strom的API的使用

整体的思路

• 由spout来发送任务给bolt，spout可以设置为多个，bolt也可以设置为多个。再由driver来统一管理。

操作步骤

• 项目结构（可以有多个bolt来分级处理）
  

依赖

<?xml version="1.0" encoding="UTF-8"?>
<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.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ujiuye.hadoop1105</groupId>
    <artifactId>test2</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.10</version>
        </dependency>

        <dependency>
            <groupId>org.apache.storm</groupId>
            <artifactId>storm-core</artifactId>
            <version>1.1.0</version>
        </dependency>
    </dependencies>


    <!--指定java编译版本，固定配置即可-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

• spout编写

实现：
IRichSpout类。
重写：
open（定义读取文件）
nextTuple（发射数据）
declareOutputFields（设置标识字段，用来被bolt识别）
属性
定义输入流与发射器：发射器由底层调用。输入流对象来获取信息以供发射。

package com.uu.strom;

import org.apache.storm.spout.SpoutOutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.IRichSpout;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Values;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.Map;

/**
 * Created by Administrator on 2019/10/25.
 */
public class WebsiteLogSpout implements IRichSpout {
    BufferedReader reader = null;
    SpoutOutputCollector collector = null;
    //表示忽略指定的警告
    @SuppressWarnings("resource")
    public void open(Map map, TopologyContext topologyContext, SpoutOutputCollector collector) {
        try {
            reader = new BufferedReader(new InputStreamReader(new FileInputStream("d:/website.log"), "UTF-8"));
            this.collector = collector;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    //在这里把数据组装为tuple，并且将tuple发射出去
    //利用reader读取一行，组装为tuple，发射一行
    public void nextTuple() {
        try {
            String readLine = reader.readLine();
            //如果要想实现spout的可靠功能，必须给每个tuple加上唯一的id，从而让框架帮助我们追踪tuple的处理情况
            collector.emit(new Values(readLine), System.currentTimeMillis());
            Thread.sleep(300);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("IS"));
    }

    @Override
    public void ack(Object o) {
        //成功读入

    }

    @Override
    public void fail(Object o) {
        //读入失败
    }



    @Override
    public Map<String, Object> getComponentConfiguration() {
        return null;
    }



    @Override
    public void close() {

    }

    @Override
    public void activate() {

    }

    @Override
    public void deactivate() {

    }
}

• boltt编写

实现：
IRichBolt类。
重写：
prepare（获取发射器，由底层实现）
execute（执行数据的处理，可以继续发送。也可以打印）
declareOutputFields（设置标识字段，用来被bolt识别）
属性
定义发射器：发射器由底层调用。

package com.uu.strom;

import org.apache.storm.task.OutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.IRichBolt;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.tuple.Tuple;

import java.util.Map;

/**
 * Created by Administrator on 2019/10/25.
 * 处理流的组件
 */
public class WebsiteLogBolt implements IRichBolt {

    //Bolt输出收集器使用的是OutputCollector
    OutputCollector collector = null;

    int num;

    @Override
    public void prepare(Map map, TopologyContext topologyContext, OutputCollector collector) {
        this.collector = collector;
    }

    @Override
    //接受上个组件发射过来的tuple，这里是指spout，
    public void execute(Tuple input) {
        try {
            String stringByField = input.getStringByField("IS");
            if (stringByField != null) {
                //进行计数
                num ++;
                //进行分割，取出sessionid
//                String sessionid = stringByField.split("\t")[num++];
                String[] split = stringByField.split("\t");
                for (String s : split) {

                //打印线程id，行数，sessionid
                    System.out.println(Thread.currentThread().getId() + "--" + num + "--" + s);
                    Thread.sleep(200);
                    //处理tuple成功，回调spout的ack方法，告知其次tuple处理成功
                    collector.ack(input);
                }
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            //处理tuple失败，回调spout的fail方法，告知其tuple处理失败
            collector.fail(input);
        }
    }

    @Override
    public void cleanup() {

    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {

    }

    @Override
    public Map<String, Object> getComponentConfiguration() {
        return null;
    }
}

• driver编写

• 多个bolt顺序执行要在setBolt方法中给给予说明。

例

setSpout参数说明
(在流中的名字，项目中的的自己写的类，设置数量)
setBolt参数说明
(在流中的名字，项目中的的自己写的类，数据的来源（参数为在本driver中的设置的名字）)
shuffleGrouping：随机分组
fieldsGrouping：按字母分组。
指定declareOutputFields中设置的字段进行线程的分组，即同一个字母分配给同一个线程。

 //拓扑构建器
        TopologyBuilder topologyBuilder = new TopologyBuilder();
        //设置spout与bolt
        //整个串联起来。
        topologyBuilder.setSpout("spout",new Spout(),1);
        //次数设置以shuffer的方式来获取数据。shuffer表示来源随机分组。
        topologyBuilder.setBolt("countBolt",new CountBolt(),1).shuffleGrouping("spout");
        //第二个bolt的数据来源于第一个bolt。
        topologyBuilder.setBolt("countBolt1",new ExecuteBole(),2).fieldsGrouping("countBolt",new Fields("one"));

实例的案例。单词统计。

package com.uu.strom;

import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.StormSubmitter;
import org.apache.storm.topology.TopologyBuilder;

/**
 * Created by Administrator on 2019/10/25.
 */
public class TopologyDriver  {
    public static void main(String[] args) throws Exception {
        // 1 创建一个拓扑构建器
        TopologyBuilder builder = new TopologyBuilder();
        // 2 设置spout、bolt
        /*
        * 执行
        * */
        builder.setSpout("websiteSpout", new WebsiteLogSpout(), 1);
        /*
        * 执行的是bolt中的execute方法，数字值为1是一个bolt。
        * */
        builder.setBolt("websiteBolt", new WebsiteLogBolt(), 2).shuffleGrouping("websiteSpout");
        // 3 设置worker的数量
        Config conf = new Config();
        conf.setNumWorkers(1);
        // 4 提交到storm集群
        if (args.length > 0) {
            StormSubmitter.submitTopology("websiteTopo", conf, builder.createTopology());
        } else {
            LocalCluster cluster = new LocalCluster();
            cluster.submitTopology("websiteTopo", conf, builder.createTopology());
        }
    }
}

在linux中的实现

storm jar 【jar路径】 【拓扑包名.拓扑类名】 【传入参数】
 【拓扑名称】

下一个案例：相同字母的统计，使用map来实现。