storm-01（5）

最新推荐文章于 2019-05-15 08:46:03 发布
原创 最新推荐文章于 2019-05-15 08:46:03 发布 · 244 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

6.投影操作 - projection

package com.liming.projection;

import backtype.storm.Config;
import backtype.storm.LocalCluster;
import backtype.storm.tuple.Fields;
import backtype.storm.utils.Utils;
import storm.trident.Stream;
import storm.trident.TridentTopology;

public class TridentDemo {
	public static void main(String[] args) {
		//--创建topology
		TridentTopology topology = new TridentTopology();
		
		Stream s = topology.newStream("xx", new SentenceSpout())
		.each(new Fields("name"), new GenderFunc(),new Fields("gender"))
		.project(new Fields("name"));
		s.each(s.getOutputFields(), new PrintFilter());
		
		//--提交到集群中运行
		Config conf = new Config();
		LocalCluster cluster = new LocalCluster();
		cluster.submitTopology("MyTopology", conf, topology.build());
		
		//--运行10秒钟后杀死Topology关闭集群
		Utils.sleep(1000 * 10);
		cluster.killTopology("MyTopology");
		cluster.shutdown();
	}
}

package com.liming.projection;

import java.util.Map;

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 backtype.storm.utils.Utils;

public class SentenceSpout extends BaseRichSpout{

	private SpoutOutputCollector collector = null;
	
	private Values [] values = {
			new Values("xiaoming","i am so shuai"),
			new Values("xiaoming","do you like me"),
			new Values("xiaohua","i do not like you"),
			new Values("xiaohua","you look like fengjie"),
			new Values("xiaoming","are you sure you do not like me"),
			new Values("xiaohua","yes i am"),
			new Values("xiaoming","ok i am sure")
	};
	
	private int index = 0;
	@Override
	public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
		this.collector = collector;
	}

	@Override
	public void nextTuple() {
		collector.emit(values[index]);
		index = index+1 == values.length ? 0 : index+1;
		Utils.sleep(100);
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		Fields fields = new Fields("name","sentence");
		declarer.declare(fields);
	}

}

package com.liming.projection;

import backtype.storm.tuple.Values;
import storm.trident.operation.BaseFunction;
import storm.trident.operation.TridentCollector;
import storm.trident.tuple.TridentTuple;

public class GenderFunc extends BaseFunction{

	@Override
	public void execute(TridentTuple tuple, TridentCollector collector) {
		String name = tuple.getStringByField("name");
		if("xiaoming".equals(name)){
			collector.emit(new Values("male"));
		}else if("xiaohua".equals(name)){
			collector.emit(new Values("female"));
		}else{
		}
	}
	
}

package com.liming.projection;

import java.util.Iterator;
import java.util.Map;

import backtype.storm.tuple.Fields;
import storm.trident.operation.BaseFilter;
import storm.trident.operation.TridentOperationContext;
import storm.trident.tuple.TridentTuple;

public class PrintFilter extends BaseFilter{

	private TridentOperationContext context = null;
	@Override
	public void prepare(Map conf, TridentOperationContext context) {
		super.prepare(conf, context);
		this.context = context;
	}
	
	@Override
	public boolean isKeep(TridentTuple tuple) {
		StringBuffer buf = new StringBuffer();
		
		Fields fields = tuple.getFields();
		Iterator<String> it = fields.iterator();

		while(it.hasNext()){
			String key = it.next();
			Object value = tuple.getValueByField(key);
			buf.append("---"+key+":"+value+"---");
		}
		System.out.println(buf.toString());
		
		return true;
	}
	
}

 

测试如下：

 

二、重分区操作 - Repartitioning operations

