storm基本使用和拓扑流程

最新推荐文章于 2022-11-22 17:31:43 发布
最新推荐文章于 2022-11-22 17:31:43 发布
阅读量604 收藏 1
点赞数
分类专栏： 项目学习-storm 文章标签： storm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013627689/article/details/78076430
版权

项目对于每个zip包里文件校验是通过storm的bolt处理的。每个bolt可以定义多个stream流，表示emit的时候可以选择性的发射元组到不同bolt进行处理。发射元祖的时候把文件的目录、清算日期、批次号等作为Field属性发射到下一个bolt，bolt获取这些参数后就可以根据路径去获取文件进行处理。

构建拓扑

package com.lancy.topology;

import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.StormSubmitter;
import org.apache.storm.generated.AlreadyAliveException;
import org.apache.storm.generated.AuthorizationException;
import org.apache.storm.generated.InvalidTopologyException;
import org.apache.storm.topology.TopologyBuilder;

import com.lancy.bolt.AuditFileCheckBolt;
import com.lancy.bolt.CardReleaseCheckBolt;
import com.lancy.bolt.DailyRechargeDataJoinBolt;
import com.lancy.bolt.DailyRechargeSummarizeBolt;
import com.lancy.bolt.FileBaseCheckBolt;
import com.lancy.bolt.FileLineFormatCheckBolt;
import com.lancy.bolt.FilePrvAndNxtTradeChkCrossFileBolt;
import com.lancy.bolt.FilePrvAndNxtTradeChkSingleFileBolt;
import com.lancy.bolt.FileRecordReplicationCheckBolt;
import com.lancy.bolt.InsertValidRecordMqBolt;
import com.lancy.bolt.OtherFileHandleBolt;
import com.lancy.bolt.OtherFileInsertDBBolt;
import com.lancy.bolt.RechargeCheckFileHandleBolt;
import com.lancy.bolt.ZipCheckBolt;
import com.lancy.bolt.lnt.InvalidDataHandleBolt;
import com.lancy.common.ConfigCommon;
import com.lancy.common.FieldsCommon;
import com.lancy.spout.ZipSpout;

/**
 * @ClassName LocalFileCheckTopology
 * @description 文件处理拓扑
 */

public class LocalFileCheckTopology {

    public static void main(String[] args) {
        Config config = new Config();
        config.setNumWorkers(8);
//      config.setNumWorkers(6);
        config.put("topology.backpressure.enable", Boolean.valueOf(false));
        config.put("topology.executor.receive.buffer.size", Integer.valueOf(16384));
        config.put("topology.executor.send.buffer.size", Integer.valueOf(16384));
        ConfigCommon.getInstance(); //初始化ConfigCommon
        if(args != null && args.length>0){
            try {
                StormSubmitter.submitTopology("local-filecheck--topology",config,topologyBuilder().createTopology());
            } catch (AlreadyAliveException e) {
                e.printStackTrace();
            } catch (InvalidTopologyException e) {
                e.printStackTrace();
            } catch (AuthorizationException e) {
                e.printStackTrace();
            }
        } else {
            config.setDebug(true);
            LocalCluster localCluster = new LocalCluster();
            localCluster.submitTopology("local-filecheck--topology-local-mode",config,topologyBuilder().createTopology());
//            try {
//                Thread.sleep(120*1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            localCluster.shutdown();
        }
    }

