storm的流分组

用的是ShuffleGrouping分组方式，并行度设置为3

这是跑下来的结果

参考代码StormTopologyShufferGrouping.java

package yehua.storm;

import java.util.Map;

import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.StormSubmitter;
import org.apache.storm.generated.AlreadyAliveException;
import org.apache.storm.generated.AuthorizationException;
import org.apache.storm.generated.InvalidTopologyException;
import org.apache.storm.spout.SpoutOutputCollector;
import org.apache.storm.task.OutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.TopologyBuilder;
import org.apache.storm.topology.base.BaseRichBolt;
import org.apache.storm.topology.base.BaseRichSpout;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;
import org.apache.storm.utils.Utils;

/**
* shufferGrouping
* 没有特殊情况下，就使用这个分组方式，可以保证负载均衡，工作中最常用的
* @author yehua
*
*/

public class StormTopologyShufferGrouping {

public static class MySpout extends BaseRichSpout{
private Map conf;
private TopologyContext context;
private SpoutOutputCollector collector;
// @Override
public void open(Map conf, TopologyContext context,
SpoutOutputCollector collector) {
this.conf = conf;
this.collector = collector;
this.context = context;
}

int num = 0;
//@Override
public void nextTuple() {
num++;
System.out.println("spout:"+num);
this.collector.emit(new Values(num));
Utils.sleep(1000);
}

//@Override
public void declareOutputFields(OutputFieldsDeclarer declarer) {
declarer.declare(new Fields("num"));
}

}

public static class MyBolt extends BaseRichBolt{

private Map stormConf;
private TopologyContext context;
private OutputCollector collector;
// @Override
public void prepare(Map stormConf, TopologyContext context,
OutputCollector collector) {
this.stormConf = stormConf;
this.context = context;
this.collector = collector;
}

//@Override
public void execute(Tuple input) {
Integer num = input.getIntegerByField("num");
System.err.println("thread:"+Thread.currentThread().getId()+",num="+num);
}

//@Override
public void declareOutputFields(OutputFieldsDeclarer declarer) {

}

public static void main(String[] args) {
TopologyBuilder topologyBuilder = new TopologyBuilder();
String spout_id = MySpout.class.getSimpleName();
String bolt_id = MyBolt.class.getSimpleName();

topologyBuilder.setSpout(spout_id, new MySpout());
topologyBuilder.setBolt(bolt_id, new MyBolt(),3).shuffleGrouping(spout_id);

Config config = new Config();
String topology_name = StormTopologyShufferGrouping.class.getSimpleName();
if(args.length==0){
//在本地运行
LocalCluster localCluster = new LocalCluster();
localCluster.submitTopology(topology_name, config, topologyBuilder.createTopology());
}else{
//在集群运行
try {
StormSubmitter.submitTopology(topology_name, config, topologyBuilder.createTopology());
} catch (AlreadyAliveException e) {
e.printStackTrace();
} catch (InvalidTopologyException e) {
e.printStackTrace();
} catch (AuthorizationException e) {
e.printStackTrace();
}
}

}

用fieldsGrouping方法

按奇偶数分组（也就是按字段分组）

从跑出来的结果看出来，一个线程处理奇数的一个线程处理偶数的

参考代码StormTopologyFieldsGrouping.java

 package yehua.storm;

 import java.util.Map;

 import org.apache.storm.Config;

 import org.apache.storm.LocalCluster;

 import org.apache.storm.StormSubmitter;

 import org.apache.storm.generated.AlreadyAliveException;

 import org.apache.storm.generated.AuthorizationException;

 import org.apache.storm.generated.InvalidTopologyException;

 import org.apache.storm.spout.SpoutOutputCollector;

 import org.apache.storm.task.OutputCollector;

 import org.apache.storm.task.TopologyContext;

 import org.apache.storm.topology.OutputFieldsDeclarer;

 import org.apache.storm.topology.TopologyBuilder;

