JStorm源代码阅读——顶层设计

最让人困惑就是IBasic和IBoltIBot和两给类。区别在于一个要求在pepare阶段传入OutputCollector，而另一个则在execute阶段。

public interface IBasicBolt extends IComponent {
    void prepare(Map stormConf, TopologyContext context);

    /**
     * Process the input tuple and optionally emit new tuples based on the input tuple.
     * 
     * All acking is managed for you. Throw a FailedException if you want to fail the tuple.
     */
    void execute(Tuple input, BasicOutputCollector collector);

    void cleanup();
}


public interface IBolt extends Serializable {
    /**
     * Called when a task for this component is initialized within a worker on the cluster. It provides the bolt with the environment in which the bolt
     * executes.
     * 
     * <p>
     * This includes the:
     * </p>
     * 
     * @param stormConf The Storm configuration for this bolt. This is the configuration provided to the topology merged in with cluster configuration on this
     *            machine.
     * @param context This object can be used to get information about this task's place within the topology, including the task id and component id of this
     *            task, input and output information, etc.
     * @param collector The collector is used to emit tuples from this bolt. Tuples can be emitted at any time, including the prepare and cleanup methods. The
     *            collector is thread-safe and should be saved as an instance variable of this bolt object.
     */
    void prepare(Map stormConf, TopologyContext context, OutputCollector collector);

    /**
     * Process a single tuple of input. The Tuple object contains metadata on it about which component/stream/task it came from. The values of the Tuple can be
     * accessed using Tuple#getValue. The IBolt does not have to process the Tuple immediately. It is perfectly fine to hang onto a tuple and process it later
     * (for instance, to do an aggregation or join).
     * 
     * <p>
     * Tuples should be emitted using the OutputCollector provided through the prepare method. It is required that all input tuples are acked or failed at some
     * point using the OutputCollector. Otherwise, Storm will be unable to determine when tuples coming off the spouts have been completed.
     * </p>
     * 
     * <p>
     * For the common case of acking an input tuple at the end of the execute method, see IBasicBolt which automates this.
     * </p>
     * 
     * @param input The input tuple to be processed.
     */
    void execute(Tuple input);

    /**
     * Called when an IBolt is going to be shutdown. There is no guarentee that cleanup will be called, because the supervisor kill -9's worker processes on the
     * cluster.
     * 
     * <p>
     * The one context where cleanup is guaranteed to be called is when a topology is killed when running Storm in local mode.
     * </p>
     */
    void cleanup();
}

Storm的设计者希望

如果使用IBasicBolt 不需要手动调用ack方法
如果使用IRichBolt 手动调用ack方法

我们再上面图中补齐一些其他的关系。发现实际上对Bisicbolt实际上是转化为richbolt。