    public static TopologyBuilder topologyBuilder(){

        TopologyBuilder builder = new TopologyBuilder();
        builder.setSpout("01. " + "zipSpout", new ZipSpout(), 1);

        //setBolt参数1组件编号，参数2具体类
        //shuffleGrouping表示拓扑上游节点是什么，也就是拓扑流转的顺序，参数2是stream_id
        builder.setBolt("02. " + "zipCheckBolt", new ZipCheckBolt(), 16)
        .shuffleGrouping("01. " + "zipSpout", FieldsCommon.NORMAL);

        builder.setBolt("03. " + "auditFileCheckBolt", new AuditFileCheckBolt(),16)
        .shuffleGrouping("02. " + "zipCheckBolt", FieldsCommon.NORMAL);

        builder.setBolt("04. " + "fileBaseCheckBolt", new FileBaseCheckBolt(), 16)
        .shuffleGrouping("03. " + "auditFileCheckBolt", FieldsCommon.NORMAL);

        builder.setBolt("05. " +"fileLineFormatCheckBolt", new FileLineFormatCheckBolt(), 96)
        .shuffleGrouping("04. " + "fileBaseCheckBolt", FieldsCommon.NORMAL);

        builder.setBolt("06. " +"fileRecordReplicationCheckBolt", new FileRecordReplicationCheckBolt(), 48)
        .shuffleGrouping("05. " +"fileLineFormatCheckBolt", FieldsCommon.TRADE_FILE);

        builder.setBolt("07. " + "dailyRechargeSummarizeBolt", new DailyRechargeSummarizeBolt(), 16)
        .shuffleGrouping("06. " +"fileRecordReplicationCheckBolt", FieldsCommon.RECHARGE_SUMMARIZE);

        builder.setBolt("08. " +"filePrvAndNxtTradeChkSingleFileBolt", new FilePrvAndNxtTradeChkSingleFileBolt(), 48)
        .shuffleGrouping("06. " +"fileRecordReplicationCheckBolt", FieldsCommon.NORMAL)
        .shuffleGrouping("07. " + "dailyRechargeSummarizeBolt", FieldsCommon.NORMAL);

        builder.setBolt("09. " + "dailyRechargeDataJoinBolt", new DailyRechargeDataJoinBolt(), 16)
        .shuffleGrouping("01. " + "zipSpout", FieldsCommon.RECHARGE_JOIN);

        builder.setBolt("10. " + "filePrvAndNxtTradeChkCrossFileBolt", new FilePrvAndNxtTradeChkCrossFileBolt(), 16)
        .shuffleGrouping("09. " + "dailyRechargeDataJoinBolt", FieldsCommon.PREV_AND_NEXT_CHECK_CROSS_FILE);

        builder.setBolt("11. " +"insertValidRecordMqBolt", new InsertValidRecordMqBolt(), 256).setNumTasks(256)
        .shuffleGrouping("08. " +"filePrvAndNxtTradeChkSingleFileBolt", FieldsCommon.INSERT_VALID_MQ)
        .shuffleGrouping("10. " +"filePrvAndNxtTradeChkCrossFileBolt", FieldsCommon.INSERT_VALID_MQ);

        builder.setBolt("12. " +"invalidDataHandleBolt", new InvalidDataHandleBolt(), 16)
        .shuffleGrouping("05. " +"fileLineFormatCheckBolt", FieldsCommon.NON_VALID)
        .shuffleGrouping("06. " +"fileRecordReplicationCheckBolt", FieldsCommon.NON_VALID)
        .shuffleGrouping("08. " +"filePrvAndNxtTradeChkSingleFileBolt", FieldsCommon.NON_VALID)
        .shuffleGrouping("10. " + "filePrvAndNxtTradeChkCrossFileBolt", FieldsCommon.NON_VALID);

        builder.setBolt("13. " +"otherFileHandleBolt",new OtherFileHandleBolt(),16)
        .shuffleGrouping("05. " +"fileLineFormatCheckBolt",FieldsCommon.OTHER_FILE);

        builder.setBolt("14. " +"rechargeCheckFileHandleBolt", new RechargeCheckFileHandleBolt(), 16)
        .shuffleGrouping("05. " +"fileLineFormatCheckBolt",FieldsCommon.RECHARGE_CHECK_FILE);

        builder.setBolt("15. " +"cardReleaseCheckBolt", new CardReleaseCheckBolt(), 16)
        .shuffleGrouping("05. " +"fileLineFormatCheckBolt",FieldsCommon.CARD_DETAIL_FILE);

        builder.setBolt("16. " +"otherFileInsertDBBolt",new OtherFileInsertDBBolt(),16)
        .shuffleGrouping("13. " +"otherFileHandleBolt")
        .shuffleGrouping("14. " +"rechargeCheckFileHandleBolt")
        .shuffleGrouping("15. " +"cardReleaseCheckBolt");

        return builder;
    }
}

spout 类

