Dependency injection apachestorm拓扑中的依赖注入

小背景：我正在使用ApacheStorm开发一个拓扑，我想为什么不在其中使用依赖注入，但我不确定当拓扑部署到集群时，它在集群环境中的行为。我开始寻找DI是否适合在Storm拓扑中使用的答案，我遇到了一些关于ApacheSpark的线程，其中提到序列化将是一个问题，并看到了ApacheStorm的一些响应。最后，我决定用GoogleGuice编写一个拓扑示例，看看会发生什么

我用两个螺栓编写了一个示例拓扑，并使用GoogleGuice注入依赖项。第一个bolt发出一个tick元组，然后第一个bolt创建消息，bolt在日志上打印消息，并调用一些类，这些类执行相同的操作。然后，该消息被发送到第二个螺栓，并在那个里使用相同的打印逻辑

第一个螺栓

public class FirstBolt extends BaseRichBolt {
    private OutputCollector collector;
    private static int count = 0;
    private FirstInjectClass firstInjectClass;

    @Override
    public void prepare(Map map, TopologyContext topologyContext, OutputCollector outputCollector) {
        collector = outputCollector;
        Injector injector = Guice.createInjector(new Module());
        firstInjectClass = injector.getInstance(FirstInjectClass.class);
    }

    @Override
    public void execute(Tuple tuple) {
        count++;
        String message = "Message count "+count;
        firstInjectClass.printMessage(message);
        log.error(message);

        collector.emit("TO_SECOND_BOLT", new Values(message));

        collector.ack(tuple);
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {
        outputFieldsDeclarer.declareStream("TO_SECOND_BOLT", new Fields("MESSAGE"));
    }

    @Override
    public Map<String, Object> getComponentConfiguration() {
        Config conf = new Config();
        conf.put(Config.TOPOLOGY_TICK_TUPLE_FREQ_SECS,   10);
        return conf;
    }
}

public class SecondBolt extends BaseRichBolt {
    private OutputCollector collector;
    private SecondInjectClass secondInjectClass;

    @Override
    public void prepare(Map map, TopologyContext topologyContext, OutputCollector outputCollector) {
        collector = outputCollector;
        Injector injector = Guice.createInjector(new Module());
        secondInjectClass = injector.getInstance(SecondInjectClass.class);
    }

    @Override
    public void execute(Tuple tuple) {
        String message = (String) tuple.getValue(0);
        secondInjectClass.printMessage(message);
        log.error("SecondBolt {}",message);

        collector.ack(tuple);
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {
    }
}

在其中注入依赖项的类

public class FirstInjectClass {
    FirstInterface firstInterface;

    private final String prepend = "FirstInjectClass";

    @Inject
    public FirstInjectClass(FirstInterface firstInterface) {
        this.firstInterface = firstInterface;
    }

    public void printMessage(String message){
        log.error("{} {}", prepend, message);
        firstInterface.printMethod(message);
    }
}

用于绑定的接口

public interface FirstInterface {
    void printMethod(String message);
}

public interface SecondInterface {
    void printMethod(String message);
}

接口的实现

public class FirstInterfaceImpl implements FirstInterface{
    private final String prepend = "FirstInterfaceImpl";
    public void printMethod(String message){
        log.error("{} {}", prepend, message);
    }
}

public class SecondInterfaceImpl implements SecondInterface{
    private final String prepend = "SecondInterfaceImpl";
    public void printMethod(String message){
        log.error("{} {}", prepend, message);
    }
}

与另一个通过DI接收依赖项的类的方式相同

public class SecondInjectClass {
    SecondInterface secondInterface;
    private final String prepend = "SecondInjectClass";

    @Inject
    public SecondInjectClass(SecondInterface secondInterface) {
        this.secondInterface = secondInterface;
    }

    public void printMessage(String message){
        log.error("{} {}", prepend, message);
        secondInterface.printMethod(message);
    }
}

另一个用于绑定的接口

public interface FirstInterface {
    void printMethod(String message);
}

public interface SecondInterface {
    void printMethod(String message);
}

第二接口的实现

public class FirstInterfaceImpl implements FirstInterface{
    private final String prepend = "FirstInterfaceImpl";
    public void printMethod(String message){
        log.error("{} {}", prepend, message);
    }
}

public class SecondInterfaceImpl implements SecondInterface{
    private final String prepend = "SecondInterfaceImpl";
    public void printMethod(String message){
        log.error("{} {}", prepend, message);
    }
}

模块类

public class Module extends AbstractModule {
    @Override
    protected void configure() {
        bind(FirstInterface.class).to(FirstInterfaceImpl.class);
        bind(SecondInterface.class).to(SecondInterfaceImpl.class);
    }
}

这里没什么特别的，只有两个螺栓和两个DI类。我在服务器上部署了它，它工作得很好。但问题是，我必须在每个螺栓中初始化喷油器，这使我怀疑它的副作用是什么

这个实现很简单，只需两个螺栓。。如果我有更多的螺栓怎么办？如果我必须在所有螺栓中初始化喷油器，它会对拓扑产生什么影响

若我试图在prepare方法之外初始化注入器，那个么序列化就会出错