storm wordcount

最新推荐文章于 2023-10-25 12:13:18 发布
最新推荐文章于 2023-10-25 12:13:18 发布
阅读量172 收藏
点赞数
文章标签： storm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38710236/article/details/81038631
版权

准备

前面几篇文章已经介绍了如何搭建storm集群。接下来学习如何编写storm代码，使用maven构建，本地模拟集群测试代码

编码

maven 配置

使用maven来配置需要的jar包，只需要一个0.9.2版本的 storm即可

   <dependencies>
        <dependency>
            <groupId>org.apache.storm</groupId>
            <artifactId>storm-core</artifactId>
            <version>0.9.2-incubating</version>
        </dependency>
    </dependencies>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
创建SentenceSpout

创建sentenceSpout作为storm的数据源，需要继承 BaseRichSpout ，它需要重写几个方法

     /*
    spout初始化时调用这个方法
    map包含storm配置信息
    TopologyContext对象提供了topology中组件的信息
    SpoutOutputCollector对象提供了发射tuple的方法
     */
    public void open(Map config, TopologyContext context, SpoutOutputCollector collector){
         this.collector=collector;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

open方法是spout的初始化时会调用的方法，传入该方法的SpoutOutputCollector对象提供了向外发射数据流的方法

 /*
     声明spout会发射一个数据流，其中的tuple包含一个字段sentence
     */
    public void declareOutputFields(OutputFieldsDeclarer declarer){
        declarer.declare(new Fields("sentence"));

    };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

declareOutputFields方法声明了该spout会发射一个数据流，该数据流包含一个key，名称为 sentence

   /*
     Storm通过调用这个方法向输出的collector发射tuple
    */
    public void nextTuple(){

        if(index < sentences.length){
            this.collector.emit(new Values(sentences[index]));
            index++;
        }
        else{
            index=0; //如果不让index归0，sentences只会发送一次
        }

        Utils.waitForMillis(1);
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

storm会调用spout的nextTuple，因此我们需要在nextTuple中使用collector.emit()方法向外发射数据流。 
完成spout如下：


import backtype.storm.spout.SpoutOutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseRichSpout;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Values;

import java.util.Map;

/**
 * Created by chenhong on 16/1/25.
 */
public class SentenceSpout extends BaseRichSpout{

    private SpoutOutputCollector collector;

    private String[] sentences={
            "my dog has fleas",
            "i like cold beverages",
            "the dog ate my homework",
            "don't hava a cow man ",
            "i don't think i like fleas"
    };

    private int index=0;


    /*
     声明spout会发射一个数据流，其中的tuple包含一个字段sentence
     */
    public void declareOutputFields(OutputFieldsDeclarer declarer){
        declarer.declare(new Fields("sentence"));

    };
    /*
    spout初始化时调用这个方法
    map包含storm配置信息
    TopologyContext对象提供了topology中组件的信息
    SpoutOutputCollector对象提供了发射tuple的方法
     */
    public void open(Map config, TopologyContext context, SpoutOutputCollector collector){
         this.collector=collector;
    }

    /*
     Storm通过调用这个方法向输出的collector发射tuple
    */
    public void nextTuple(){

        if(index < sentences.length){
            this.collector.emit(new Values(sentences[index]));
            index++;
        }
        else{
            index=0; //如果不让index归0，sentences只会发送一次
        }

        Utils.waitForMillis(1);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
创建SplitSentenceBolt

创建SplitSentenceBolt，对spout发射的句子按空格分隔成单词，需要继承BaseRichBolt，它需要重写一下几个方法：

     /*
     bolt初始化时调用
     */
    public void prepare(Map config ,TopologyContext context,OutputCollector collector){
        this.collector = collector;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

prepare在bolt初始化时会被调用，类似spout的open方法，OutputCollector用来向外发射一个数据流

    /*
     声明每个tuple包含一个字段 word
     */
    public void declareOutputFields(OutputFieldsDeclarer declarer){
        declarer.declare(new Fields("word"));
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

declareOutputFields表示该bolt会向外发射一个数据流，该数据流包含一个key，key的名称为 word

  /*
     每当从订阅的数据流中接收一个tuple，都会调用这个方法
     */
    public void execute(Tuple tuple){
        String sentence = tuple.getStringByField("sentence");
        String[] words = sentence.split(" ");
        for(String word : words){
            this.collector.emit(new Values(word));
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

该方法会在bolt接收到上游发射的数据流后被调用 
完成代码如下：

import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseRichBolt;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;

import java.util.Map;

/**
 * Created by chenhong on 16/1/25.
 */
public class SplitSentenceBolt extends BaseRichBolt{

    private OutputCollector collector;

    /*
     bolt初始化时调用
     */
    public void prepare(Map config ,TopologyContext context,OutputCollector collector){
        this.collector = collector;
    }

    /*
     声明每个 tuple包含一个字段 word
     */
    public void declareOutputFields(OutputFieldsDeclarer declarer){
        declarer.declare(new Fields("word"));
    }

    /*
     每当从订阅的数据流中接收一个tuple，都会调用这个方法
     */
    public void execute(Tuple tuple){
        String sentence = tuple.getStringByField("sentence");
        String[] words = sentence.split(" ");
        for(String word : words){
            this.collector.emit(new Values(word));
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
创建WordCountBolt

WordCountBolt用来对SplitSentenceBolt发射的单词进行计数，WordCountBolt需要实现的方法与SplitSentenceBolt类似，因此不再对方法多做解释。完成代码如下：

import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseRichBolt;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by chenhong on 16/1/25.
 */
public class WordCountBolt extends BaseRichBolt{
    private OutputCollector collector;

    private HashMap<String,Long> counts = null;

    public void prepare(Map config , TopologyContext context,OutputCollector collector){
        this.collector = collector;
        this.counts = new HashMap<String, Long>();
    }



    public void execute(Tuple tuple){
        String word = tuple.getStringByField("word");
        Long count = this.counts.get(word);
        if(count ==null){
            count =0L;
        }
        count++;
        this.counts.put(word,count);
        this.collector.emit(new Values(word,count));
    }

    public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {
        outputFieldsDeclarer.declare(new Fields("word","count"));
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
创建ReportBolt

ReportBolt作为最后一个Bolt，它的作用是对计数完的单词进行打印或持久化到数据库。因此无需再向外发射数据流。因此它的declareOutputFields不需要声明declare

      /*
     该bolt位于末端,所以declareOutputFields为空
    **/
    public void declareOutputFields(OutputFieldsDeclarer declarer){

    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

在该计数完成后，将计数结果打印，因此需要重写cleanup方法

      /*
     cleanup方法用来释放bolt占用的资源
     */
    public void cleanup(){
        System.out.println("--- FINAL COUNTS ---");
        List<String> keys = new ArrayList<String>();
        keys.addAll(this.counts.keySet());
        Collections.sort(keys);
        for(String key: keys){
            System.out.println(key+" : "+this.counts.get(key));

        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

完成代码如下：

import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseRichBolt;
import backtype.storm.tuple.Tuple;

import java.util.*;

/**
 * Created by chenhong on 16/1/25.
 */
public class ReportBolt extends BaseRichBolt {
    private HashMap<String,Long> counts =null;

    public void prepare(Map config, TopologyContext context, OutputCollector collector){
        this.counts = new HashMap<String, Long>();
    }

    public void execute(Tuple tuple){
        String word = tuple.getStringByField("word");
        Long count = tuple.getLongByField("count");
        this.counts.put(word,count);

    }

    /*
     该bolt位于末端,所以declareOutputFields为空
    **/
    public void declareOutputFields(OutputFieldsDeclarer declarer){

    }


    /*
     cleanup方法用来释放bolt占用的资源
     */
    public void cleanup(){
        System.out.println("--- FINAL COUNTS ---");
        List<String> keys = new ArrayList<String>();
        keys.addAll(this.counts.keySet());
        Collections.sort(keys);
        for(String key: keys){
            System.out.println(key+" : "+this.counts.get(key));

        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
创建WordCountTopology

现在已经实现了一个 SentenceSpout， SplitSentenceBolt，WordCountBolt，ReportBolt。 我们需要将SentenceSpout作为数据源，将句子发射给SplitSentenceBolt， SplitSentenceBolt将接收到的句子按照空格进行分割成单词发射给WordCountBolt，WordCountBolt对单词进行计数，并将计数结果发送给ReportBolt，注意WordCountBolt的计数结果随着程序进行随时变化，因此ReportBolt中的计数结果也随时更新。在程序结束后，将ReportBolt记录的单词和计数打印出来。完成代码如下：

import backtype.storm.Config;
import backtype.storm.LocalCluster;
import backtype.storm.topology.TopologyBuilder;
import backtype.storm.tuple.Fields;

/**
 * Created by chenhong on 16/1/25.
 */
public class WordCountTopology {

    private static final String SENTENCE_SPOUT_ID="sentence-spout";
    private static final String SPILL_BOLT_ID ="split-bolt";
    private static final String COUNT_BOLT_ID ="count-bolt";
    private static final String REPORT_BOLT_ID="report-bolt";
    private static final String TOPOLOGY_NAME="word-count-topology";

    public static void main(String[] args){

        SentenceSpout spout = new SentenceSpout();
        SplitSentenceBolt splitBolt = new SplitSentenceBolt();
        WordCountBolt countBolt = new WordCountBolt();
        ReportBolt reportBolt = new ReportBolt();

        TopologyBuilder builder = new TopologyBuilder();

        //注册一个sentence spout并且赋值给其唯一的ID
        builder.setSpout(SENTENCE_SPOUT_ID, spout);
        //注册一个splitsentencebolt ，这个bolt订阅sentencespout发射出来的数据流,shuffleGrouping方法告诉
        //storm要将类sentenceSpout发射的tuple随机均匀地分发给SplitSentenceBolt实例
        builder.setBolt(SPILL_BOLT_ID,splitBolt).shuffleGrouping(SENTENCE_SPOUT_ID);
        //fieldsGrouping()方法来保证所有 word字段值相同的tuple会被路由到同一个wordcountbolt实例中
        builder.setBolt(COUNT_BOLT_ID,countBolt).fieldsGrouping(SPILL_BOLT_ID, new Fields("word"));
        //globalGrouping方法将WordCountBolt发射的所有tuple路由到唯一的ReportBolt任务中
        builder.setBolt(REPORT_BOLT_ID,reportBolt).globalGrouping(COUNT_BOLT_ID);

        //config对象代表了对topology所有组件全局生效的配置参数集合，会分发给各个spout和bolt的open(),prepare()方法
        Config config = new Config();
        //LocalCluster类在本地开发环境来模拟一个完整的storm集群
        LocalCluster cluster = new LocalCluster();
        cluster.submitTopology(TOPOLOGY_NAME,config,builder.createTopology());
        Utils.waitForSeconds(5);
        cluster.killTopology(TOPOLOGY_NAME);
        cluster.shutdown();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

运行结果

注意单词计数的结果与机器性能有关

a : 432
ate : 432
beverages : 432
cold : 432
cow : 432
dog : 864
don't : 864
fleas : 864
has : 432
hava : 432
homework : 432
i : 1296
like : 864
man : 432
my : 864
the : 432
think : 432
我思念的城市ZZZ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Storm的WordCount实例
03-19
Storm的WordCount实例。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
Storm入门程序wordCount
fa124607857的博客
11-07 600
1.1、storm是什么 storm是twitter公司开源贡献给apache的一款实时流式处理的一个开源软件，主要用于解决数据的实时计算以及实时的处理等方面的问题 1.2、storm的特点 Storm是一个开源的分布式实时计算系统，可以简单、可靠的处理大量的数据流。Storm有很多使用场景：如实时分析，在线机器学习，持续计算，分布式RPC，ETL等等。Sto...
【Storm】【三】本地模式
鸟人的博客
02-23 784
1、本地模式(Local Mode)： 即Topology（相当于一个任务，后续会详细讲解） 运行在本地机器的单一JVM上，这个模式主要用来开发、调试。2、远程模式(Remote Mode):在这个模式，我们把我们的Topology提交到集群，在这个模式中，Storm的所有组件都是线程安全的，因为它们都会运行在不同的Jvm或物理机器上，这个模式就是正式的生产模式。
storm学习（1） word_count 程序
ch717828的专栏
08-16 3428
准备前面几篇文章已经介绍了如何搭建storm集群。接下来学习如何编写storm代码，使用maven构建，本地模拟集群测试代码编码maven 配置使用maven来配置需要的jar包，只需要一个0.9.2版本的 storm即可 <dependencies> <dependency> <groupId>org.apache.storm</groupId>
storm入门简介及WordCount代码解析（一）
liuyanwu的博客
07-14 1458
大数据中数据处理有两种基本的方式：批处理和实时流处理，在大数据组件中，Hadoop中的MapReduce可以处理批处理，对应的Strom即为处理实时流数据的组件。 Storm是一个开源的分布式实时计算系统。
storm-wordcount例子
02-24
《深入理解Storm-Wordcount实例》 Storm是一个分布式实时计算系统，它被广泛应用于大数据处理领域，尤其是在实时数据流分析方面。"storm-wordcount"是Storm中的一个经典示例，用于演示如何处理实时数据流并进行简单...
Storm本地模式WordCount亲测可用
02-25
**Storm本地模式WordCount亲测可用** 在大数据处理领域，Apache Storm是一个实时计算框架，它被广泛用于处理无界数据流。"Storm本地模式"是Storm提供的一种在单机环境中进行开发和测试的机制，无需分布式环境即可...
storm_wordcount.zip
08-01
【标题】"storm_wordcount.zip" 是一个基于Java开发的Apache Storm项目，主要实现的功能是对英语单词进行实时统计。Storm是一个分布式实时计算系统，能够处理海量数据流，并保证每个事件只被处理一次（Exactly-once...
jstorm2.2.1执行wordcount
09-16
本项目主要实现的功能是：统计单词的个数 jdk1.8 jstorm2.2.1 执行步骤： 1. 本地正确安装maven 2. 本地正确安装zookeeper,并启动 3. Idea导入项目源码，以...4. 可分别运行random或wordcount下topology下的main类
在windows10下搭建Storm并运行WordCount详解（单机版）！
小兵qwer的专栏
11-26 798
发布时间：2018-04-10 来源：网络 上传者：用户 关键字: 单机版 搭建 详解 WordCount windows10 运行 Storm 发表文章 摘要：作为主流的大数据处理平台,不同于批处理的Hadoop,Storm的实时计算以及拓扑结构有其独有的优势(当然,只是针对于不同的情况下)。初学Storm,网上的教程大都是在Linux下搭建的平台,也有少许windows下搭建的,这里...
Storm实战之WordCount
cufu3352的博客
03-06 189
在storm环境部署完毕，并正确启动之后，现在就可以真正进入storm开发了，按照惯例，以wordcount作为开始。 这个例子很简单，核心组件包括：一个spout，两个bolt，一个Topology。 spout从一个路径...
大数据-Storm流式框架（二）--wordcount案例
最新发布
yaya_jn的博客
10-25 1289
storm软件包中lib目录下的所有jar包。
大数据技术基础实验十五：Storm实验——实时WordCountTopology
北天的博客
11-18 1770
大数据技术基础实验十五，利用Storm集群实现实时WordCountTopology。
storm实践:用storm写wordcount
ForgetThatNight的博客
06-30 1271
1、编程模型 DataSource：外部数据源 Spout：接受外部数据源的组件，将外部数据源转化成Storm内部的数据，以Tuple为基本的传输单元下发给Bolt Bolt:接受Spout发送的数据，或上游的bolt的发送的数据。根据业务逻辑进行处理。发送给下一个Bolt或者是存储到某种介质上。介质可以是Redis可以是mysql，或者其他。 Tuple：Storm内部中数据传输的基本单元，里面...
storm程序-单词统计wordcount
Tomorrow never comes
12-16 1747
spout代码：public class MyLocalFileSpout extends BaseRichSpout { public static final String FILE_PATH = "/root/1.log"; // public static final String FILE_PATH = "D:\\1.log"; private SpoutOutput
storm编程-项目实战篇-wordcount程序
allowancedebug的博客
03-05 359
部分转载： （1）Open() 是初始化方法 （2）close() 在该spout关闭前执行，但是并不能得到保证其一定被执行，kill -9时不执行，Storm kill {topoName} 时执行 （3）activate() 当Spout已经从失效模式中激活时被调用。该Spout的nextTuple()方法很快就会被调用。 （4）deactivate() 当Spout已经失效...
Storm案例：WordCount
weixin_46235157的博客
03-20 414
Storm案例：WordCount B.WordCount 首先定义一个类继承BaseRichSpout,需要实现其方法,在这个类你需要产生数据并发送出去 public static class DataSourceSpout extends BaseRichSpout { @Override public void open(Map conf, Topolog...
storm——本地eclipse上调试wordcount程序
赶路人儿
09-19 2326
通常，对于hadoop或者storm这种任务类型的程序，我们都希望能够在本地进行一次调试，然后再提交到集群上跑任务。 storm和hadoop类似，有本地模式和集群模式。相比hadoop而言，storm的本地模式更加简单，不需要在本地（windows环境）安装任何storm的软件或者工具等（什么都不需要额外安装，只需要maven引入storm的jar即可）。本文就是如何在windows上调试
Storm流处理框架入门教程
例如，创建一个简单的WordCount拓扑，包含一个读取输入的spout和一个执行单词计数的bolt。 3. **Bolt和Spout编程**: Spout是数据流的源头，负责从外部数据源（如Kafka或TCP套接字）拉取数据。Bolt处理这些数据，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值