Repartition操作可以改变tuple在各个task之上的划分。
	Repartition也可以改变Partition的数量。
	Repartition需要网络传输。

	重分区时的并发度设置：
		0.parallelismHint：设置重分区时的并发度，此方法将会将会向前寻找最近的一次重分区操作，设置这两个方法之间的所有操作的并发度为指定值，如果不设置所有重分区操作的并发度默认为1。
	重分区操作包括如下方式：
		**重分区方法如果不通过parallelismHint方法设置并发度则默认后续方法的并发度为1.
		1.shuffle：随机将tuple均匀地分发到目标partition里。
		2.broadcast：每个tuple被复制到所有的目标partition里，在DRPC中有用 - 你可以在每个partition上使用stateQuery。
		3.partitionBy：对每个tuple选择partition的方法是：(该tuple指定字段的hash值) mod (目标partition的个数)，该方法确保指定字段相同的tuple能够被发送到同一个partition。（但同一个partition里可能有字段不同的tuple）
		4.global：所有的tuple都被发送到同一个partition。
		5.batchGlobal：确保同一个batch中的tuple被发送到相同的partition中。
		6.patition：该方法接受一个自定义分区的function（实现backtype.storm.grouping.CustomStreamGrouping）

.parallelismHint：设置重分区时的并发度，此方法将会将会向前寻找最近的一次重分区操作，设置这两个方法之间的所有操作的并发度为指定值，如果不设置所有重分区操作的并发度默认为1。如下

package com.liming.Repartition;

import backtype.storm.Config;
import backtype.storm.LocalCluster;
import backtype.storm.tuple.Fields;
import backtype.storm.utils.Utils;
import storm.trident.Stream;
import storm.trident.TridentTopology;

public class TridentDemo {
	public static void main(String[] args) {
		//--创建topology
		TridentTopology topology = new TridentTopology();
		
		Stream s = topology.newStream("xx", new SentenceSpout())
		.parallelismHint(2);
		s.each(s.getOutputFields(), new PrintFilter());
		
		//--提交到集群中运行
		Config conf = new Config();
		LocalCluster cluster = new LocalCluster();
		cluster.submitTopology("MyTopology", conf, topology.build());
		
		//--运行10秒钟后杀死Topology关闭集群
		Utils.sleep(1000 * 10);
		cluster.killTopology("MyTopology");
		cluster.shutdown();
	}
}

package com.liming.Repartition;

import java.util.Map;

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 backtype.storm.utils.Utils;

public class SentenceSpout extends BaseRichSpout{

	private SpoutOutputCollector collector = null;
	
	private Values [] values = {
			new Values("xiaoming","i am so shuai"),
			new Values("xiaoming","do you like me"),
			new Values("xiaohua","i do not like you"),
			new Values("xiaohua","you look like fengjie"),
			new Values("xiaoming","are you sure you do not like me"),
			new Values("xiaohua","yes i am"),
			new Values("xiaoming","ok i am sure")
	};
	
	private int index = 0;
	@Override
	public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
		this.collector = collector;
	}

	@Override
	public void nextTuple() {
		if(index<values.length){
			collector.emit(values[index]);
			index++;
		}
		Utils.sleep(100);
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		Fields fields = new Fields("name","sentence");
		declarer.declare(fields);
	}

}

package com.liming.Repartition;

import java.util.Iterator;
import java.util.Map;

import backtype.storm.tuple.Fields;
import storm.trident.operation.BaseFilter;
import storm.trident.operation.TridentOperationContext;
import storm.trident.tuple.TridentTuple;

public class PrintFilter extends BaseFilter{

	private TridentOperationContext context = null;
	@Override
	public void prepare(Map conf, TridentOperationContext context) {
		super.prepare(conf, context);
		this.context = context;
	}
	
	@Override
	public boolean isKeep(TridentTuple tuple) {
		StringBuffer buf = new StringBuffer();
		
		Fields fields = tuple.getFields();
		Iterator<String> it = fields.iterator();

		while(it.hasNext()){
			String key = it.next();
			Object value = tuple.getValueByField(key);
			buf.append("---"+key+":"+value+"---");
		}
		System.out.println(buf.toString());
		
		return true;
	}
	
}

结果每句话都输出了两次：

案例9 - 改造如上案例，分别用不同分区处理xiaoming和xiaohua的发言，统计每个人说话的次数：

package com.liming.Repartition;

