storm部分：storm的架构介绍

storm是并行计算的框架

storm是一种有向无环的方式，并且是并行计算的方式，是一种实时的方式

 flume：消息采集器

kafka：消息队列

storm异步实时处理请求：

异步是指是有向无环的方式

同步的话：需要借助于分布式远程服务

 Storm的架构：

Spolt负责推送数据

Bolt负责处理数据

topology负责分发策略

local cluster负责创建集群

如果有多个流程的话，spolt依然是发送数据的，bolt端在处理之前还会切分

最终：相同的词要汇聚在一个bolt中，正如MapReduce中的源于：相同的key为一组，这一组key调用一次reduce方法。

storm是一个流式处理框架，有数据就处理，没有数据就等待中，是一个死循环，除非断掉。

Spolt端：

package com.bjsxt.storm.spout;

import java.util.List;
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;
/**
 * 
 * 数据累加： 1+2+3+4......
 * 
 * @author Administrator
 *
 */
public class WsSpout extends BaseRichSpout {
	Map map;
	TopologyContext context;
	SpoutOutputCollector collector;// 发送器
	int i = 0;
	/**
	 * 发送数据，不断被线程调用
	 */
	@Override
	public void nextTuple() {
		i++;
		List tuple = new Values(i);
		this.collector.emit(tuple);
		System.err.println("spout -----------------------" + i);

		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {

			e.printStackTrace();
		}
	}

	@Override
	public void open(Map map, TopologyContext context, SpoutOutputCollector collector) {
		this.map = map;
		this.context = context;
		this.collector = collector;
	}

	/**
	 * 声明发送数据的信息
	 */
	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		declarer.declare(new Fields("num"));
	}
}

Bolt端：

package com.bjsxt.storm.bolt;

import java.util.Map;

import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseRichBolt;
import backtype.storm.tuple.Tuple;

public class WsBolt extends BaseRichBolt {

	Map stormConf;
	TopologyContext context;
	OutputCollector collector;
	int sum = 0;
	@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) {
		// 1.接收tuple内的数据
		int i = input.getIntegerByField("num");

		// 2.累加
		sum += i;
		
		//3.输出效果
		System.out.println("sum-------------------------------"+sum);
		
	}

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

主方法：

package com.bjsxt.storm.test;

import com.bjsxt.storm.bolt.WsBolt;
import com.bjsxt.storm.spout.WsSpout;

import backtype.storm.Config;
import backtype.storm.LocalCluster;
import backtype.storm.topology.TopologyBuilder;

/**
 * 
 * 构建拓扑结构 Topology ----- 》job
 * 
 * @author Administrator
 *
 */
public class Test {

	public static void main(String[] args) {
		
		TopologyBuilder tb = new TopologyBuilder();
		
		tb.setSpout("wsspout", new WsSpout());
		tb.setBolt("wsbolt", new WsBolt()).shuffleGrouping("wsspout");
		

		//创建本地服务集群
		LocalCluster lc = new LocalCluster();
		lc.submitTopology("ws", new Config(), tb.createTopology());
		
		
	}

}