Storm 与 Redis 整合

最新推荐文章于 2020-07-30 14:57:25 发布
最新推荐文章于 2020-07-30 14:57:25 发布
阅读量551 收藏
点赞数
分类专栏： 大数据 文章标签： 数据库 大数据 php

Storm 与 Redis 整合

原创编写： 王宇 
2016-11-07

 

Storm 与 Redis 整合
参考资料：http://storm.apache.org/releases/2.0.0-SNAPSHOT/storm-redis.html
Strom为Redis提供几个标准Bolt
RedisLookupBolt 例子
RedisStoreBoltBolt 例子
非简单Bolt
RedisLookupBolt 源代码，用于理解WordCountRedisLookupMapper
Kafka + Storm + Redis 完整例子
依赖包
编译执行

 

参考资料：http://storm.apache.org/releases/2.0.0-SNAPSHOT/storm-redis.html

Strom为Redis提供几个标准Bolt

  • RedisLookupBolt: 查询
  • RedisStoreBolt: 存储
  • AbstractRedisBolt: 存储

RedisLookupBolt 例子

从Redis中，查询单词的计算数量

  1. classWordCountRedisLookupMapperimplementsRedisLookupMapper{
  2. privateRedisDataTypeDescription description;
  3. privatefinalString hashKey ="wordCount";
  5. publicWordCountRedisLookupMapper(){
  6. description =newRedisDataTypeDescription(
  7. RedisDataTypeDescription.RedisDataType.HASH, hashKey);
  8. }
  10. @Override
  11. publicList<Values> toTuple(ITuple input,Object value){
  12. String member = getKeyFromTuple(input);
  13. List<Values> values =Lists.newArrayList();
  14. values.add(newValues(member, value));
  15. return values;
  16. }
  18. @Override
  19. publicvoid declareOutputFields(OutputFieldsDeclarer declarer){
  20. declarer.declare(newFields("wordName","count"));
  21. }
  23. @Override
  24. publicRedisDataTypeDescription getDataTypeDescription(){
  25. return description;
  26. }
  28. @Override
  29. publicString getKeyFromTuple(ITuple tuple){
  30. return tuple.getStringByField("word");
  31. }
  33. @Override
  34. publicString getValueFromTuple(ITuple tuple){
  35. returnnull;
  36. }
  37. }
  39. JedisPoolConfig poolConfig =newJedisPoolConfig.Builder()
  40. .setHost(host).setPort(port).build();
  41. RedisLookupMapper lookupMapper =newWordCountRedisLookupMapper();
  42. RedisLookupBolt lookupBolt =newRedisLookupBolt(poolConfig, lookupMapper);
  • 对例子理解


  •  
    如上图，JedisPoolConfig的作用是，提供Redis相关的配置，给RedisLookupBolt 
    RedisLookupMapper的作用是，绘制相应的数据结构给RedisLookupBolt. 
    例如
    • getKeyFromTuple()方法， 告诉RedisLookupBolt,从输入的Tuple中，取什么样子的Key，让它去Redis中查询。
    • declareOutputFields()的作用是，定义RedisLookupBolt的输出格式。

RedisStoreBoltBolt 例子

  2. classWordCountStoreMapperimplementsRedisStoreMapper{
  3. privateRedisDataTypeDescription description;
  4. privatefinalString hashKey ="wordCount";
  6. publicWordCountStoreMapper(){
  7. description =newRedisDataTypeDescription(
  8. RedisDataTypeDescription.RedisDataType.HASH, hashKey);
  9. }
  11. @Override
  12. publicRedisDataTypeDescription getDataTypeDescription(){
  13. return description;
  14. }
  16. @Override
  17. publicString getKeyFromTuple(ITuple tuple){
  18. return tuple.getStringByField("word");
  19. }
  21. @Override
  22. publicString getValueFromTuple(ITuple tuple){
  23. return tuple.getStringByField("count");
  24. }
  25. }
  27. JedisPoolConfig poolConfig =newJedisPoolConfig.Builder()
  28. .setHost(host).setPort(port).build();
  29. RedisStoreMapper storeMapper =newWordCountStoreMapper();
  30. RedisStoreBolt storeBolt =newRedisStoreBolt(poolConfig, storeMapper);

非简单Bolt