 import org.apache.storm.topology.base.BaseRichBolt;

 import org.apache.storm.topology.base.BaseRichSpout;

 import org.apache.storm.tuple.Fields;

 import org.apache.storm.tuple.Tuple;

 import org.apache.storm.tuple.Values;

 import org.apache.storm.utils.Utils;

 /**

  * FieldsGrouping

  * 字段分组

  * @author yehua

  *

  */

 public class StormTopologyFieldsGrouping {

     public static class MySpout extends BaseRichSpout{

         private Map conf;

         private TopologyContext context;

         private SpoutOutputCollector collector;

         //@Override

         public void open(Map conf, TopologyContext context,

                 SpoutOutputCollector collector) {

             this.conf = conf;

             this.collector = collector;

             this.context = context;

         }

         int num = 0;

         //@Override

         public void nextTuple() {

             num++;

             System.out.println("spout:"+num);

             this.collector.emit(new Values(num,num%2));

             Utils.sleep(1000);

         }

         //@Override

         public void declareOutputFields(OutputFieldsDeclarer declarer) {

             declarer.declare(new Fields("num","flag"));

         }

     }

     public static class MyBolt extends BaseRichBolt{

         private Map stormConf;

         private TopologyContext context;

         private OutputCollector collector;

         //@Override

         public void prepare(Map stormConf, TopologyContext context,

                 OutputCollector collector) {

             this.stormConf = stormConf;

             this.context = context;

             this.collector = collector;

         }

         //@Override

         public void execute(Tuple input) {

             Integer num = input.getIntegerByField("num");

             System.err.println("thread:"+Thread.currentThread().getId()+",num="+num);

         }

         //@Override

         public void declareOutputFields(OutputFieldsDeclarer declarer) {

         }

     }

     public static void main(String[] args) {

         TopologyBuilder topologyBuilder = new TopologyBuilder();

         String spout_id = MySpout.class.getSimpleName();

         String bolt_id = MyBolt.class.getSimpleName();

         topologyBuilder.setSpout(spout_id, new MySpout());

         //注意：字段分组一定可以保证相同分组的数据进入同一个线程处理

         topologyBuilder.setBolt(bolt_id, new MyBolt(),2).fieldsGrouping(spout_id, new Fields("flag"));

         Config config = new Config();

         String topology_name = StormTopologyFieldsGrouping.class.getSimpleName();

         if(args.length==0){

             //在本地运行

             LocalCluster localCluster = new LocalCluster();

             localCluster.submitTopology(topology_name, config, topologyBuilder.createTopology());

         }else{

             //在集群运行

             try {

                 StormSubmitter.submitTopology(topology_name, config, topologyBuilder.createTopology());

             } catch (AlreadyAliveException e) {

                 e.printStackTrace();

             } catch (InvalidTopologyException e) {

                 e.printStackTrace();

             } catch (AuthorizationException e) {

                 e.printStackTrace();

             }

         }

     }

 }

这里补充一下，比如说有两类数据3个线程的时候

我们再看看运行结果，发现只有两个线程干活了

还有一种情况，只有一个线程的情况，还是两类数据

从运行结果看出来，所有话一个进程干完了

allGrouping方法

运行结果：spout每发一条数据三个进程都接收到了（基本没什么应用场景）

参考代码StormTopologyAllGrouping.java

 package yehua.storm;

 import java.util.Map;

 import org.apache.storm.Config;

 import org.apache.storm.LocalCluster;

 import org.apache.storm.StormSubmitter;

 import org.apache.storm.generated.AlreadyAliveException;

 import org.apache.storm.generated.AuthorizationException;

 import org.apache.storm.generated.InvalidTopologyException;

 import org.apache.storm.spout.SpoutOutputCollector;

 import org.apache.storm.task.OutputCollector;

 import org.apache.storm.task.TopologyContext;

 import org.apache.storm.topology.OutputFieldsDeclarer;

