Storm入门Demo

 一、简介                                             

    

       我们前面的文章对Apache Storm 是一个开源的分布式、实时、可扩展、容错的计算系统的基本知识进行熟悉之后，我们通过Storm简单的例子把应用跟基础知识结合起来。

       Storm的Topology是一个分布式实时计算应用，它通过Stream groupings把spouts和Bolts串联起来组成了流数据处理结构，Topologys在集群中一直运行，直到kill（storm kill topology-name [-w wait-time-secs]） 拓扑时扑才会结束运行。

        拓扑运行模式：本地模式和分布式模式。

 

 二、单词统计的例子                                      

    

           

          

      我们通过Spout读取文本，然后发送到第一个bolt对文本进行切割，然后在对切割好单词把相同的单词发送给第二个bolt同一个task来统计，这些过程可以利用多台服务器帮我们完成。

    组件有spout、bolt、Stream groupings（shuffleGrouping、fieldsGrouping）、Topology

 

    第一步：创建spout数据源

          

[java]  view plain  copy

1. import java.util.Map;  
2. import org.apache.storm.spout.SpoutOutputCollector;  
3. import org.apache.storm.task.TopologyContext;  
4. import org.apache.storm.topology.OutputFieldsDeclarer;  
5. import org.apache.storm.topology.base.BaseRichSpout;  
6. import org.apache.storm.tuple.Fields;  
7. import org.apache.storm.tuple.Values;  
8. import org.apache.storm.utils.Utils;  
9.   
10. /** 
11.  * 数据源 
12.  * @author zhengcy 
13.  * 
14.  */  
15. @SuppressWarnings("serial")  
16. public class SentenceSpout extends  BaseRichSpout {  
17.       
18.     private SpoutOutputCollector collector;  
19.     private String[] sentences = {  
20.             "Apache Storm is a free and open source distributed realtime computation system",  
21.             "Storm makes it easy to reliably process unbounded streams of data",  
22.             "doing for realtime processing what Hadoop did for batch processing",  
23.             "Storm is simple", "can be used with any programming language",  
24.             "and is a lot of fun to use" };  
25.     private int index = 0;  
26.   
27.     @Override  
28.     public void declareOutputFields(OutputFieldsDeclarer declarer) {  
29.         //定义输出字段描述  
30.         declarer.declare(new Fields("sentence"));  
31.     }  
32.   
33.     @SuppressWarnings("rawtypes")  
34.     public void open(Map config, TopologyContext context,SpoutOutputCollector collector) {  
35.         this.collector = collector;  
36.     }  
37.     
38.       
39.     public void nextTuple() {  
40.          if(index >= sentences.length){  
41.             return;   
42.          }  
43.          //发送字符串  
44.         this.collector.emit(new Values(sentences[index]));  
45.         index++;  
46.         Utils.sleep(1);  
47.     }  
48. }  

   第二步：实现单词切割bolt

             

[java]  view plain  copy

1. import org.apache.storm.topology.BasicOutputCollector;  
2. import org.apache.storm.topology.OutputFieldsDeclarer;  
3. import org.apache.storm.topology.base.BaseBasicBolt;  
4. import org.apache.storm.tuple.Fields;  
5. import org.apache.storm.tuple.Tuple;  
6. import org.apache.storm.tuple.Values;  
7.   
8. /** 
9.  * 切割句子 
10.  * @author zhengcy 
11.  * 
12.  */  
13. @SuppressWarnings("serial")  
14. public class SplitSentenceBolt extends BaseBasicBolt {  
15.   
16.     @Override  
17.     public void declareOutputFields(OutputFieldsDeclarer declarer) {  
18.         //定义了传到下一个bolt的字段描述  
19.         declarer.declare(new Fields("word"));  
20.     }  
21.   
22.     @Override  
23.     public void execute(Tuple input, BasicOutputCollector collector) {  
24.         String sentence = input.getStringByField("sentence");  
25.         String[] words = sentence.split(" ");  
26.         for (String word : words) {  
27.             //发送单词  
28.             collector.emit(new Values(word));  
29.         }  
30.     }  
31. }  

    第三步：对单词进行统计bolt

 

          

[java]  view plain  copy