import backtype.storm.Config;
import backtype.storm.LocalCluster;
import backtype.storm.tuple.Fields;
import backtype.storm.utils.Utils;
import storm.trident.Stream;
import storm.trident.TridentTopology;
import storm.trident.operation.builtin.Count;
/**
 * 从分区案例
 */
public class TridentDemo2 {
	public static void main(String[] args) {
		//--创建topology
		TridentTopology topology = new TridentTopology();
		
		//TODO
		Stream s = topology.newStream("xx", new SentenceSpout())
			.partitionBy(new Fields("name"))
			.partitionAggregate(new Fields("name"),new SentenceAggerator(),new Fields("name","count"))
			.parallelismHint(2)
			;
			
			s.each(s.getOutputFields(), new PrintFilter());
		
		
		//--提交到集群中运行
		Config conf = new Config();
		LocalCluster cluster = new LocalCluster();
		cluster.submitTopology("MyTopology", conf, topology.build());
		
		//--运行10秒钟后杀死Topology关闭集群
		Utils.sleep(1000 * 10);
		cluster.killTopology("MyTopology");
		cluster.shutdown();
		
	}
}

package com.liming.Repartition;

import java.util.Map;

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 backtype.storm.utils.Utils;

public class SentenceSpout extends BaseRichSpout{

	private SpoutOutputCollector collector = null;
	
	private Values [] values = {
			new Values("xiaoming","i am so shuai"),
			new Values("xiaoming","do you like me"),
			new Values("xiaohua","i do not like you"),
			new Values("xiaohua","you look like fengjie"),
			new Values("xiaoming","are you sure you do not like me"),
			new Values("xiaohua","yes i am"),
			new Values("xiaoming","ok i am sure")
	};
	
	private int index = 0;
	@Override
	public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
		this.collector = collector;
	}

	@Override
	public void nextTuple() {
		if(index<values.length){
			collector.emit(values[index]);
			index++;
		}
		Utils.sleep(100);
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		Fields fields = new Fields("name","sentence");
		declarer.declare(fields);
	}

}

package com.liming.Repartition;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import backtype.storm.tuple.Values;
import storm.trident.operation.BaseAggregator;
import storm.trident.operation.TridentCollector;
import storm.trident.tuple.TridentTuple;

public class SentenceAggerator extends BaseAggregator<ConcurrentHashMap<String,Integer>> {

	@Override
	public ConcurrentHashMap<String,Integer> init(Object batchId, TridentCollector collector) {
		return new ConcurrentHashMap<String,Integer>();
	}

	@Override
	public void aggregate(ConcurrentHashMap<String,Integer> val, TridentTuple tuple, TridentCollector collector) {
		String name = tuple.getStringByField("name");
		val.put(name, val.containsKey(name) ? val.get(name)+1 : 1);
	}

	@Override
	public void complete(ConcurrentHashMap<String,Integer> val, TridentCollector collector) {
		for(Map.Entry<String, Integer> entry : val.entrySet()){
			collector.emit(new Values(entry.getKey(),entry.getValue()));
		}
	}

}

package com.liming.Repartition;


import java.util.Iterator;
import java.util.Map;


import backtype.storm.tuple.Fields;
import storm.trident.operation.BaseFilter;
import storm.trident.operation.TridentOperationContext;
import storm.trident.tuple.TridentTuple;


public class PrintFilter extends BaseFilter{


	private TridentOperationContext context = null;
	@Override
	public void prepare(Map conf, TridentOperationContext context) {
		super.prepare(conf, context);
		this.context = context;
	}
	
	@Override
	public boolean isKeep(TridentTuple tuple) {
		StringBuffer buf = new StringBuffer();
		buf.append("---partition_id:"+context.getPartitionIndex());
		
		Fields fields = tuple.getFields();
		Iterator<String> it = fields.iterator();


		while(it.hasNext()){
			String key = it.next();
			Object value = tuple.getValueByField(key);
			buf.append("---"+key+":"+value+"---");
		}
		System.out.println(buf.toString());
		
		return true;
	}
	
}

结果如下：可见是两个分区处理的

三、聚合操作 - Aggregation operations

