Storm实例



package com.uplooking.bigdata.storm.local;

import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.generated.StormTopology;
import org.apache.storm.spout.SpoutOutputCollector;
import org.apache.storm.task.OutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.TopologyBuilder;
import org.apache.storm.topology.base.BaseRichBolt;
import org.apache.storm.topology.base.BaseRichSpout;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;

import java.util.Map;

/**
 * 统计实现数字累加求和的案例：数据源不断产生递增数字，对产生的数字累加求和
 * 我们的Storm topology由什么做成？
 * 数据源Spout
 *       产生不断递增的数字
 * 数据处理Bolt
 *      获取Spout产生的数据，进行累加，输出累加的结果
 * 将二者Spout和Bolt组织成为一个Topology交给Storm集群进行处理
 *
 */
public class LocalSumTopology {
    /**
     * 当前spout用于接收数据源的数据
     */
    static class SumNumSpout extends BaseRichSpout {
        private Map conf;
        private TopologyContext context;
        private SpoutOutputCollector collector;

        /**
         * 这是一个生命周期方法，一个SumNumSpout实例只运行一次，主要完成初始化的参数设置
         * @param conf      ---->storm程序以及storm集群相关的配置信息
         * @param context   ---->整个Topology上下文对象，可以通过该context获得相关topology应用属性
         * @param collector ---->主要用于收集数据，并将数据发射到下一个阶段
         */
        public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
            this.conf = conf;
            this.context = context;
            this.collector = collector;
        }
        /*
            storm程序只要nextTuple方法，完成数据采集，处理，发射到下游bolt
         */
        int num = 0;
        public void nextTuple() {
//            num++;//数据自增
//            Values
            System.out.println("spout产生的数据：" + num);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            collector.emit(new Values(num++));//使用collector发射数据
        }

        //是对发射到下游bolt中的数据的一个说明
        public void declareOutputFields(OutputFieldsDeclarer declarer) {
            declarer.declare(new Fields("num"));
        }
    }

    /**
     * 对接收到spout中的数据的处理逻辑
     */
    static class SumNumBolt extends BaseRichBolt {
        private Map conf;
        private TopologyContext context;
        private OutputCollector collector;

        public void prepare(Map conf, TopologyContext context, OutputCollector collector) {
            this.conf = conf;
            this.context = context;
            this.collector = collector;
        }
        int sum = 0;
        //这里面对接收上游数据的一个处理
        public void execute(Tuple tuple) {
            int num = tuple.getIntegerByField("num");
            sum += num;
            System.out.println("bolt累加之后的结果值：" + sum);

        }

        //类似于spout中的declareOutputFields方法，如果还有下游bolt操作，那需要在这里面进行一个说明
        //如果没有下面bolt操作，这个方法就可以不用进行任何操作
        public void declareOutputFields(OutputFieldsDeclarer declarer) {

        }
    }

    public static void main(String[] args) {
        //主要就是用来组织spout和bolt成为一个Topology拓扑，提交到集群

        //构建Topology是通过TopologyBuilder来进行设置
        TopologyBuilder topologyBuilder = new TopologyBuilder();
        //set spout
        //spout_id-->
        String spoutID = "sumNumSpout_id";
        topologyBuilder.setSpout(spoutID, new SumNumSpout());
        //设置bolt
        //.shuffleGrouping(spoutID)--->设置数据来源
        String boltID = "sumNumBolt_id";
        topologyBuilder.setBolt(boltID, new SumNumBolt()).shuffleGrouping(spoutID);
        //产生topology
        StormTopology stormTopology = topologyBuilder.createTopology();

        //因为咱们本地运行，所以使用LocalCluster就可以
        LocalCluster cluster = new LocalCluster();
        /**
         * topologyName
         * Map---->configuration
         * StormTopology
         */
        String topologyName = LocalSumTopology.class.getSimpleName();
        Config config = new Config();
        cluster.submitTopology(topologyName, config, stormTopology);
    }
}