 import org.apache.storm.topology.TopologyBuilder;

 import org.apache.storm.topology.base.BaseRichBolt;

 import org.apache.storm.topology.base.BaseRichSpout;

 import org.apache.storm.tuple.Fields;

 import org.apache.storm.tuple.Tuple;

 import org.apache.storm.tuple.Values;

 import org.apache.storm.utils.Utils;

 /**

  * AllGrouping

  * 广播分组

  * @author yehua

  *

  */

 public class StormTopologyAllGrouping {

     public static class MySpout extends BaseRichSpout{

         private Map conf;

         private TopologyContext context;

         private SpoutOutputCollector collector;

         //@Override

         public void open(Map conf, TopologyContext context,

                 SpoutOutputCollector collector) {

             this.conf = conf;

             this.collector = collector;

             this.context = context;

         }

         int num = 0;

         //@Override

         public void nextTuple() {

             num++;

             System.out.println("spout:"+num);

             this.collector.emit(new Values(num));

             Utils.sleep(1000);

         }

         //@Override

         public void declareOutputFields(OutputFieldsDeclarer declarer) {

             declarer.declare(new Fields("num"));

         }

     }

     public static class MyBolt extends BaseRichBolt{

         private Map stormConf;

         private TopologyContext context;

         private OutputCollector collector;

         //@Override

         public void prepare(Map stormConf, TopologyContext context,

                 OutputCollector collector) {

             this.stormConf = stormConf;

             this.context = context;

             this.collector = collector;

         }

         //@Override

         public void execute(Tuple input) {

             Integer num = input.getIntegerByField("num");

             System.err.println("thread:"+Thread.currentThread().getId()+",num="+num);

         }

         //@Override

         public void declareOutputFields(OutputFieldsDeclarer declarer) {

         }

     }

     public static void main(String[] args) {

         TopologyBuilder topologyBuilder = new TopologyBuilder();

         String spout_id = MySpout.class.getSimpleName();

         String bolt_id = MyBolt.class.getSimpleName();

         topologyBuilder.setSpout(spout_id, new MySpout());

         topologyBuilder.setBolt(bolt_id, new MyBolt(),3).allGrouping(spout_id);

         Config config = new Config();

         String topology_name = StormTopologyAllGrouping.class.getSimpleName();

         if(args.length==0){

             //在本地运行

             LocalCluster localCluster = new LocalCluster();

             localCluster.submitTopology(topology_name, config, topologyBuilder.createTopology());

         }else{

             //在集群运行

             try {

                 StormSubmitter.submitTopology(topology_name, config, topologyBuilder.createTopology());

             } catch (AlreadyAliveException e) {

                 e.printStackTrace();

             } catch (InvalidTopologyException e) {

                 e.printStackTrace();

             } catch (AuthorizationException e) {

                 e.printStackTrace();

             }

         }

     }

 }

LocalOrShufferGrouping方法

spout只会给同一个主机的线程发送数据（图中的线程1），也就是在同一个线程里会被发送数据，这样做的好处就是在同一个进程里发送数据效率搞，不用跨主机传输

但是当数据量太大的时候，线程1处理不了的时候就麻烦了，所以在实际工作中不建议这样做。

这里用的是3个线程（3个bolt），2个进程(2个worker)

从运行的结果我们可以看出来，只有一个线程在接收数据

还有一种情况，如果本地没有线程的时候，他就跟ShufferGrouping的效果一样的

参考代码StormTopologyLocalOrShufferGrouping.java

 package yehua.storm;

 import java.util.Map;

 import org.apache.storm.Config;

 import org.apache.storm.LocalCluster;

 import org.apache.storm.StormSubmitter;

 import org.apache.storm.generated.AlreadyAliveException;

 import org.apache.storm.generated.AuthorizationException;

 import org.apache.storm.generated.InvalidTopologyException;

 import org.apache.storm.spout.SpoutOutputCollector;

