Storm集成Kafka和Redis

最新推荐文章于 2022-04-18 15:31:48 发布
原创 最新推荐文章于 2022-04-18 15:31:48 发布 · 1.1k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了如何将Storm项目与Kafka和Redis进行集成，包括新建Storm项目，引入依赖，定义Schema和Bolt进行数据处理，提交Topology，以及依次开启Zookeeper、Storm、Kafka和Redis服务。在验证过程中，通过发送生产者消息并观察Redis中的缓存消息，确保整个流程的正确性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Storm集成Kafka和Redis

一、 新建Strom项目

 

二、 引入pom依赖

<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <spring.version>2.5.6</spring.version>
</properties>

<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>3.8.1</version>
    <scope>test</scope>
  </dependency>

  <!--storm -->
  <dependency>
    <groupId>org.apache.storm</groupId>
    <artifactId>storm-core</artifactId>
    <version>0.9.6</version>
    <!--<scope>provided</scope>-->
  </dependency>

  <!--redis -->
  <dependency>
    <groupId>org.apache.storm</groupId>
    <artifactId>storm-redis</artifactId>
    <version>1.1.0</version>
  </dependency>

  <!--Kafka  start -->
  <dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka_2.9.2</artifactId>
    <version>0.8.2.2</version>
    <exclusions>
      <exclusion>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
      </exclusion>
      <exclusion>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
      </exclusion>
    </exclusions>
  </dependency>
  <dependency>
    <groupId>org.apache.storm</groupId>
    <artifactId>storm-kafka</artifactId>
    <version>0.9.6</version>
  </dependency>
  <!--Kafka  end -->

  <!--ActiveMQ  start-->
 <!-- <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jms</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.apache.xbean</groupId>
    <artifactId>xbean-spring</artifactId>
    <version>3.7</version>
  </dependency>
  <dependency>
    <groupId>org.apache.storm</groupId>
    <artifactId>storm-jms</artifactId>
    <version>1.1.0</version>
  </dependency>
  <dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-core</artifactId>
    <version>5.4.0</version>
    <exclusions>
      <exclusion>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
      </exclusion>
      <exclusion>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
      </exclusion>
    </exclusions>
  </dependency>-->
  <!--ActiveMQ    end-->
</dependencies>

<build>
  <plugins>
    <plugin>
      <artifactId>maven-assembly-plugin</artifactId>
      <configuration>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        <archive>
          <manifest>
            <!--告诉运行的主类是哪个，注意根据自己的情况，下面的包名做相应的修改-->
            <!--<mainClass>com.simon.storm.URLCountTopology</mainClass>-->
          </manifest>
        </archive>
      </configuration>
      <executions>
        <execution>
          <id>make-assembly</id>
          <phase>package</phase>
          <goals>
            <goal>single</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <configuration>
        <source>1.8</source>
        <target>1.8</target>
      </configuration>
    </plugin>
    <plugin>
      <groupId>org.codehaus.mojo</groupId>
      <artifactId>exec-maven-plugin</artifactId>
      <version>1.2.1</version>
      <executions>
        <execution>
          <goals>
            <goal>exec</goal>
          </goals>
        </execution>
      </executions>
      <configuration>
        <executable>java</executable>
        <includeProjectDependencies>true</includeProjectDependencies>
        <includePluginDependencies>true</includePluginDependencies>
        <mainClass></mainClass>
        <systemProperties>
          <systemProperty>
            <key>log4j.configuration</key>
            <value>file:./src/main/resources/log4j.properties</value>
          </systemProperty>
        </systemProperties>
      </configuration>
      <dependencies>
        <dependency>
          <groupId>org.apache.storm</groupId>
          <artifactId>storm-core</artifactId>
          <version>1.1.0</version>
          <type>jar</type>
        </dependency>
      </dependencies>
    </plugin>
  </plugins>
</build>

三、 定义Schema 将kafka获取的消息作过滤处理。

package com.simon.storm;

import backtype.storm.spout.Scheme;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Values;

import java.io.UnsupportedEncodingException;
import java.util.List;

/**
 * Created by Administrator on 2018/1/10.
 * 对kafka出来的数据转换成字符串，
 * 接下来我们想办法来处理strom清洗之后的数据
 */
public class MessageScheme implements Scheme {
    public List<Object> deserialize(byte[] bytes) {
        try {
             String msg = new String(bytes, "UTF-8");
             return new Values(msg);
         } catch (UnsupportedEncodingException e) {
             e.printStackTrace();
         }
        return null;
    }