Trident中有aggregate()和persistentAggregate()方法对流进行聚合操作。

	1.aggregate()
		在每个batch上独立的执行,进行全局的聚合
		当使用ReduceAggregator或者Aggregator聚合器时，流先被重新划分成一个大分区(仅有一个partition)，然后对这个partition做聚合操作；
		当使用CombinerAggregatr时，Trident首先对每个partition局部聚合，然后将所有这些partition重新划分到一个partition中，完成全局聚合。
		相比而言，CombinerAggregator更高效，推荐使用。
		可以推测出，aggregate()操作将会隐含的导致数据流重分区，分区之后只剩一个分区。

		例子： 
			使用aggregate()对一个batch操作得到一个全局的count
				mystream.aggregate(new Count(), new Fields("count"))

	2.persistentAggregate() 
		对所有batch中的所有tuple进行聚合，并将结果存入state源中。
		当使用ReduceAggregator或者Aggregator聚合器时，流先被重新划分成一个大分区(仅有一个partition)，然后对这个partition做聚合操作；
		当使用CombinerAggregator时，Trident首先对每个partition局部聚合，然后将所有这些partition重新划分到一个partition中，完成全局聚合。
		相比而言，CombinerAggregator更高效，推荐使用。
		**同在partitionAggregate中一样，aggregate中的聚合器也可以使用链式用法。但是，如果你将一个CombinerAggregator链到一个非CombinerAggregator后面，Trident就不能做局部聚合优化。

四、分组操作 - Operations on grouped streams

groupBy操作先对流中的指定字段做partitionBy操作，让指定字段相同的tuple能被发送到同一个partition里。然后在每个partition里根据指定字段值对该分区里的tuple进行分组。
	！！注意，不是忽略Batch，而是在批内再考虑指定字段，基于批内相同的指定字段做聚合。
	参看图：Group By原理

	如果你在一个grouped stream上做聚合操作，聚合操作将会在每个分组(group)内进行，而不是整个batch上。
	GroupStream类中也有persistentAggregate方法，该方法聚合的结果将会存储在一个key值为分组字段(即groupBy中指定的字段)的MapState中，这些还是在Trident state。

package com.liming.groupby;

import backtype.storm.Config;
import backtype.storm.LocalCluster;
import backtype.storm.tuple.Fields;
import backtype.storm.utils.Utils;
import storm.trident.Stream;
import storm.trident.TridentTopology;
import storm.trident.operation.builtin.Count;
/**
 * 分组操作案例
 */
public class TridentDemo4 {
	public static void main(String[] args) {
		//--创建topology
		TridentTopology topology = new TridentTopology();
		
		//TODO
		Stream s = topology.newStream("xx", new SentenceSpout())
				.groupBy(new Fields("name"))
				.aggregate(new Count(),new Fields("count"))
			;
			
			s.each(s.getOutputFields(), new PrintFilter());
		
		
		//--提交到集群中运行
		Config conf = new Config();
		LocalCluster cluster = new LocalCluster();
		cluster.submitTopology("MyTopology", conf, topology.build());
		
		//--运行10秒钟后杀死Topology关闭集群
		Utils.sleep(1000 * 10);
		cluster.killTopology("MyTopology");
		cluster.shutdown();
		
	}
}

package com.liming.groupby;

import java.util.Map;

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 backtype.storm.utils.Utils;

public class SentenceSpout extends BaseRichSpout{

	private SpoutOutputCollector collector = null;
	
	private Values [] values = {
			new Values("xiaoming","i am so shuai"),
			new Values("xiaoming","do you like me"),
			new Values("xiaohua","i do not like you"),
			new Values("xiaohua","you look like fengjie"),
			new Values("xiaoming","are you sure you do not like me"),
			new Values("xiaohua","yes i am"),
			new Values("xiaoming","ok i am sure")
	};
	
	private int index = 0;
	@Override
	public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
		this.collector = collector;
	}

	@Override
	public void nextTuple() {
		if(index<values.length){
			collector.emit(values[index]);
			index++;
		}
		Utils.sleep(100);
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		Fields fields = new Fields("name","sentence");
		declarer.declare(fields);
	}

}

package com.liming.groupby;