package com.lingnanpass.spout;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.storm.spout.SpoutOutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseRichSpout;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Values;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.lingnanpass.common.CommUtil;
import com.lingnanpass.common.ConfigCommon;
import com.lingnanpass.common.FieldsCommon;
import com.lingnanpass.common.LntValidate;
import com.lingnanpass.common.WarnUtil;
import com.lingnanpass.common.pre.PreFileCheckUtil;
import com.lingnanpass.common.util.DateTransformUitl;
import com.lingnanpass.common.util.FileUtil;
import com.lingnanpass.common.util.FtpUtil;
import com.lingnanpass.common.util.JsonUtil;
import com.lingnanpass.common.util.MonitorUtil;
import com.lingnanpass.common.util.RedisUtil;
import com.lingnanpass.common.util.RuleMappingUtil;
import com.lingnanpass.common.util.ZIPUtil;
import com.lingnanpass.db.DbUtil;
import com.lingnanpass.db.JdbcTemplate;

/**
 * @ClassName ZipSpout
 * @description 从数据库zip队列中获取FTP上传数据的消息，根据消息中描述的FTP地址，文件名等信息下载文件
 * @author yaoyf
 */
@SuppressWarnings("serial")
public class ZipSpout extends BaseRichSpout {

    private SpoutOutputCollector _collector;


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

    @Override
    public void nextTuple() {
        //写业务代码
        int type = 0;
        if(type == 0){
            //发射后如何判断流到那个bolt呢，是通过
            //builder.setBolt("09. " + "dailyRechargeDataJoinBolt", new DailyRechargeDataJoinBolt(), 16)
        //.shuffleGrouping("01. " + "zipSpout", FieldsCommon.RECHARGE_JOIN);
            _collector.emit(FieldsCommon.RECHARGE_JOIN, new Values(entry.getKey()));
        }else{
            _collector.emit(FieldsCommon.NORMAL, new Values(zipAbsPath,clearingBatchNo,jyFileName, mCode, serviceCode, areaCode));
        }

    }

    //定义不同stream_id以及不同stream_id输出的字段参数,只有定义了才可以emit出去
    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declareStream(FieldsCommon.NORMAL, new Fields(FieldsCommon.ZIP_ABS_PATH,FieldsCommon.CLEARING_BATCH_NO,FieldsCommon.JY_FILE_NAME, FieldsCommon.MERCHANT,FieldsCommon.SERVICE_CODE, FieldsCommon.AREA_CODE));
        declarer.declareStream(FieldsCommon.RECHARGE_JOIN, new Fields(FieldsCommon.RECHARGE_SUMMARIZE_FLAG));
    }


}

其中一个bolt

package com.lancy.bolt;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import org.apache.commons.io.FileUtils;
import org.apache.storm.topology.BasicOutputCollector;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseBasicBolt;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;



/**
 * @ClassName DailyRechargeDataJoinBolt
 * @description 
 *
 */
public class DailyRechargeDataJoinBolt extends BaseBasicBolt {

    @Override
    public void execute(Tuple input, BasicOutputCollector collector) {
        String value = input.getString(0);//获取前面的bolt传递的值。
        // 发射消息至其他bolt
        collector.emit(FieldsCommon.PREV_AND_NEXT_CHECK_CROSS_FILE, new Values("CC", ccFile.getAbsolutePath(), ccList));
        collector.emit(FieldsCommon.PREV_AND_NEXT_CHECK_CROSS_FILE, new Values("CZ", czFile.getAbsolutePath(), czList));

    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declareStream(FieldsCommon.PREV_AND_NEXT_CHECK_CROSS_FILE, new Fields(FieldsCommon.ZIP_TYPE, FieldsCommon.FILE_ABS_PATH, FieldsCommon.FILE_LIST));
    }
}

总结即
首先构建topology，可以构建复杂的路由网络。

TopologyBuilder builder = new TopologyBuilder();
builder.setSpout("spout", new SentenceSpout(), 1);

builder.setBolt("split", new SplitBolt(), 2)
.shuffleGrouping("spout ");//通过组件编号路由。

builder.setBolt("count1", new Count1Bolt(), 2)
.shuffleGrouping("split","split-stream");//通过组件编号和stream_id路由。

builder.setBolt("count2", new Count2Bolt(), 2)
.shuffleGrouping("split","split-stream");//通过组件编号和stream_id路由。
.shuffleGrouping("spout","spout1-stream");//通过组件编号和stream_id路由。

