我有一个这样的接口/实现：

public interface Processor {
    void processMessage(Message m);
}

@Component
public class FooAProcessor implements Processor {
    private FooA fooA;

    public FooAProcessor(FooA fooA) {
        this.fooA = fooA;
    }

    @Override
    public void processMessage(Message m) {
        //do stuff
    }
}

@Component
public class FooBProcessor implements Processor {
    private FooA fooA;

    public FooBProcessor(FooA fooA) {
        this.fooA = fooA;
    }

    @Override
    public void processMessage(Message m) {
        //do stuff
    }
}

字符串
FooA bean很简单，如下所示：

@Component
public class FooA {
    //stuff
}

型
消息类：

public class Message {
    private Class clazz;
}

型
我正在从队列中提取消息。我需要提供一个具体的处理器来适当地处理不同类型的消息。下面是消息接收器：

public class MessageReceiver {
    public void handleMessage(Message m) {
        Processor processor = //get concrete implementation from Message clazz
        processor.processMessage(m);
    }
}

型
如何使用类名/对象来定义Processor的具体实现？
我的第一个想法是开发某种类型的工厂，它接受一个类并提供具体的实现。类似于这样：

@Component
public class ProcessorFactory {
    private FooAProcessor fooAProcessor;
    private FooBProcessor fooBProcessor;

    public ProcessorFactory(FooAProcessor fooAProcessor, FooBProcessor fooBProcessor) {
        this.fooAProcessor = fooAProcessor;
        this.fooBProcessor = fooBProcessor;
    }

    public Processor getFactory(Class clazz) {
        if(clazz.isAssignableFrom(FooAProcessor.class)) {
            return fooAProcessor;
        }
    }
}

型
或者像这样使用应用程序上下文：

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.getBean(clazz);

型
这是解决这个问题的最好方法吗？有更好的做法吗？