 import org.apache.storm.task.OutputCollector;

 import org.apache.storm.task.TopologyContext;

 import org.apache.storm.topology.OutputFieldsDeclarer;

 import org.apache.storm.topology.TopologyBuilder;

 import org.apache.storm.topology.base.BaseRichBolt;

 import org.apache.storm.topology.base.BaseRichSpout;

 import org.apache.storm.tuple.Fields;

 import org.apache.storm.tuple.Tuple;

 import org.apache.storm.tuple.Values;

 import org.apache.storm.utils.Utils;

 /**

  * LocalAllshufferGrouping

  * @author yehua

  *

  */

 public class StormTopologyLocalOrShufferGrouping {

     public static class MySpout extends BaseRichSpout{

         private Map conf;

         private TopologyContext context;

         private SpoutOutputCollector collector;

         //@Override

         public void open(Map conf, TopologyContext context,

                 SpoutOutputCollector collector) {

             this.conf = conf;

             this.collector = collector;

             this.context = context;

         }

         int num = 0;

         //@Override

         public void nextTuple() {

             num++;

             System.out.println("spout:"+num);

             this.collector.emit(new Values(num));

             Utils.sleep(1000);

         }

         //@Override

         public void declareOutputFields(OutputFieldsDeclarer declarer) {

             declarer.declare(new Fields("num"));

         }

     }

     public static class MyBolt extends BaseRichBolt{

         private Map stormConf;

         private TopologyContext context;

         private OutputCollector collector;

         //@Override

         public void prepare(Map stormConf, TopologyContext context,

                 OutputCollector collector) {

             this.stormConf = stormConf;

             this.context = context;

             this.collector = collector;

         }

         //@Override

         public void execute(Tuple input) {

             Integer num = input.getIntegerByField("num");

             System.err.println("thread:"+Thread.currentThread().getId()+",num="+num);

         }

         //@Override

         public void declareOutputFields(OutputFieldsDeclarer declarer) {

         }

     }