import java.util.Iterator;
import java.util.Map;

import backtype.storm.tuple.Fields;
import storm.trident.operation.BaseFilter;
import storm.trident.operation.TridentOperationContext;
import storm.trident.tuple.TridentTuple;

public class PrintFilter extends BaseFilter{

	private TridentOperationContext context = null;
	@Override
	public void prepare(Map conf, TridentOperationContext context) {
		super.prepare(conf, context);
		this.context = context;
	}
	
	@Override
	public boolean isKeep(TridentTuple tuple) {
		StringBuffer buf = new StringBuffer();
		buf.append("---partition_id:"+context.getPartitionIndex());
		
		Fields fields = tuple.getFields();
		Iterator<String> it = fields.iterator();

		while(it.hasNext()){
			String key = it.next();
			Object value = tuple.getValueByField(key);
			buf.append("---"+key+":"+value+"---");
		}
		System.out.println(buf.toString());
		
		return true;
	}
	
}

结果如下：

五、合并和连接 - Merges and joins

可以将几个stream汇总到一起，最简单的汇总方法是将他们合并成一个stream，这个可以通过TridentTopology中的merge方法完成

		例如：
			topology.merge(stream1, stream2, stream3);
			Trident指定新的合并之后的流中的字段为stream1中的字段。
			所有的流中的字段必须一致才能进行merge

	另一种汇总方法是使用join（连接，类似于sql中的连接操作）。
	下面的在stream1( ["key", "val1", "val2"] ) 和 stream2["x", "val1"]

	例如：
		topology.join(stream1, new Fields("key"), stream2, new Fields("x"), new Fields("key", "a", "b", "c"));
		上面这个连接操作使用”key”和”x”字段作为连接字段。由于输入流中有重叠的字段名（如上面的val1字段在stream1和stream2中都有），Trident要求指定输出的新流中的所有字段。输出流中的tuple要包含下面这些字段：

		1、连接字段列表：如本例中的输出流中的”key”字段对应stream1中的”key”和stream2中的”x”。
		2、来自所有输入流中的非连接字段列表，按照传入join方法中的输入流的顺序：如本例中的”a”和”b”对应于stream1中的”val1″ 和 “val2″，”c” 对应stream2中的 “val1″。

		**注意：要连接的stream必须在同一个Topology中

流一样的合并

package com.liming.merge;

import backtype.storm.Config;
import backtype.storm.LocalCluster;
import backtype.storm.tuple.Fields;
import backtype.storm.utils.Utils;
import storm.trident.Stream;
import storm.trident.TridentTopology;
/**
 * 合并操作案例
 */
public class TridentDemo5 {
	public static void main(String[] args) {
		//--创建topology
		TridentTopology topology = new TridentTopology();
		
		/**
		 * merge
		 */
		Stream s1 = topology.newStream("xx", new SentenceSpout());
		Stream s2 = topology.newStream("yy", new SentenceSpout());
		Stream s3 = topology.newStream("zz", new SentenceSpout());
		Stream s = topology.merge(s1,s2,s3);
		s.each(s.getOutputFields(), new PrintFilter());
		
		//--提交到集群中运行
		Config conf = new Config();
		LocalCluster cluster = new LocalCluster();
		cluster.submitTopology("MyTopology", conf, topology.build());
		
		//--运行10秒钟后杀死Topology关闭集群
		Utils.sleep(1000 * 10);
		cluster.killTopology("MyTopology");
		cluster.shutdown();
		
	}
}

package com.liming.merge;

import java.util.Map;

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 backtype.storm.utils.Utils;

public class SentenceSpout extends BaseRichSpout{

	private SpoutOutputCollector collector = null;
	
	private Values [] values = {
			new Values("xiaoming","i am so shuai"),
			new Values("xiaoming","do you like me"),
			new Values("xiaohua","i do not like you"),
			new Values("xiaohua","you look like fengjie"),
			new Values("xiaoming","are you sure you do not like me"),
			new Values("xiaohua","yes i am"),
			new Values("xiaoming","ok i am sure")
	};
	