    public Fields getOutputFields() {
        return new Fields("msg");
    }
} 

四、 定义bolt

  将数据处理并保存到redis中

package com.simon.storm;

import backtype.storm.task.TopologyContext;
import backtype.storm.topology.BasicOutputCollector;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseBasicBolt;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;
import redis.clients.jedis.Jedis;

import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Map;

/**
 * Created by Administrator on 2018/1/10.
 *
 * 把输出的消息放到文件redis缓存中
 */
public class SenqueceBolt  extends BaseBasicBolt {

    private Jedis jedis ;

    @Override
    public void prepare(Map stormConf, TopologyContext context) {
        super.prepare(stormConf, context);
        jedis = new Jedis("master",6379);
    }

    public void execute(Tuple tuple, BasicOutputCollector basicOutputCollector) {
        String word = (String) tuple.getValue(0);
        /*String out = "output:" + word;*/
        System.out.println(word);

        if(word != null){
            //将url写入到redis的一个zset集合中
            // 参数1： zset的主键 参数2：要增加的分数 参数3：url中的网站部分——site
            word = word.toUpperCase();
            jedis.zincrby("words", 1, word);
        }

        basicOutputCollector.emit(new Values(word));
    }

    public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {
        outputFieldsDeclarer.declare(new Fields("message"));
    }
}

五、 定义Topology 提交本地或集群

package com.simon.storm;

import backtype.storm.Config;
import backtype.storm.LocalCluster;
import backtype.storm.StormSubmitter;
import backtype.storm.generated.AlreadyAliveException;
import backtype.storm.generated.InvalidTopologyException;
import backtype.storm.spout.SchemeAsMultiScheme;
import backtype.storm.topology.TopologyBuilder;
import backtype.storm.utils.Utils;
import storm.kafka.BrokerHosts;
import storm.kafka.KafkaSpout;
import storm.kafka.SpoutConfig;
import storm.kafka.ZkHosts;
import storm.kafka.bolt.KafkaBolt;
import java.util.HashMap;
import java.util.Map;
public class StormKafkaTopo {
    public static void main( String[] args ) {
        BrokerHosts brokerHosts = new ZkHosts("master:2181,slave01:2181,slave02:2181");
        SpoutConfig spoutConfig = new SpoutConfig(brokerHosts, "hello", "/kafka", "kafkaspout");
         Config conf = new Config();
         Map<String, String> map = new HashMap<String, String>();
         map.put("metadata.broker.list", "10.10.34.36:9092");
         map.put("serializer.class", "kafka.serializer.StringEncoder");
         conf.put("kafka.broker.properties", map);
         //conf.put("topic", "topic2");
         spoutConfig.scheme = new SchemeAsMultiScheme(new MessageScheme());
         TopologyBuilder builder = new TopologyBuilder();
         builder.setSpout("spout", new KafkaSpout(spoutConfig));
         builder.setBolt("bolt", new SenqueceBolt()).shuffleGrouping("spout");
         builder.setBolt("kafkabolt", new KafkaBolt<String, Integer>()).shuffleGrouping("bolt");
         if(args != null && args.length > 0) {
                //提交到集群运行
                 try {
                     StormSubmitter.submitTopology(args[0], conf, builder.createTopology());
                 } catch (AlreadyAliveException e) {
                     e.printStackTrace();
                 } catch (InvalidTopologyException e) {
                     e.printStackTrace();
                 }
             } else {
                 //本地模式运行
                 LocalCluster cluster = new LocalCluster();
                 cluster.submitTopology("Topotest1121", conf, builder.createTopology());
                 Utils.sleep(1000000);
                 cluster.killTopology("Topotest1121");
                 cluster.shutdown();
             }
     }
}

六、 开启集群

        1. 开启zookeeper

            1) 先同步时间

 

            2) 开启zookeeper集群

 

 

        2. 开启storm

            1) 开启nimbus

 

            2) 开启ui

 

            3) 开启supervisor

 

 

        3. 开启kafka

            1) 开启kafka服务

 

 

            2) 另起窗口开启kafka主题

 

            3) 开启kafka发布者

 

            4) 开启kafka消费者

 

            5) 测试生产者发送消息

 

 

            6) 测试消费者接受消息

            4. 开启redis客户端

 

七、 运行Topology程序

八、 启动完成

九、 发送生产者消息测试

 

十、 控制台输出

 