builder.setBolt("print", new PrintBolt(), 2)
.shuffleGrouping("count2","count2-stream");//通过组件编号和stream_id路由。
.shuffleGrouping("spout","spout2-stream");//通过组件编号和stream_id路由。

然后定义spout，spout一般继承BaseRichSpout，重写open， nextTuple 和 declareOutputFields 方法。在declareOutputFields方法里定义此spout 的可能发送的节点。然后在nextTuple发射出去。


    collector.emit("spout2-stream", new Values("nihao"));

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declareStream("spout2-stream", new Fields("test") );
        declarer.declareStream("spout1-stream");
    }

bolt 和spout差不多，bolt继承BaseBasicBolt ，重写execute 和 declareOutputFields 方法。
execute方法接收spout或者bolt发送过来的参数实现拓扑流转。

@Override
public void execute(Tuple input, BasicOutputCollector collector) {

}

参考资料

http://blog.csdn.net/kingzone_2008/article/details/52791515

xianggugou
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STORM 拓扑构建
yangyangmyself的专栏
08-28 3368
在Storm拓扑构建前我们先复习一下Storm概念及组件： 1. Nimbus：负责资源分配和任务调度。 2. Supervisor：负责接受nimbus分配的任务，启动和停止属于自己管理的worker进程。 3. Worker：运行具体处理组件逻辑的进程。 4. Task：worker中每一个spout/bolt的线程称为一个task. 在storm0.8之后，task不再与物理线程对应，同一个 spout/bolt的task可能会共享一个物理线程，该线程称为xecutor。 5. Topology
storm使用(一)–入门及安装
panda-star的博客
08-28 833
storm使用(一)–入门及安装 文章目录一、简介二、strom组成2.1 节点组成2.1.1 master节点2.1.2 worker结点2.2 组件组成2.2.1 tuple2.2.2 stream2.2.3 spout2.2.4 bolt2.3 应用组成2.3.1 topology2.3.2 stream grouping2.3.4 worker2.3.5 task2.3.6 executo...
Storm拓扑有几种提交方式
m0_58536533的博客
11-22 560
首先，Storm有两种运行模式：本地模式和远程模式。在本地模式下，您可以在本地机器上完全在进程中开发和测试拓扑。在远程模式下，您提交拓扑（topology）以在机器集群上执行。
storm的应用场景及入门思路
weixin_41969791的博客
04-09 2144
storm是twitter公司捐献给apache的一个实时处理框架，对于消息，storm来一条处理一条，不会造成信息的堆积。而hadoop为批处理，堆积一定数据一起处理。对于对实时性要求很高的应用场景就一定要用storm。 storm的使用方式为： 1、安装zookeeper(上传，解压，改配置文件，增加myid，分发) 2、安装storm(上传，解压，改配置文件，分发) 3、启动stor
Storm的初识和安装以及使用
weixin_43909426的博客
01-26 429
1.产生的背景 对于大量的海量数据的批处理，传统上使用的hadoop、hive等，优点是吞吐量大、自动容错的特点，但是同时缺点也十分的明显，只适合一些离线的数据处理，对于一些实时数据处理并不擅长，由此产生的Storm、SparkStreaming、Fink等实时的计算系统。 2.简介 Apache Storm 是一个Twitter的开源分布式、实时、可扩展、容错的操作系统。Strom处理数据...
Storm事务性拓扑详解教程.docx
最新发布
11-05
使用Storm编程，可以通过调用ack和fail方法来确保一条消息的处理成功或失败。不过当元组被重发时，会发生什么呢？你又该如何砍不会重复计算？ Storm0.7.0实现了一个新特性——事务性拓扑，这一特性使消息在语义上...
storm读书笔记---storm运行流程
01-27
本文来自于csdn，本文简要通过storm和Hadoop各角色对比，介绍了storm的运行流程，希望对您的学习有帮助。一、storm是一个用于实时流式计算的分布式计算引擎，弥补了Hadoop在实时计算方面的不足（Hadoop在本质上是一...
使用Storm实现实时大数据分析！
02-26
简单和明了，Storm让大数据分析变得轻松加愉快。当今世界，公司的日常运营经常会生成TB级别的数据。数据来源囊括了互联网装置可以捕获的任何类型数据，网站、社交媒体、交易型商业数据以及其它商业环境中创建的数据...
storm和Redis.zip
07-07
storm和Redis安装包，apache-storm-0.9.2-incubating.tar和redis-3.0.0.tar
Storm环境下基于拓扑结构的任务调度策略
03-06
Storm环境下基于拓扑结构的任务调度策略
Storm拓扑
KOJ的博客
08-10 1386
一 什么是拓扑 Storm中的拓扑，实际上就是一个有向图的计算。拓扑中节点包含数据的逻辑处理；节点之间的边显示数据如何在节点直接流动。 二 Java中如何建立拓扑 1 首先创建一个TopologyBuilder对象。 2 使用setSpout方法和setBolt方法，建立拓扑中的节点以及节点之间的联系。（方法的参数列表：第一个参数表示组件的id；第二个参数是Spout或者Bolt对
storm学习笔记-事务拓扑
dark
09-26 358
《Storm实战构建大数据实时计算》 《从零开始学Storm》 学习笔记 一致性事务 storm是一个分布式流处理系统，利用anchor和ack机制保证了所有tuple都被成功处理。如果出错了，则可以被重传，但是如何保证出错的tuple只被处理一次呢？Storm提供了一套事务性组件Transactional Topology,来解决这个问题。 ...
storm初级教程 005 storm核心之拓扑
小麒麟的博客
10-12 139
拓扑是指在storm运行的计算[storm jar app.jar com.XXX.main] 则main函数包含了一个拓扑的定义，拓扑指定了一个计算的配置，spout,bolt以及每个组件之间的stream grouping[也就是订阅者如何订阅被订阅者的规则:流分组] 拓扑由上述拓扑构建者构建，number为并行度/执行器数量，不指定默认为1; 流分组有8...
Storm入门之第三章拓扑
Jacob
06-07 704
本文翻译自《Getting Started With Storm》  译者：吴京润   编辑：方腾飞 在这一章，你将学到如何在同一个Storm拓扑结构内的不同组件之间传递元组，以及如何向一个运行中的Storm集群发布一个拓扑。 数据流组 设计一个拓扑时，你要做的最重要的事情之一就是定义如何在各组件之间交换数据（数据流是如何被bolts消费的）。一个数据流组指定了每个bolt会消费
Apache Storm工作流程
ItStar
12-06 2529
一个工作的Storm集群应该有一个Nimbus和一个或多个supervisors。另一个重要的节点是Apache ZooKeeper，它将用于nimbus和supervisors之间的协调。现在让我们仔细看看Apache Storm的工作流程 −最初，nimbus将等待“Storm拓扑”提交给它。一旦提交拓扑，它将处理拓扑并收集要执行的所有任务和任务将被执行的顺序。然后，nimbus将任务均匀分配
storm的概念及架构详解
qq_39162838的博客
07-19 1万+
Storm概要 首先回顾map reduce框架 主节点jobtracker，从节点 taskTracker。 用户提交任务给jobtracker，jobtracker分配给taskTracker，我们管这些任务叫job 运行的作业分为两种 map 和 reduce。 Storm是一个实时计算框架 主节点 nimbus  从节点 supervisor 用户提交作业给nimbus， n...
Storm 流程分析
zzShine的专栏
01-17 633
流程说明 client提交topology到nimbus nimbus针对该topology建立本地的目录，nimbus中的调度器根据topology的配置计算task，并把task分配到不同的worker上，调度的结果写入zk。 在zk上创建assignments节点，存储task和supervisor中work的对应关系。 在zk上创建workerbeats节点来监控worker的心跳。 su
Storm（流计算）技术原理
热门推荐
曹世宏的博客
06-02 3万+
流计算概述 什么是流数据： 数据有静态数据和流数据。 静态数据： 很多企业为了支持决策分析而构建的数据仓库系统，其中存放的大量历史数据就是静态数据。技术人员可以利用数据挖掘和OLAP（On-Line Analytical Processing）分析工具从静态数据中找到对企业有价值的信息。 图：静态数据的一般处理流程 流数据： 近年来，在Web应用、网络监控、传感监测等领域，兴...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值