     public static void main(String[] args) {

         TopologyBuilder topologyBuilder = new TopologyBuilder();

         String spout_id = MySpout.class.getSimpleName();

         String bolt_id = MyBolt.class.getSimpleName();

         topologyBuilder.setSpout(spout_id, new MySpout());

         topologyBuilder.setBolt(bolt_id, new MyBolt(),3).localOrShuffleGrouping(spout_id);

         Config config = new Config();

         config.setNumWorkers(2);

         String topology_name = StormTopologyLocalOrShufferGrouping.class.getSimpleName();

         if(args.length==0){

             //在本地运行

             LocalCluster localCluster = new LocalCluster();

             localCluster.submitTopology(topology_name, config, topologyBuilder.createTopology());

         }else{

             //在集群运行

             try {

                 StormSubmitter.submitTopology(topology_name, config, topologyBuilder.createTopology());

             } catch (AlreadyAliveException e) {

                 e.printStackTrace();

             } catch (InvalidTopologyException e) {

                 e.printStackTrace();

             } catch (AuthorizationException e) {

                 e.printStackTrace();

             }

         }

     }

 }

storm的流分组的更多相关文章

简单聊聊Storm的流分组策略
简单聊聊Storm的流分组策略首先我要强调的是,Storm的分组策略对结果有着直接的影响,不同的分组的结果一定是不一样的.其次,不同的分组策略对资源的利用也是有着非常大的不同,本文主要讲一讲loca ...
Storm Grouping —— 流分组策略
Storm Grouping: Shuffle Grouping :随机分组,尽量均匀分布到下游Bolt中将流分组定义为混排.这种混排分组意味着来自Spout的输入将混排,或随机分发给此Bolt中的 ...
Storm流分组介绍
Storm流分组介绍流分组是拓扑定义的一部分,每个Bolt指定应该接收哪个流作为输入.流分组定义了流/元组如何在Bolt的任务之间进行分发.在设计拓扑的时候需要定义数据 ...
Storm Topology及分组原理
Storm的通信机制,需要满足如下一些条件以满足Storm的语义. 1.建立数据传输的缓冲区.在通信连接没有建立之前把发送的数据缓存起来.数据发送方可以在连接建立之前发送消息,而不需要等连接建立起来, ...
Stream grouping-storm的流分组策略
A stream grouping tells a topology how to send tuples between two components. Remember, spouts and b ...
Storm 学习之路（一）—— Storm和流处理简介
一.Storm 1.1 简介 Storm 是一个开源的分布式实时计算框架,可以以简单.可靠的方式进行大数据流的处理.通常用于实时分析,在线机器学习.持续计算.分布式RPC.ETL等场景.Storm具有 ...
Storm 系列（一）—— Storm和流处理简介
一.Storm 1.1 简介 Storm 是一个开源的分布式实时计算框架,可以以简单.可靠的方式进行大数据流的处理.通常用于实时分析,在线机器学习.持续计算.分布式 RPC.ETL 等场景.Storm ...
Storm实时流处理Hello World
近来在看Storm的相关资料,以下总结一下配置过程和Hello World例子. Storm是分布式的实时计算系统.详细文档可参考Storm网站,也可以参阅<Getting started wi ...
java8 新特性 Stream流分组排序过滤多条件去重
private static List<User> list = new ArrayList<User>(); public static void main(String[] ...

随机推荐

C语言基础:函数指针分类： iOS学习 c语言基础 2015-06-10 21:55 15人阅读评论(0) 收藏
函数指针:指向函数的指针变量. 函数名相当于首地址. 函数指针定义:返回值类型 (*函数指针变量名)(参数类型1,参数类型2,....)=初始值函数指针类型:返回值类型 (*)(参数类型1,参数 ...
webbench-1.5_hacking
/**************************************************************************** * * webbench-1.5_hacki ...
51Nod：1134 最长递增子序列
动态规划修改隐藏话题 1134 最长递增子序列基准时间限制:1 秒空间限制:131072 KB 分值: 0 难度:基础题收藏关注给出长度为N的数组,找出这个数组的最长递增子序列.(递 ...
k8s dockerk个人学习(1)
虚拟机部署k8s 1. 创建虚拟机虚拟机用的是virtualBox和vagrant工具,百度安装virtualBox和vagrant 创建vagrant目录并创建文件Vagrantfile内容为 V ...
Linux中常用的函数
1.devm_kzalloc() 函数 devm_kzalloc() 和kzalloc()一样都是内核内存分配函数,但是devm_kzalloc()是跟设备(device)有关的,当设备(device ...
阿里云流计算专场-GitHub上相关文档
阿里云流计算专场-GitHub路径:https://github.com/Alibaba-Technology/hangzhouYunQi2017ppt
CGI之C语言篇
为什么要进行CGI编程? 在HTML中,当客户填写了表单,并按下了发送(submit)按钮后,表单的内容被发送到了服务器端,一般的,这时就需要有一个服务器端脚本来对表单的内容进行一些处理,或者是把它们 ...
【转】每天一个linux命令（37）：date命令
原文网址:http://www.cnblogs.com/peida/archive/2012/12/13/2815687.html 在linux环境中,不管是编程还是其他维护,时间是必不可少的,也经常 ...
Oracle DataBase单实例使用ASM案例(1)--ASM基本概念
版权声明:本文为博主原创文章,未经博主允许不得转载. Oracle DataBase单实例使用ASM案例(1)--ASM基本概念系统环境: 操作系统:RH EL5-64 Oracle 软件: Ora ...
bzoj 2286(洛谷 2495) [Sdoi2011]消耗战——虚树
题目:https://www.lydsy.com/JudgeOnline/problem.php?id=2286 https://www.luogu.org/problemnew/show/P2495 ...

storm的流分组

storm的流分组的更多相关文章

随机推荐

热门专题