Storm - Trident

[align=center][size=large]Trident[/size][/align]

一、Storm 保证性

1.数据一定会发送
通过 ack / fail 方法确认，若失败，则提供重新发送的机制

2.数据一定只会统计一次
数据发送后有一个唯一性的标识，通过判断此标识，若存在，则不处理

3.数据一定会按照顺序进行处理
数据发送后有一个唯一性的标识，按照标识编号的顺序进行处理

二、Storm 保证性实现

1.逐个发送，逐个处理

如果这样处理，则原有的并行处理会变成穿行处理，不可取

2.批量发送，批量处理

如果这样处理，则如果当前这批数据处理完毕但未发送，则无法处理下一批数据，且这一批数据之间的处理顺序是并发的在进行的

3.分成两个步骤
一个处理数据，一个发送数据；
数据处理完毕，则继续处理下一批数据；数据是否发送到下一个缓解，由发送数据的步骤决定
采用此方式

三、Trident

1.Spout

package com.study.storm.trident.wordcount;

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;

/**
 * @description
 * 数据来源
 * 模拟批量数据发送
 * <br/>
 * @remark
 * Storm 的保证及实现
 * 1.数据一定被发送
 * 通过 ack() 、 fail() 的确认机制，若发送失败，则重新发送
 * 2.数据只被处理一次
 * 数据发送时带有唯一的编号，判断此编号是否被处理过，若是，则忽略，不处理
 * 3.数据被按照一定的顺序处理
 * 数据发送时带有唯一的编号，按照编号的顺序进行处理，若数据不是按照顺序到达，则等待
 * 
 * <br/>
 * 
 * Trident 处理批量数据
 * 
 */
public class SentenceSpout extends BaseRichSpout {

	/**
	 * 
	 */
	private static final long serialVersionUID = 2122598284858356171L;

	private SpoutOutputCollector collector = null ;

	/**
	 * 模拟批量数据发送
	 * key : name 
	 * value : sentence 
	 */
	private Values [] valuesArray = new Values[] {
			new Values("a","111111111111"),
			new Values("b","222222222222"),
			new Values("c","333333333333"),
			new Values("d","444444444444"),
			new Values("e","555555555555"),
			new Values("f","666666666666"),
			new Values("g","777777777777"),
			new Values("h","888888888888")
	};

	@SuppressWarnings("rawtypes")
	@Override
	public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
		this.collector = collector ;
	}

	// 发送的顺序，即数据组合的下标，标识数据发送到哪个位置
	private int index = 0 ;

	@Override
	public void nextTuple() {

		if(index >= valuesArray.length){
			return ;
		}
		index = index == valuesArray.length ? 0 : index++ ;
		this.collector.emit(valuesArray[index]);
	}

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

}

简化实现

package com.study.storm.trident.wordcount;

import backtype.storm.Config;
import backtype.storm.LocalCluster;
import backtype.storm.generated.StormTopology;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Values;
import backtype.storm.utils.Utils;
import storm.trident.Stream;
import storm.trident.TridentTopology;
import storm.trident.testing.FixedBatchSpout;

public class TridentTopologyDemo {

	public static void main(String[] args) {

		// 相当于原有的 Spout 实现
		@SuppressWarnings("unchecked")
		FixedBatchSpout tridentSpout = new FixedBatchSpout(new Fields("name","sentence"),
				1,
				new Values("a","111111111111"),
				new Values("b","222222222222"),
				new Values("c","333333333333"),
				new Values("d","444444444444"),
				new Values("e","555555555555"),
				new Values("f","666666666666"),
				new Values("g","777777777777"),
				new Values("h","888888888888"));
		// 是否循环发送，false 不
		tridentSpout.setCycle(false);

		TridentTopology topology = new TridentTopology();
		/**
		 *  1.本地过滤器设置
		 */
		// 设置数据源
		Stream initStream = topology.newStream("tridentSpout", tridentSpout);
		// 设置过滤器  -- 过滤name : d 的数据  
		initStream = initStream.each(new Fields("name"),new RemovePartDataFilter());
		// 添加函数，输出字母对应的位置
		initStream = initStream.each(new Fields("name"),new NameIndexFunction() ,new Fields("indexNum"));

		// 设置过滤器  -- 拦截数据并打印
		Stream filterPrintStream = initStream.each(new Fields("name","sentence"), new PrintFilter());








		//--提交Topology给集群运行
		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.study.storm.trident.wordcount;

import java.util.Iterator;

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

/**
 * @description 
 * 打印：key 与 value ，fields 与  fields 对应传输的内容
 */
public class PrintFilter extends BaseFilter {

	/**
	 * 
	 */
	private static final long serialVersionUID = 4393484291178519442L;

	@Override
	public boolean isKeep(TridentTuple tuple) {
		Fields fields = tuple.getFields();
		Iterator<String> iterator = fields.iterator();
		while(iterator.hasNext()){
			String key = iterator.next();
			Object valueByField = tuple.getValueByField(key);
			System.out.println("fields : "+ key + " values : "+valueByField);
		}

		return true;
	}

}

package com.study.storm.trident.wordcount;

import storm.trident.operation.BaseFilter;
import storm.trident.tuple.TridentTuple;

/**
 * 过滤name = d 的数据
 * return false 过滤
 * return true  继续传递
 */
public class RemovePartDataFilter extends BaseFilter {

	/**
	 * 
	 */
	private static final long serialVersionUID = 8639858690618579558L;

	@Override
	public boolean isKeep(TridentTuple tuple) {
		String stringByField = tuple.getStringByField("name");
		return !stringByField.equals("d");
	}

}

package com.study.storm.trident.wordcount;

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

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

public class NameIndexFunction extends BaseFunction {

	/**
	 * 
	 */
	private static final long serialVersionUID = 9085021905838331812L;

	static Map<String,Integer> indexMap = new HashMap<String,Integer>();
	static {
		indexMap.put("a", 1);
		indexMap.put("b", 2);
		indexMap.put("c", 3);
		indexMap.put("d", 4);
		indexMap.put("e", 5);
		indexMap.put("f", 6);
		indexMap.put("g", 7);
		indexMap.put("h", 8);
		indexMap.put("i", 9);
	}

	@Override
	public void execute(TridentTuple tuple, TridentCollector collector) {
		String name = tuple.getStringByField("name");
		collector.emit(new Values(indexMap.get(name)));
	}

}