Storm分布式实时计算框架

Storm

1. 信息流处理{Stream processing} 

Storm可用来实时处理新数据和更新数据库，兼具容错性和可扩展性。 

2. 连续计算{Continuous computation} 

Storm可进行连续查询并把结果即时反馈给客户端。比如把Twitter上的热门话题发送到浏览器中。 

3. 分布式远程程序调用{Distributed RPC} 

Storm可用来并行处理密集查询。Storm的拓扑结构是一个等待调用信息的分布函数，当它收到一条调用信息后，会对查询进行计算，并返回查询结果。  举个例子Distributed RPC可以做并行搜索或者处理大集合的数据。

       

 

Storm集群的组件介绍：

        storm集群是表面上类似于Hadoop集群。而在Hadoop上运行“MapReduce作业”，在storm运行“topologies”。 “jobs”和“topologies”本身有很大的不同 - 一个关键的区别是，一个MapReduce作业最终完成，而一个永远的拓扑信息进行处理（或直到你杀了它）。

        有两种类型的节点运行在Storm集群中：

(1)主节点（master）主节点运行着一个守护进程“Nimbus“，这个类似于hadoop的jobtracker,Nimbus 负责将任务分配给worker机器，并监视故障。

(2)工作节点（worker）运行着一个守护进程"Supervisor",他主管侦听分配给它的机器和启动工作，并停止工作进程在必要时依据"Nimbus"已经分配给它的任务。

        

        Nimbus与supervisor之间的所有通信都是通过ZK来传递的，另外Nimbus的守护进程和监事守护进程快速失败和无状态的。所有的状态都是保存在ZK中或者本地的磁盘中的。这就意味着你可以通过Kill -9来杀死 Nimbus与supervisor进程，然后他们启动就像没发生过任何事情一样。这样的设计使得storm集群非常稳定。

        如何将你的storm程序在storm集群中跑呢？

storm jar all-my-code.jar backtype.storm.MyTopology arg1 arg2

all-my-code.jar（包名）   backtype.storm.MyTopology（类名-默认是定位到main方法）   arg1 arg2（参数） 

           Streams

一个stream是一个没有边界的tuples.storm将一个流分成以分布式和可靠的方式的新的流。提供了一个数据流的转换：“spouts”，“bolts”。spouts和bolts有你实现运行的应用程序特定的逻辑接口。spouts其实就是一个数据源，一个spout去读取数据源，以tuples的形式通过emit()发射出去，然后bolts接受tuples。实际应用中可以有多个spout发射数据，并且由多个bolts接收数据，bolts也可以将接收到的数据再发射给其他bolts。

 

结构如下图所示：

这个拓扑将永远运行下去，或者直到你杀死它。storm将自动重新分配任何失败的任务。此外，Storm保证不会有数据丢失，即使宕机。

一个简单的例子拓扑:

1、SimpleSpout类继承BaseRichSpout类，用来产生数据并且向topology里面发出消息：tuple。

 

package com.ljq.helloword;

import java.util.Map;
import java.util.Random;

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;

/**
 * Spout起到和外界沟通的作用，他可以从一个数据库中按照某种规则取数据，也可以从分布式队列中取任务
 * 
 * @author Administrator
 *
 */
@SuppressWarnings("serial")
public class SimpleSpout extends BaseRichSpout{
    //用来发射数据的工具类
    private SpoutOutputCollector collector;
    private static String[] info = new String[]{
        "comaple\t,12424,44w46,654,12424,44w46,654,",
        "lisi\t,435435,6537,12424,44w46,654,",
        "lipeng\t,45735,6757,12424,44w46,654,",
        "hujintao\t,45735,6757,12424,44w46,654,",
        "jiangmin\t,23545,6457,2455,7576,qr44453",
        "beijing\t,435435,6537,12424,44w46,654,",
        "xiaoming\t,46654,8579,w3675,85877,077998,",
        "xiaozhang\t,9789,788,97978,656,345235,09889,",
        "ceo\t,46654,8579,w3675,85877,077998,",
        "cto\t,46654,8579,w3675,85877,077998,",
        "zhansan\t,46654,8579,w3675,85877,077998,"};
    
    Random random=new Random();
    
    /**
     * 初始化collector
     */
    public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
        this.collector = collector;
    }
    
    /**
     * 在SpoutTracker类中被调用，每调用一次就可以向storm集群中发射一条数据（一个tuple元组），该方法会被不停的调用
     */
    @Override
    public void nextTuple() {
        try {
            String msg = info[random.nextInt(11)];
            // 调用发射方法
            collector.emit(new Values(msg));
            // 模拟等待100ms
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 定义字段id，该id在简单模式下没有用处，但在按照字段分组的模式下有很大的用处。
     * 该declarer变量有很大作用，我们还可以调用declarer.declareStream();来定义stramId，该id可以用来定义更加复杂的流拓扑结构
     */
    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("source")); //collector.emit(new Values(msg));参数要对应
    }

}

 2、SimpleBolt类继承BaseBasicBolt类，处理一个输入tuple。

package com.ljq.helloword;

import backtype.storm.topology.BasicOutputCollector;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseBasicBolt;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;

/**
 * 接收喷发节点(Spout)发送的数据进行简单的处理后，发射出去。
 * 
 * @author Administrator
 * 
 */
@SuppressWarnings("serial")
public class SimpleBolt extends BaseBasicBolt {

    public void execute(Tuple input, BasicOutputCollector collector) {
        try {
            String msg = input.getString(0);
            if (msg != null){
                //System.out.println("msg="+msg);
                collector.emit(new Values(msg + "msg is processed!"));
            }
                
        } catch (Exception e) {
            e.printStackTrace(); 
        }
    }

    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("info"));
    }

}

 3、SimpleTopology类包含一个main函数，是Storm程序执行的入口点，包括一个数据喷发节点spout和一个数据处理节点bolt。

package com.ljq.helloword;

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

/**
 * 定义了一个简单的topology，包括一个数据喷发节点spout和一个数据处理节点bolt。
 * 
 * @author Administrator
 *
 */
public class SimpleTopology {
    public static void main(String[] args) {
        try {
            // 实例化TopologyBuilder类。
            TopologyBuilder topologyBuilder = new TopologyBuilder();
            // 设置喷发节点并分配并发数，该并发数将会控制该对象在集群中的线程数。
            topologyBuilder.setSpout("SimpleSpout", new SimpleSpout(), 1);
            // 设置数据处理节点并分配并发数。指定该节点接收喷发节点的策略为随机方式。
            topologyBuilder.setBolt("SimpleBolt", new SimpleBolt(), 3).shuffleGrouping("SimpleSpout");
            Config config = new Config();
            config.setDebug(true);
            if (args != null && args.length > 0) {
                config.setNumWorkers(1);
                StormSubmitter.submitTopology(args[0], config, topologyBuilder.createTopology());
            } else {
                // 这里是本地模式下运行的启动代码。
                config.setMaxTaskParallelism(1);
                LocalCluster cluster = new LocalCluster();
                cluster.submitTopology("simple", config, topologyBuilder.createTopology());
            }
            
        } catch (Exception e) {
            e.printStackTrace(); 
        }
    }
}

 运行结果效果如下：