	private int index = 0;
	@Override
	public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
		this.collector = collector;
	}

	@Override
	public void nextTuple() {
		if(index<values.length){
			collector.emit(values[index]);
			index++;
		}
		Utils.sleep(100);
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		Fields fields = new Fields("name","sentence");
		declarer.declare(fields);
	}

}

package com.liming.merge;

import java.util.Iterator;
import java.util.Map;

import backtype.storm.tuple.Fields;
import storm.trident.operation.BaseFilter;
import storm.trident.operation.TridentOperationContext;
import storm.trident.tuple.TridentTuple;

public class PrintFilter extends BaseFilter{

	private TridentOperationContext context = null;
	@Override
	public void prepare(Map conf, TridentOperationContext context) {
		super.prepare(conf, context);
		this.context = context;
	}
	
	@Override
	public boolean isKeep(TridentTuple tuple) {
		StringBuffer buf = new StringBuffer();
		buf.append("---partition_id:"+context.getPartitionIndex());
		
		Fields fields = tuple.getFields();
		Iterator<String> it = fields.iterator();

		while(it.hasNext()){
			String key = it.next();
			Object value = tuple.getValueByField(key);
			buf.append("---"+key+":"+value+"---");
		}
		System.out.println(buf.toString());
		
		return true;
	}
	
}

结果如下：

 

流不一样的合并：

package com.liming.merge;

import backtype.storm.Config;
import backtype.storm.LocalCluster;
import backtype.storm.tuple.Fields;
import backtype.storm.utils.Utils;
import storm.trident.Stream;
import storm.trident.TridentTopology;
/**
 * 合并操作案例
 */
public class TridentDemo5 {
	public static void main(String[] args) {
		//--创建topology
		TridentTopology topology = new TridentTopology();
		
		
		Stream s1 = topology.newStream("xx", new SentenceSpout());
		Stream s2 = topology.newStream("yy", new GenderSpout());
		Stream s = topology.join(s1, new Fields("name"), s2, new Fields("name"),new Fields("name","sentence","gender"));
		s.each(s.getOutputFields(), new PrintFilter());
		
		//--提交到集群中运行
		Config conf = new Config();
		LocalCluster cluster = new LocalCluster();
		cluster.submitTopology("MyTopology", conf, topology.build());
		
		//--运行10秒钟后杀死Topology关闭集群
		Utils.sleep(1000 * 10);
		cluster.killTopology("MyTopology");
		cluster.shutdown();
		
	}
}

package com.liming.merge;

import java.util.Map;

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 backtype.storm.utils.Utils;

public class SentenceSpout extends BaseRichSpout{

	private SpoutOutputCollector collector = null;
	
	private Values [] values = {
			new Values("xiaoming","i am so shuai"),
			new Values("xiaoming","do you like me"),
			new Values("xiaohua","i do not like you"),
			new Values("xiaohua","you look like fengjie"),
			new Values("xiaoming","are you sure you do not like me"),
			new Values("xiaohua","yes i am"),
			new Values("xiaoming","ok i am sure")
	};
	
	private int index = 0;
	@Override
	public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
		this.collector = collector;
	}

	@Override
	public void nextTuple() {
		if(index<values.length){
			collector.emit(values[index]);
			index++;
		}
		Utils.sleep(100);
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		Fields fields = new Fields("name","sentence");
		declarer.declare(fields);
	}

}

package com.liming.merge;

import java.util.Map;

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 backtype.storm.utils.Utils;

public class GenderSpout extends BaseRichSpout{

	private SpoutOutputCollector collector = null;
	
	private Values [] values = {
			new Values("xiaoming","male"),
			new Values("xiaohua","female"),
	};
	
	private int index = 0;
	@Override
	public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
		this.collector = collector;
	}

	@Override
	public void nextTuple() {
		if(index<values.length){
			collector.emit(values[index]);
			index++;
		}
		Utils.sleep(100);
	}
//	@Override
//	public void nextTuple() {
//		collector.emit(values[index]);
//		index = index+1 == values.length ? 0 : index+1;
//		Utils.sleep(100);
//	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		Fields fields = new Fields("name","sentence");
		declarer.declare(fields);
	}

}

