Storm实现单词统计代码

  

import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.commons.io.FileUtils;

import backtype.storm.Config;
import backtype.storm.LocalCluster;
import backtype.storm.spout.SpoutOutputCollector;
import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.TopologyBuilder;
import backtype.storm.topology.base.BaseRichBolt;
import backtype.storm.topology.base.BaseRichSpout;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;
import backtype.storm.utils.Utils;

/**
 * 单词计数
 * 监控d:\test目录下面的文件，统计单词出现的总次数
 * 当有新文件出现的时候，也要能解析出来
 * 
 * @author Administrator
 *
 */
public class LocalTopologyWordCount {
    
    
    /**
     * spout需要继承baserichspout，实现未实现的方法
     * @author Administrator
     *
     */
    public static class DataSourceSpout extends BaseRichSpout{
        private Map conf;
        private TopologyContext context;
        private SpoutOutputCollector collector;
        
        /**
         * 初始化方法，只会执行一次
         * 在这里面可以写一个初始化的代码
         * Map conf：其实里面保存的是topology的一些配置信息
         * TopologyContext context：topology的上下文，类似于servletcontext
         * SpoutOutputCollector collector：发射器，负责向外发射数据(tuple)
         */
        @Override
        public void open(Map conf, TopologyContext context,
                SpoutOutputCollector collector) {
            this.conf = conf;
            this.context = context;
            this.collector = collector;
        }

        /**
         * 这个方法是spout中最重要的方法，
         * 这个方法会被storm框架循环调用，可以理解为这个方法是在一个while循环之内
         * 每调用一次，会向外发射一条数据
         */
        @Override
        public void nextTuple() {
            //获取指定目录下面的新文件，
            Collection<File> listFiles = FileUtils.listFiles(new File("d:\test"), new String[]{"txt"}, true);
            //分别读取每个文件
            for (File file : listFiles) {
                try {
                    List<String> readLines = FileUtils.readLines(file);
                    for (String line : readLines) {
                        //把每一行封装成一个tuple，发射出去
                        this.collector.emit(new Values(line));
                    }
                    FileUtils.moveFile(file, new File(file.getAbsolutePath()+System.currentTimeMillis()));//给文件该名字,否则会一直处理这个文件.
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
        /**
         * 声明输出字段
         */
        @Override
        public void declareOutputFields(OutputFieldsDeclarer declarer) {
            //给values中的数据起个名字，方便后面的bolt从这个values中取数据
            //fields中定义的参数和values中传递的数值是一一对应的
            declarer.declare(new Fields("line"));
        }
        
    }
    
    
    /**
     * 自定义bolt需要实现baserichbolt
     * @author Administrator
     *
     */
    public static class SplitBolt extends BaseRichBolt{
        private Map stormConf; 
        private TopologyContext context;
        private OutputCollector collector;
        
        /**
         * 和spout中的open方法意义一样
         */
        @Override
        public void prepare(Map stormConf, TopologyContext context,
                OutputCollector collector) {
            this.stormConf = stormConf;
            this.context = context;
            this.collector = collector;
        }

        /**
         * 是bolt中最重要的方法，当spout发射一个tuple出来，execute也会被调用，需要对spout发射出来的tuple进行处理
         */
        @Override
        public void execute(Tuple input) {
            //获取每一行数据进行切割
            String line = input.getStringByField("line");
            String[] splits = line.split("	");
            //把切割出来的单词一个一个发射出去
            for (String word : splits) {
                this.collector.emit(new Values(word));
            }
            
        }
        
        //在这没必要定义了，因为execute方法中没有向外发射tuple，所以就不需要声明了。
        //如果nextTuple或者execute方法中向外发射了tuple，那么declareOutputFields必须要声明，否则不需要声明
        /**
         * 声明输出字段
         */
        @Override
        public void declareOutputFields(OutputFieldsDeclarer declarer) {
            declarer.declare(new Fields("word"));
        }
        
    }
    
    
    
    /**
     * 自定义bolt需要实现baserichbolt
     * @author Administrator
     *
     */
    public static class CountBolt extends BaseRichBolt{
        private Map stormConf; 
        private TopologyContext context;
        private OutputCollector collector;
        
        /**
         * 和spout中的open方法意义一样
         */
        @Override
        public void prepare(Map stormConf, TopologyContext context,
                OutputCollector collector) {
            this.stormConf = stormConf;
            this.context = context;
            this.collector = collector;
        }

        HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
        /**
         * 是bolt中最重要的方法，当spout发射一个tuple出来，execute也会被调用，需要对spout发射出来的tuple进行处理
         */
        @Override
        public void execute(Tuple input) {
            //获取每一个单词
            String word = input.getStringByField("word");
            //在map中进行统计
            Integer integer = hashMap.get(word);
            if(integer==null){
                integer=0;
            }
            integer++;
            hashMap.put(word, integer);
            //把这个统计结果打印到控制台
            Utils.sleep(1000);
            System.out.println("=========================================");
            for (Entry<String, Integer> entry : hashMap.entrySet()) {
                System.out.println(entry);
            }
        }
        
        //在这没必要定义了，因为execute方法中没有向外发射tuple，所以就不需要声明了。
        //如果nextTuple或者execute方法中向外发射了tuple，那么declareOutputFields必须要声明，否则不需要声明
        /**
         * 声明输出字段
         */
        @Override
        public void declareOutputFields(OutputFieldsDeclarer declarer) {
        }
        
    }
    /**
     * 注意：在组装topology的时候，组件的id在定义的时候，名称不能以__开头。__是系统保留的
     * @param args
     */
    public static void main(String[] args) {
        //组装topology
        TopologyBuilder topologyBuilder = new TopologyBuilder();
        topologyBuilder.setSpout("spout1", new DataSourceSpout());
        //.shuffleGrouping("spout1"); 表示让MyBolt接收MySpout发射出来的tuple
        topologyBuilder.setBolt("bolt1", new SplitBolt()).shuffleGrouping("spout1");
        topologyBuilder.setBolt("bolt2", new CountBolt()).shuffleGrouping("bolt1");
        
        //创建本地storm集群
        LocalCluster localCluster = new LocalCluster();
        localCluster.submitTopology("wordCountTopology", new Config(), topologyBuilder.createTopology());
    }
}