storm词频统计

原创

mob649e815ecee0 2024-10-05 06:04:30 ©著作权

©著作权归作者所有：来自51CTO博客作者mob649e815ecee0的原创作品，请联系作者获取转载授权，否则将追究法律责任

Storm 词频统计实现指南

Apache Storm 是一个开源的实时计算系统，广泛应用于实时数据分析。本文将教你如何在 Storm 中实现词频统计，以便你能更好地理解其工作流程。

整体流程

下面是实现 Storm 词频统计的步骤：

步骤	描述
1	设置 Storm 环境
2	编写 Spout
3	编写 Bolt
4	创建 Topology
5	提交 Topology

步骤详细说明

1. 设置 Storm 环境

首先，你需要安装 Apache Storm 并启动集群。可以通过以下命令来启动 Storm：

# 启动 zookeeper
bin/zookeeper-server-start.sh config/zookeeper.properties &

# 启动 storm nimbus
bin/storm nimbus &

# 启动 storm supervisor
bin/storm supervisor &

2. 编写 Spout

Spout 是 Storm 拓扑中的数据源。我们将创建一个简单的 Spout，随机生成一些单词。

import org.apache.storm.spout.SpoutOutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.spout.ISpoutOutputCollector;
import org.apache.storm.topology.BasicOutputCollector;
import org.apache.storm.tuple.Values;
import org.apache.storm.Config;
import org.apache.storm.topology.BasicOutputCollector;

import java.util.Map;
import java.util.Random;

public class WordSpout implements BaseRichSpout {
    private SpoutOutputCollector collector;
    private Random random;

    @Override
    public void open(Map config, TopologyContext context, SpoutOutputCollector collector) {
        this.collector = collector;
        this.random = new Random();
    }

    @Override
    public void nextTuple() {
        String[] words = {"apache", "storm", "topology", "spout", "bolt"};
        String word = words[random.nextInt(words.length)];
        this.collector.emit(new Values(word));  // 发送生成的单词
        Utils.sleep(100);  // 暂停一会儿，保持流速
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("word"));  // 定义输出字段
    }
}

这段代码实现了一个简单的 Spout，通过随机选择单词并使用 collector.emit() 方法发送给下游 Bolt。

3. 编写 Bolt

Bolt 是处理数据的地方。我们将编写一个计数单词出现次数的 Bolt。

import org.apache.storm.task.OutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.BasicOutputCollector;
import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;
import org.apache.storm.topology.BasicOutputDeclarer;
import org.apache.storm.task.IBolt;

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

public class WordCountBolt implements IRichBolt {
    private OutputCollector collector;
    private Map<String, Integer> wordCounts;

    @Override
    public void prepare(Map stormConf, TopologyContext context, OutputCollector collector) {
        this.collector = collector;
        this.wordCounts = new HashMap<>();
    }

    @Override
    public void execute(Tuple input) {
        String word = input.getStringByField("word");
        int count = wordCounts.getOrDefault(word, 0) + 1;  // 更新单词计数
        wordCounts.put(word, count);
        collector.emit(new Values(word, count));  // Emit the word and its count
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("word", "count"));  // 定义输出字段
    }

    @Override
    public void cleanup() {
        // 在此处可以输出统计结果
        for (Map.Entry<String, Integer> entry : wordCounts.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

在 WordCountBolt 中，我们用一个 HashMap 存储单词及其出现总数。

4. 创建 Topology

一旦我们编写了 Spout 和 Bolt，就可以创建 Topology，连接它们。

import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.topology.TopologyBuilder;

public class WordCountTopology {
    public static void main(String[] args) {
        TopologyBuilder builder = new TopologyBuilder();
        
        builder.setSpout("word-spout", new WordSpout());  // 设置 spout
        builder.setBolt("count-bolt", new WordCountBolt())
               .shuffleGrouping("word-spout");  // 连接 Spout 和 Bolt
        
        Config config = new Config();
        config.setDebug(true);

        LocalCluster cluster = new LocalCluster();
        cluster.submitTopology("WordCountTopology", config, builder.createTopology());  // 提交拓扑
    }
}

以上代码创建了名为 WordCountTopology 的拓扑，并在本地服务器上运行。

类图

我们可以用以下 mermaid 代码生成类图，以更清晰地展示 Spout 和 Bolt 之间的关系：

classDiagram
    class WordSpout {
        +open()
        +nextTuple()
        +declareOutputFields()
    }

    class WordCountBolt {
        +prepare()
        +execute()
        +declareOutputFields()
        +cleanup()
    }

    WordSpout <|-- WordCountBolt: Uses