采用 AbstractRedisBolt 实现更为复杂的逻辑

  1. publicstaticclassLookupWordTotalCountBoltextendsAbstractRedisBolt{
  2. privatestaticfinalLogger LOG =LoggerFactory.getLogger(LookupWordTotalCountBolt.class);
  3. privatestaticfinalRandom RANDOM =newRandom();
  5. publicLookupWordTotalCountBolt(JedisPoolConfig config){
  6. super(config);
  7. }
  9. publicLookupWordTotalCountBolt(JedisClusterConfig config){
  10. super(config);
  11. }
  13. @Override
  14. publicvoid execute(Tuple input){
  15. JedisCommands jedisCommands =null;
  16. try{
  17. jedisCommands = getInstance();
  18. String wordName = input.getStringByField("word");
  19. String countStr = jedisCommands.get(wordName);
  20. if(countStr !=null){
  21. int count =Integer.parseInt(countStr);
  22. this.collector.emit(newValues(wordName, count));
  24. // print lookup result with low probability
  25. if(RANDOM.nextInt(1000)>995){
  26. LOG.info("Lookup result - word : "+ wordName +" / count : "+ count);
  27. }
  28. }else{
  29. // skip
  30. LOG.warn("Word not found in Redis - word : "+ wordName);
  31. }
  32. }finally{
  33. if(jedisCommands !=null){
  34. returnInstance(jedisCommands);
  35. }
  36. this.collector.ack(input);
  37. }
  38. }
  40. @Override
  41. publicvoid declareOutputFields(OutputFieldsDeclarer declarer){
  42. // wordName, count
  43. declarer.declare(newFields("wordName","count"));
  44. }
  45. }

RedisLookupBolt 源代码，用于理解WordCountRedisLookupMapper

注意下列代码中的：

  • get
  1. package org.apache.storm.redis.bolt;
  3. import org.apache.storm.topology.OutputFieldsDeclarer;
  4. import org.apache.storm.tuple.Tuple;
  5. import org.apache.storm.tuple.Values;
  6. import org.apache.storm.redis.common.mapper.RedisDataTypeDescription;
  7. import org.apache.storm.redis.common.mapper.RedisLookupMapper;
  8. import org.apache.storm.redis.common.config.JedisClusterConfig;
  9. import org.apache.storm.redis.common.config.JedisPoolConfig;
  10. import redis.clients.jedis.JedisCommands;
  12. import java.util.List;
  14. /**
  15. * Basic bolt for querying from Redis and emits response as tuple.
  16. * <p/>
  17. * Various data types are supported: STRING, LIST, HASH, SET, SORTED_SET, HYPER_LOG_LOG, GEO
  18. */
  19. publicclassRedisLookupBoltextendsAbstractRedisBolt{
  20. privatefinalRedisLookupMapper lookupMapper;
  21. privatefinalRedisDataTypeDescription.RedisDataType dataType;
  22. privatefinalString additionalKey;
  24. /**
  25. * Constructor for single Redis environment (JedisPool)
  26. * @param config configuration for initializing JedisPool
  27. * @param lookupMapper mapper containing which datatype, query key, output key that Bolt uses
  28. */
  29. publicRedisLookupBolt(JedisPoolConfig config,RedisLookupMapper lookupMapper){
  30. super(config);
  32. this.lookupMapper = lookupMapper;
  34. RedisDataTypeDescription dataTypeDescription = lookupMapper.getDataTypeDescription();
  35. this.dataType = dataTypeDescription.getDataType();
  36. this.additionalKey = dataTypeDescription.getAdditionalKey();
  37. }
  39. /**
  40. * Constructor for Redis Cluster environment (JedisCluster)
  41. * @param config configuration for initializing JedisCluster
  42. * @param lookupMapper mapper containing which datatype, query key, output key that Bolt uses
  43. */
  44. publicRedisLookupBolt(JedisClusterConfig config,RedisLookupMapper lookupMapper){
  45. super(config);
  47. this.lookupMapper = lookupMapper;
  49. RedisDataTypeDescription dataTypeDescription = lookupMapper.getDataTypeDescription();
  50. this.dataType = dataTypeDescription.getDataType();
  51. this.additionalKey = dataTypeDescription.getAdditionalKey();
  52. }
  54. /**
  55. * {@inheritDoc}
  56. */
  57. @Override
  58. publicvoid execute(Tuple input){
  59. String key = lookupMapper.getKeyFromTuple(input);
  60. Object lookupValue;
  62. JedisCommands jedisCommand =null;
  63. try{
  64. jedisCommand = getInstance();
  66. switch(dataType){
  67. case STRING:
  68. lookupValue = jedisCommand.get(key);
  69. break;
  71. case LIST:
  72. lookupValue = jedisCommand.lpop(key);
  73. break;
  75. case HASH:
  76. lookupValue = jedisCommand.hget(additionalKey, key);
  77. break;
  79. case SET:
  80. lookupValue = jedisCommand.scard(key);
  81. break;
  83. case SORTED_SET:
  84. lookupValue = jedisCommand.zscore(additionalKey, key);
  85. break;
  87. case HYPER_LOG_LOG:
  88. lookupValue = jedisCommand.pfcount(key);
  89. break;
  91. case GEO:
  92. lookupValue = jedisCommand.geopos(additionalKey, key);
  93. break;
  95. default:
  96. thrownewIllegalArgumentException("Cannot process such data type: "+ dataType);
  97. }
  99. List<Values> values = lookupMapper.toTuple(input, lookupValue);
  100. for(Values value : values){
  101. collector.emit(input, value);
  102. }
  104. collector.ack(input);
  105. }catch(Exception e){
  106. this.collector.reportError(e);
  107. this.collector.fail(input);
  108. }finally{
  109. returnInstance(jedisCommand);
  110. }
  111. }
  113. /**
  114. * {@inheritDoc}
  115. */
  116. @Override
  117. publicvoid declareOutputFields(OutputFieldsDeclarer declarer){
  118. lookupMapper.declareOutputFields(declarer);
  119. }
  120. }