package com.liming.merge;

import java.util.Iterator;
import java.util.Map;

import backtype.storm.tuple.Fields;
import storm.trident.operation.BaseFilter;
import storm.trident.operation.TridentOperationContext;
import storm.trident.tuple.TridentTuple;

public class PrintFilter extends BaseFilter{

	private TridentOperationContext context = null;
	@Override
	public void prepare(Map conf, TridentOperationContext context) {
		super.prepare(conf, context);
		this.context = context;
	}
	
	@Override
	public boolean isKeep(TridentTuple tuple) {
		StringBuffer buf = new StringBuffer();
		buf.append("---partition_id:"+context.getPartitionIndex());
		
		Fields fields = tuple.getFields();
		Iterator<String> it = fields.iterator();

		while(it.hasNext()){
			String key = it.next();
			Object value = tuple.getValueByField(key);
			buf.append("---"+key+":"+value+"---");
		}
		System.out.println(buf.toString());
		
		return true;
	}
	
}

结果如下：

storm-strange-loop-110920101342-phpapp01
03-28
标题“storm-strange-loop-***-phpapp01”暗示该文档可能涉及“Storm”和“Strange Loop”两个主要概念。Storm是一种开源的实时计算系统，它设计用于处理大量的数据流，并且具有分布式和容错特性。Strange Loop是一...
storm-esper-example
07-02
这个模拟的主要类是 com.neulion.stream.OneHourOnlineVisitorsMain 解压数据目录下的数据文件：drcSimulator.1.2013-01-07 00.7z 将 config.properties-template 重命名为 config.properties，确保参数 ...
Storm集群搭建-01
kxj19980524的博客
05-15 263
jar包下载 （1）官方网址：http://storm.apache.org/ 虚拟机准备 1）准备3台虚拟机 2）配置ip地址 3）配置主机名称 4）3台主机分别关闭防火墙 5) 安装jdk 6) 安装Zookeeper集群 Storm集群部署 解压后,进入storm/目录下创建data文件夹,用来存放数据 修改这个配置文件时,格式要正确...
Storm-0.8.1集群部署
panguoyuan的专栏
09-24 1780
1、下载storm-0.8.1.zip 2、
storm-01（4）
tansuoliming的博客
09-15 207
测试如下： 思考3 - 如果存在下列tuple和聚合器，请问经过聚合器的结果是什么： 假设输入流包括字段 ["a", "b"] ，并有下面的partitions： Partition 0: ["a", 1] ["b", 2] Partition 1: ["a", 3] ["c", 8] Partition 2
storm-01（2）
tansuoliming的博客
09-15 209
以下介绍可靠性处理2、3（顺序处理、每个只处理一次） ============================================================ Strom的可靠处理引发的问题 在Storm进行可靠处理时，由于tuple可能被再次发送，所以在storm上进行统计个数之类的实现时，可能会存在重复计数问题。 Storm提供了机制可以实现"按顺序处理且只处理一次"的...
Storm-集群安装Storm
qq_38709565的博客
12-05 371
1.集群部署的基本流程 集群部署的流程：下载安装包、解压安装包、修改配置文件、分发安装包、启动集群 2.集群部署的基础环境准备 安装前的准备工作（zk集群已经部署完毕） 3、Storm集群部署 3.1、下载安装包 wget    http://124.202.164.6/files/1139000006794ECA/apache.fayea.com/storm/apache-storm...
Storm-01（1）
tansuoliming的博客
04-18 386
一、Storm概述 Storm是一个开源的分布式实时计算系统，可以简单、可靠的处理大量的数据流。Storm有很多使用场景：如实时分析，在线机器学习，持续计算，分布式RPC，ETL等等。Storm支持水平扩展，具有高容错性，保证每个消息都会得到处理，而且处理速度很快(在一个小集群中，每个结点每秒可以处理数以百万计的消息)。Storm的部署和运维都很便捷，而且更为重要的是可以使用任意编程语言来开发应...
storm-01（3）
tansuoliming的博客
09-15 298
3.分区聚合操作 分区聚合操作由 聚合器 - CombinerAggregator, ReducerAggregator, Aggregator 来实现。 分区聚合操作(partitionAggregate)对每个Partition中的tuple进行聚合. 与前面的Function在原tuple后面追加数据不同，分区聚合操作的输出会直接替换掉输入的tuple，仅输出分区聚合操作中发...
storm-kafka-client使用
congtuo7221的博客
09-28 835
packagehgs.core.sk; importjava.util.Map; importorg.apache.kafka.clients.consumer.ConsumerConfig; importor...
kafka-storm-es
weixin_40944388的博客
08-14 842
kafka-storm-es这条线其实就两个结点，kafka-storm还行，storm-es我主要是参考了 https://blog.csdn.net/yl3395017/article/details/77496034?utm_source=gold_browser_extension这篇博客，因为里面缺失了很多东西，而且我的代码也有些改动，在这里将自己走过的坑分享一下，希望对君有用。 我...
01、Storm的集群搭建 03-storm部署-2.avi
02-14
01、Storm的集群搭建 03-storm部署-2.avi
Eclipse中zookeeper插件安装和使用
tansuoliming的博客
03-24 6377
1.需要联网2.打开Eclipse=》help=》install new software3.点击add，添加如下的url:http://www.massedynamic.org/eclipse/updates/4.选择好插件，三个全部勾选。然后点击next进行安装5.显示正在下载和安装6.调出Zookeeper的视图7.新建Zookeeper连接服务，并填好name和RootPath，然后点击a...
网站流量统计分析系统-01
tansuoliming的博客
04-20 4972
一、需求分析网站流量统计系统需求分析二、项目架构三、具体实现1.js埋点0准备工作（准备两个页面a.jsp和b.jsp）：a.jsp代码如下：&lt;%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%&gt; &lt;!DOCTYPE html&gt; &lt;html&g..
spark-04：spqrkSql
tansuoliming的博客
05-02 1455
1.spark-sql风靡之因1）  SQL，foxpro baseIII，SQLServer（微软的产品） 2000,2005,2008,2012，SyBase （微软的前生【大概在版本6时被微软买了版权，就像微软在操作系统方面，买了dos的版权】，powerdesigner就是sybase的产品，它天生就是做大数据量的，出现要比oracle还早）, Oracle 6i（2000年），7i，8i...
Avro
tansuoliming的博客
03-24 646
1.创建maven工程2.导入依赖&lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache....
hadoop--01
tansuoliming的博客
03-28 642
hadoop伪分布模式安装伪分布式模式：用多个线程模拟多台真实机器，即模拟真实的分布式环境。安装步骤：0.关闭防火墙执行：service iptablesstop  这个指令关闭完防火墙后，如果重启，防火墙会重新建立，所以，如果想重启后防火墙还关闭，需额外执行：chkconfig iptables off 1.配置主机名执行：vim /etc/sysconfig/network编辑主机名注意：主机...
网站流量统计分析系统-02
tansuoliming的博客
04-21 585
0.将埋点收到的数据通过flume导入到kafka中a.配置flume的配置文件配置文件有两种：第一种是需要导入插件的，第二种是使用flume原生的。以下配置是第二种#agent a1.sources = r1 a1.sinks = k1 a1.channels = c1 #Source a1.sources.r1.type = avro a1.sources.r1.bind...
spark
tansuoliming的博客
04-28 471
一、spark为什么兴起1.大数据平台（1）列举hadoop（亚马逊）、spark（2）两个核心分布式计算:MapReduce、spark        MR分布式计算不足：离线计算  （中间运算结果存盘）pb级别的数据        Spark（解决快慢问题）spark速度快分布式存储 :HDFS 、gfs[谷歌分布式文件系统系统] 、S3[亚马逊分布式文件存储系统]、tachyon内存分布式文...
KafKa+Storm资料与源码安装包集合
此外，还有一系列的rar压缩包，其中包含名为“storm01”到“storm07”的课上代码，这些代码文件可能包含了关于Storm的实用案例和示例程序，是学习Storm编程的重要资源。 在使用这些安装包和资料时，需要注意以下几...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值