十一、 查看redis

 

            查看列表：

 

   在此发送kafka消息：

 

十二、 打包运行storm集群

   放开storm-core的provide

 

十三、 上传jar包

 

十四、 运行storm jar

十五、 由于版本冲突会造成很多难以解决的问题

十六、 重新安装匹配的kafka和Storm的版本

            apache-storm-0.9.6.tar.gz   kafka_2.9.2-0.8.2.2.tgz

十七、 打包到集群

十八、 上传

 

十九、 运行storm jar

二十、 测试kafka发送消息

 

二十一、 查看redis缓存消息

 

Redis和Kafka：比较与区别
DxJavascript的博客
09-27 1255
本文将详细介绍Redis和Kafka之间的区别，并提供相应的源代码示例。Kafka使用发布-订阅模式，将数据流组织成主题（topics），并将消息发布到主题中。Redis适用于快速读写和多样化数据结构的场景，而Kafka适用于高吞吐量和可靠性要求较高的实时数据处理场景。Redis是一种基于内存的数据存储系统，它提供了多种数据结构（如字符串、哈希、列表、集合等），并支持持久化到磁盘。消息发布者将消息发送到特定的频道（channel），然后订阅该频道的所有订阅者都会接收到该消息。
大数据技术分享：Redis与Kafka的区别
qianfeng_dashuju的博客
06-19 2634
第一: Kafka与Redis PUB/SUB之间较大的区别在于Kafka是一个完整的系统，而Redis PUB/SUB只是一个套件(utility)——没有冒犯Redis的意思，毕竟它的主要功能并不是PUB/SUB。 第二: Redis 消息推送（基于分布式pub/sub）多用于实时性较高的消息推送，并不保证可靠。（推荐学习：Redis视频教程）其他的mq和Kafka保证可靠但有一些延迟（非实时系统没有保证延迟）。redis-pub/sub断电就清空，而使用redis-list作为消息推送虽然有持久
KafKaStormRedis
01-31
本项目验证了storm1.1.1从kafka2.12-1.0.0消费数据，将统计结果保存到redis中。项目自带kafka生产者testcase。具体用法请看README.md的[Order of execution]部分。集群部署过程也在此文件的reference网页。集群的storm,kafka版本与项目版本要一致，否则会kafka消息出现乱码。
Spring boot集成kafka，redis，实现注册消息同步到另一个数据库
sjjsaaaa的博客
04-18 3337
Spring boot集成kafka，redis，实现注册消息同步到另一个数据库
分布式消息中间件（四）——Flume+Kafka+Storm+Redis生态架构实战
Think In JAVA—Max
06-15 6992
一、Kafka项目应用架构分析 1、Kafka生态架构        数据收集的速度，跟处理的速度不一定一致，故使用Kafka中间件作为数据收集和数据处理的一个Access入口，接收flume收集的数据，并通过kafkaSpout提交给Storm进行处理。 2、kafka 消息生产者 3、kafka 消息消费者   二、Kafka Producer  1、配置FlumeCl
storm+kafka+redis+mysql
07-12
标题中的"storm+kafka+redis+mysql"是一个典型的大数据实时处理架构，广泛应用于日志收集、数据分析等领域。下面将详细介绍这些技术组件及其在实际应用中的作用。 **Apache Storm** Apache Storm是一个开源的分布式...
大数据处理实例：通过Storm结合Kafka, Redis和MySQL
2. **实例程序搭建**：这里暗示了一个已经开发完成的Storm、Kafka、Redis和MySQL集成应用实例。使用Maven可以方便地管理这个应用的依赖和构建过程。 3. **导入和运行**：描述中提到的“导入后下载maven库可运行”，...
基于Storm/Kafka/Redis的高效分布式爬虫系统
资源摘要信息:"Storm-Simple-Crawler是一个利用Apache Storm进行数据流处理、Kafka进行消息队列管理和Redis进行数据存储的分布式爬虫系统。该系统采用Java语言开发，版本号为0.0.1，其主要特点包括遵循网络爬虫的...
大数据技术视频课程教程：HBase、Hive、Sqoop、Flume、ZooKeeper、Storm、Kafka、Redis、MongoDB
大数据课程教程视频是当前大数据领域最热门的学习资源之一，本资源涵盖了大数据八大知识领域，分别是HBase、Hive、Sqoop、Flume、ZooKeeper、Storm、Kafka、Redis和MongoDB。下面是对每个知识领域的详细介绍： 一、...
Spring boot集成Kafka+Storm的示例代码
08-28
本篇文章主要介绍了使用Spring Boot集成Kafka和Storm的示例代码，并详细讲解了为什么需要将Storm和Kafka整合到Spring Boot项目中，以及如何实现这种整合。 为什么需要整合到Spring Boot 在业务需求中，我们需要将...
Spark Streaming集成kafka和redis简单示例 - Java版
xbing的博客
06-29 1719
pom.xml中添加依赖：&lt;!-- https://mvnrepository.com/artifact/org.apache.spark/spark-streaming --&gt; &lt;dependency&gt; &lt;groupId&gt;org.apache.spark&lt;/groupId&gt; &lt;artifactId&gt;spark-strea...
Storm整合Kafka、Redis、AMQ
Simon的博客
04-17 620
Storm整合Kafka、Redis、AMQ 一、需求         ogg监控Oracle数据的增删改查操作推到Kafka，Kafka推送Json数据串，Storm进行解析过滤操作，存储一份在Redis中，在推送到AMQ，前台页面利用WebSocket实时刷新取出AMQ消息缓存数据，展示页面。 二、安装Storm、Kafka、Redis、AMQ 三、创建java项目   四、引入p...
Storm/Redis/Kafka的使用
qq_43794633的博客
03-11 1318
Linux环境下Apache Storm的使用：爬取指定网站信息并将信息存进redis和kafka，再将两者读出的数据作为spout，分别对两者的数据词频统计、行数统计、字数统计，并将所得结果存入redis内存数据库，并观察这两个情况的时延、吞吐量。注意：两个数据源两个拓扑。 目录1．环境搭建1.1安装JDK1.2安装eclipse1.3 安装、打开zookeeper服务1.4安装、打开Kafka服务1.5安装、打开Redis服务1.6 安装、打开Storm服务1.7 添加maven依赖2．程序使用说明3．
storm+flume+kafka+redis+zookeeper
ixtgtg的专栏
06-07 485
zookeeper 为分布式系统提供一致性协调(Coordination)服务,Client与ZooKeeper之间的通信，需要创建一个Session https://www.2cto.com/net/201806/756084.html https://www.cnblogs.com/felixzh/p/5869212.html 配置DNS映射: 将zkCluster的标识lgprc...
Storm 整合kafka
易水寒
06-30 685
1.依赖&lt;dependency&gt; &lt;groupId&gt;org.apache.curator&lt;/groupId&gt; &lt;artifactId&gt;curator-framework&lt;/artifactId&gt; &lt;version&gt;${curator.version}&lt;/vers...
Redis、Kafka、Storm
meng984611383的博客
07-03 770
一、Redis 【1】Redis指令查询手册：https://redis.io/commands#hash 【2】Redis 是一个完全开源免费的高性能的key-value数据库，常常用作缓存，它有丰富的API接口，其使用类似类似于普通数据库操作，先进行redis客户端的链接，然后进行相应的类似增删改查操作，相关API接口与命令行命令基本是一一对应的。 maven依赖： &lt;depe...
storm-kafka-redis-jdbc学习
dark
09-16 407
通过一个简单的业务拓扑，将storm与kafka,redis,oracle的集成。 Topology说明： spout： 从kafka读取消息 bolt_1： 检验消息格式 bolt_2： 从redis读取类型 匹配，将匹配未通过的消息，写入redis bolt_3： 读取oracle读取指标值, 当超过指标值时，将消息写入oralce , 以及写入kafka. Topology示意图...
简单Storm消费Kafka数据并存储到redis实例（订单信息处理）
虾哔哔的博客
04-14 3409
maven依赖 &lt;dependencies&gt; &lt;dependency&gt; &lt;groupId&gt;org.apache.storm&lt;/groupId&gt; &lt;artifactId&gt;storm-core&lt;/artifactId&gt; &lt;version&gt;0.9.5&lt;/ve
kafka与redis
weixin_44857939的博客
03-24 4769
1、 kafka是消息中间件，原理就是一个队列用来保存所有发布的消息，等到客户端一上线就推送给客户端。发布订阅模式。所有消息都保存在磁盘上 2、redis是非关系型数据库，也有发布订阅的功能。 区别： kafka是保存在磁盘上，一般用于性能要求不高的场景（日志），而redis是保存在内存上，一般用于高并发的场景。 而且由于redis是保存在内存，所以服务器一旦宕机，内容丢失，安全性不好。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值