Kafka + Storm + Redis 完整例子

  • 场景 
    参考 《Storm与Kafka整合记录》中，统计单词数量的例子。在这个例子基础之上，将统计到单词结果保存到Redis中。
  • 修改Topology，增加RedisStoreBolt
  1. publicclassKafkaStormSample{
  2. publicclassKafkaStormSample{
  3. publicstaticvoid main(String[] args)throwsException{
  4. Config config =newConfig();
  5. config.setDebug(true);
  6. config.put(Config.TOPOLOGY_MAX_SPOUT_PENDING,1);
  7. String zkConnString ="localhost:2181";
  8. String topic ="my-first-topic";
  9. BrokerHosts hosts =newZkHosts(zkConnString);
  11. SpoutConfig kafkaSpoutConfig =newSpoutConfig(hosts, topic,"/"+ topic, UUID.randomUUID().toString());
  12. kafkaSpoutConfig.bufferSizeBytes =1024*1024*4;
  13. kafkaSpoutConfig.fetchSizeBytes =1024*1024*4;
  14. // kafkaSpoutConfig.forceFromStart = true;
  15. kafkaSpoutConfig.scheme =newSchemeAsMultiScheme(newStringScheme());
  17. // Creating RedisStoreBolt
  18. String host ="localhost";
  19. int port =6379;
  21. JedisPoolConfig poolConfig =newJedisPoolConfig.Builder().setHost(host).setPort(port).build();
  23. RedisStoreMapper storeMapper =newWordCountStoreMapper();
  24. RedisStoreBolt storeBolt =newRedisStoreBolt(poolConfig, storeMapper);
  26. // Assemble with topology
  27. TopologyBuilder builder =newTopologyBuilder();
  28. builder.setSpout("kafka-spout",newKafkaSpout(kafkaSpoutConfig));
  29. builder.setBolt("word-spitter",newSplitBolt()).shuffleGrouping("kafka-spout");
  30. builder.setBolt("word-counter",newCountBolt()).shuffleGrouping("word-spitter");
  31. builder.setBolt("redis-store-bolt", storeBolt).shuffleGrouping("word-counter");
  33. LocalCluster cluster =newLocalCluster();
  34. cluster.submitTopology("KafkaStormSample", config, builder.createTopology());
  36. Thread.sleep(10000);
  38. cluster.shutdown();
  39. }
  40. }
  • 修改 CountBolt, emit to RedisStoreBolt
  1. publicclassCountBoltimplementsIRichBolt{
  2. Map<String,Integer> counters;
  3. privateOutputCollector collector;
  5. @Override
  6. publicvoid prepare(Map stormConf,TopologyContext context,
  7. OutputCollector collector){
  8. this.counters =newHashMap<String,Integer>();
  9. this.collector = collector;
  10. }
  12. @Override
  13. publicvoid execute(Tuple input){
  14. String str = input.getString(0);
  16. if(!counters.containsKey(str)){
  17. counters.put(str,1);
  18. }else{
  19. Integer c = counters.get(str)+1;
  20. counters.put(str, c);
  21. }
  23. // emit to redis-store-bolt
  24. Integer result = counters.get(str);
  25. this.collector.emit(newValues(str,String.valueOf(result)));
  27. collector.ack(input);
  28. }
  30. @Override
  31. publicvoid cleanup(){
  32. for(Map.Entry<String,Integer> entry:counters.entrySet()){
  33. System.out.println(entry.getKey()+" : "+ entry.getValue());
  34. }
  35. }
  37. @Override
  38. publicvoid declareOutputFields(OutputFieldsDeclarer declarer){
  39. declarer.declare(newFields("word","count"));
  41. }
  43. @Override
  44. publicMap<String,Object> getComponentConfiguration(){
  45. returnnull;
  46. }
  47. }

依赖包

jedis-2.9.0.jar 
commons-pool2-2.4.2.jar

将以上两个包，增加到CLASSPATH路径中

编译执行

  • 启动服务

    • 启动 zookeeper
      1. $ cd /opt/zookeeper
      2. $ ./bin/zkServer.sh start
    • 启动 redis
      1. $ redis-server
    • 启动 kafka
      1. $ cd /opt/kafka
      2. $ ./bin/kafka-server-start.sh config/server.properties
    • 启动 storm
      1. $ cd /opt/storm
      2. $./bin/storm nimbus
      3. $./bin/storm supervisor

  • 输入数据

  1. $cd /opt/kafka
  2. $./bin/kafka-console-producer.sh --broker-list localhost:9092--topic my-first-topic
  3. Hello
  4. My first message
  5. My second message
  • 执行例子
  1. $ java KafkaStormSample
  • 在Redis-cli 中查询结果

 

  1. $ redis-cli
  2. 127.0.0.1:6379> hvals wordCount
MrWangyu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Storm 集成 Redis
.
02-18 627
Storm 实时计算完的结果一般会放到 Redis 中缓存。 集成 Redis 所需的 pom 文件： &amp;lt;dependencies&amp;gt; &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.apache.storm&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;stor
storm整合redis的例子源码
08-17
整合Storm与Redis，主要目标是利用Storm处理实时数据，并将结果有效地存储到Redis中，以便后续快速访问或进一步分析。以下是一些关键步骤： 1. **创建Spout**：Spout是Storm数据流的源头，通常从外部数据源（如...
Storm整合Redis
weixin_46235157的博客
03-24 211
先丢个官网链接 本章博客依赖官网 第一步，先放依赖： <dependency> <groupId>org.apache.storm</groupId> <artifactId>storm-redis</artifactId> <version>${storm.version}</version&g...
基于Redis、Storm的实时数据查询实践
weixin_33966365的博客
08-11 147
通过算法小组给出的聚合文件，我们需要实现一种业务场景，通过用户的消费地点的商户ID与posId，查询出他所在的商圈，并通过商圈地点查询出与该区域的做活动的商户，并与之进行消息匹配，推送相应活动信息到用户手机。 那么整个流程分为两步，第一步，将整个聚合文件刷入缓存，文件数据格式如下： 　　29 1:1 102100156910958 10015691 X有限公司 0 1 　　29 1:1 10...
Storm 系列（七）—— Storm 集成 Redis 详解
weixin_30362083的博客
09-04 250
一、简介 Storm-Redis 提供了 Storm 与 Redis 的集成支持，你只需要引入对应的依赖即可使用： <dependency> <groupId>org.apache.storm</groupId> <artifactId>storm-redis</artifactId> <versi...
zk-kafka-redis-storm安装
12-12
与Hadoop处理批量数据不同，Storm专注于实时数据流的处理，能够快速地处理和响应新产生的数据。 在"zk-kafka-redis-storm安装"过程中，首先需要安装Zookeeper，确保集群的协调和数据一致性。接着是Kafka的部署，...
Flume+kafka+Storm整合
02-23
Flume+kafka+Storm整合 示例简介： 以下为三个组建整合，这里只做操作也演示结果，原理性方面大家多学习基础。 流程顺序是flume获取telnet数据，将接收到的数据发送至kafak，kafka作为Storm的spout，Storm进行有向无...
storm-kafka整合代码
02-04
当我们谈论"storm-kafka整合代码"时，这意味着我们要将这两者结合，使得 Storm 可以从 Kafka 中消费数据并进行实时处理。下面将详细介绍 Storm 和 Kafka 的核心概念以及它们整合的关键步骤。 **Apache Storm** ...
storm+kafka+redis+mysql
07-12
标题中的"storm+kafka+redis+mysql"是一个典型的大数据实时处理架构，广泛应用于日志收集、数据分析等领域。下面将详细介绍这些技术组件及其在实际应用中的作用。 **Apache Storm** Apache Storm是一个开源的分布式...
storm + redis 整合
wangqiaowqo的专栏
02-22 173
storm + redis 整合 1、storm + redis 整合 http://storm.apache.org/documentation/storm-redis.html
Storm项目08——storm与redis集成
zytmaster的博客
07-30 161
原数据是一个字符串数组，将数组中的元素一个一个向下发送 SimpleSpout package com.xnmzdx.spout; import java.util.Map; import backtype.storm.spout.SpoutOutputCollector; import backtype.storm.task.TopologyContext; import backtype.storm.topology.OutputFieldsDeclarer; import backty..
Storm集成Redis
u010634288的博客
05-08 723
Storm如果是数据了很大，持久化到DB中，就需要频繁的做磁盘IO，这样的话明显不太好。一般来说做持久化一般是和redis，他们2个是比较配套的。他们都是基于内存的数据库。官方也是不推荐把Storm的数据持久化到DB，因为Storm可能会有多多少少的数据丢失，包括hadoop都是一样的。所以Storm处理了大批量的数据。如果是数据量少，就没有必要使用Storm这个工具了。由于Redis有RDB和A...
缓存架构和Storm的关系
石印掌纹的博客
05-24 991
Storm简介有些热点数据相关的实施处理的方案，比如快速预热，热点数据的实时感知和快速降级，全部要用到Storm，因为我们要实时的计算出热点缓存数据，实时计算，高并发的情况。这时要做一些实时的计算，必须涉及到分布式，分布式的技术才能处理高并发和大量的请求。目前在实时计算领域，大数据的技术在做复杂的热数据的统计和分析，超大流量，高并发的，流式处理的分布式场景下，最成熟的就是StormStorm的特点...
大数据处理框架之Strom：redis storm 整合
weixin_30284355的博客
10-29 90
storm 引入redis ,主要是使用redis缓存库暂存storm的计算结果，然后redis供其他应用调用取出数据。 新建maven工程 pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:s...
Storm集群和集成
hsiehchou的博客
06-01 203
Storm集群和集成 一、Storm集群任务提交流程 二、Storm内部通信机制 三、集成Storm 1、与JDBC集成 将Storm Bolt处理的结果插入MySQL数据库中 需要依赖的jar包  $STORM_HOME\external\sql\storm-sql-core*.jar  $STORM_HOME\external\storm-jdbc\storm-jdbc-...
Storm+redis 实现发布订阅模式
qq_31866793的博客
06-25 188
一，现在的storm是定时从redis读取数据，然后做预处理，这样子不是redis的数据在storm那边不是实时更新，目前有时间了，需要进行优化 二，redis有一个发布订阅模式，明天来实现一下。 ...
Storm 系列（七）—— Storm集成 Redis 详解
黑白影的博客
06-07 1688
一、简介 Storm-Redis提供了Storm与Redis的集成支持，你只需要引入对应的依赖即可使用： <dependency> <groupId>org.apache.storm</groupId> <artifactId>storm-redis</artifactId> <version>${st...
springboot与redis整合
最新发布
03-16
Spring Boot与Redis整合可以通过以下步骤实现： 1. 添加Redis依赖 在pom.xml文件中添加以下依赖： ``` <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis ``` 2. 配置Redis...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值