1. import java.util.HashMap;  
2. import java.util.Map;  
3. import org.apache.storm.task.TopologyContext;  
4. import org.apache.storm.topology.BasicOutputCollector;  
5. import org.apache.storm.topology.OutputFieldsDeclarer;  
6. import org.apache.storm.topology.base.BaseBasicBolt;  
7. import org.apache.storm.tuple.Tuple;  
8.   
9. /** 
10.  * 统计单词 
11.  * @author zhengcy 
12.  * 
13.  */  
14. @SuppressWarnings("serial")  
15. public class WordCountBolt extends BaseBasicBolt {  
16.       
17.     private  Map<String, Long> counts = null;  
18.       
19.   
20.     @SuppressWarnings("rawtypes")  
21.     @Override  
22.     public void prepare(Map stormConf, TopologyContext context) {  
23.         this.counts = new HashMap<String, Long>();  
24.     }  
25.   
26.     @Override  
27.     public void cleanup() {  
28.         //拓扑结束执行  
29.        for (String key : counts.keySet()) {  
30.             System.out.println(key + " : " + this.counts.get(key));  
31.        }  
32.     }  
33.   
34.     @Override  
35.     public void execute(Tuple input, BasicOutputCollector collector) {  
36.         String word = input.getStringByField("word");  
37.         Long count = this.counts.get(word);  
38.         if (count == null) {  
39.             count = 0L;  
40.         }  
41.         count++;  
42.         this.counts.put(word, count);  
43.     }  
44.   
45.     @Override  
46.     public void declareOutputFields(OutputFieldsDeclarer declarer) {  
47.           
48.     }  
49.   
50. }  

  第四步：创建Topology拓扑

            通过Stream groupings把spouts和Bolts串联起来组成了流数据处理，并设置spout和bolt处理的并行数。

           拓扑运行模式：本地模式和分布式模式。

[java]  view plain  copy

1. import org.apache.storm.Config;  
2. import org.apache.storm.LocalCluster;  
3. import org.apache.storm.StormSubmitter;  
4. import org.apache.storm.topology.TopologyBuilder;  
5. import org.apache.storm.tuple.Fields;  
6.   
7. /** 
8.  * 单词统计拓扑 
9.  * @author zhengcy 
10.  * 
11.  */  
12. public class WordCountTopology {  
13.   
14.     public static void main(String[] args) throws Exception {  
15.   
16.         TopologyBuilder builder = new TopologyBuilder();  
17.         builder.setSpout("spout", new SentenceSpout(), 1);  
18.         builder.setBolt("split", new SplitSentenceBolt(), 2).shuffleGrouping("spout");  
19.         builder.setBolt("count", new WordCountBolt(), 2).fieldsGrouping("split", new Fields("word"));  
20.   
21.         Config conf = new Config();  
22.         conf.setDebug(false);  
23.           
24.         if (args != null && args.length > 0) {  
25.             // 集群模式  
26.             conf.setNumWorkers(2);  
27.             StormSubmitter.submitTopology(args[0], conf, builder.createTopology());  
28.         } else {  
29.             // 本地模式  
30.             LocalCluster cluster = new LocalCluster();  
31.             cluster.submitTopology("word-count", conf, builder.createTopology());  
32.             Thread.sleep(10000);    
33.             cluster.shutdown();   
34.         }  
35.     }  
36. }  

 

 三、运行拓扑                                          

   

     1、本地模式

         本地模式是我们用来本地开发调试的，不需要部署到storm集群就能运行，运行java的main函数就可以了

         

[java]  view plain  copy

1.        // 本地模式  
2. LocalCluster cluster = new LocalCluster();  
3. cluster.submitTopology("word-count", conf, builder.createTopology());  

         

       2、集群模式

         把代码生成jar，放到服务器某个目录下，例如：/usr/local/storm，并/usr/local/storm/bin目录下运行storm命令提交拓扑。

       

[html]  view plain  copy

1. >./storm jar ../stormTest.jar cn.storm.WordCountTopology WordCountTopolog  

 

         

      查看storm ui 是否提交成功拓扑

      

     

 

四、查看集群模式下拓扑的日志                                                                                       

    

    我们查看运行起来的拓扑有没有报错

 

   第一步：访问storm管理页面

                例如：http://192.168.2.200:8081/index.html

    

     访问storm管理页面并点击对应的拓扑，并查看拓扑分布到哪几台服务器

                   

 

         第二步：查看日志

 

            tail -f  logs/workers-artifacts/拓扑ID/端口/worker.log

                      

                   例如：

                         

[html]  view plain  copy

1. >tail -f  logs/workers-artifacts/WordCountTopology-1-1497095813/6700/worker.log  

                 

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/congcong68/article/details/73013142