Storm 入门的Demo教程

Storm超实用教程详解-附示例 Storm 中最重要的抽象,应该就是 Stream grouping 了,它能够控制 Spot/Bolt 对应的 Task 以什么样的方式来分发 Tuple,将 Tuple 发射到目的 Spot/Bolt 对应的 Task.定义拓扑的时候,一部分工作是指定每个Bolt应该消费哪些流。是一个轻量级的数据格式,支持基本的类型,如果想实现自定义的类型,需要实现自己的序列化方式。把数据的计算处理过程合理的拆分到多个Bolt、合理设置Bolt的task数量,能够提高Bolt的处理能力,提升流水线的并发度。 阅读详情

转载地址:https://www.cnblogs.com/xuwujing/p/8584684.html

Storm介绍

Storm是Twitter开源的分布式实时大数据处理框架,最早开源于github,从0.9.1版本之后,归于Apache社区,被业界称为实时版Hadoop。随着越来越多的场景对Hadoop的MapReduce高延迟无法容忍,比如网站统计、推荐系统、预警系统、金融系统(高频交易、股票)等等,大数据实时处理解决方案(流计算)的应用日趋广泛,目前已是分布式技术领域最新爆发点,而Storm更是流计算技术中的佼佼者和主流。

Storm的核心组件

  • Nimbus:即Storm的Master,负责资源分配和任务调度。一个Storm集群只有一个Nimbus。
  • Supervisor:即Storm的Slave,负责接收Nimbus分配的任务,管理所有Worker,一个Supervisor节点中包含多个Worker进程。
  • Worker:工作进程,每个工作进程中都有多个Task。
  • Task:任务,在 Storm 集群中每个 Spout 和 Bolt 都由若干个任务(tasks)来执行。每个任务都与一个执行线程相对应。
  • Topology:计算拓扑,Storm 的拓扑是对实时计算应用逻辑的封装,它的作用与 MapReduce 的任务(Job)很相似,区别在于 MapReduce 的一个 Job 在得到结果之后总会结束,而拓扑会一直在集群中运行,直到你手动去终止它。拓扑还可以理解成由一系列通过数据流(Stream Grouping)相互关联的 Spout 和 Bolt 组成的的拓扑结构。
  • Stream:数据流(Streams)是 Storm 中最核心的抽象概念。一个数据流指的是在分布式环境中并行创建、处理的一组元组(tuple)的无界序列。数据流可以由一种能够表述数据流中元组的域(fields)的模式来定义。
  • Spout:数据源(Spout)是拓扑中数据流的来源。一般 Spout 会从一个外部的数据源读取元组然后将他们发送到拓扑中。根据需求的不同,Spout 既可以定义为可靠的数据源,也可以定义为不可靠的数据源。一个可靠的 Spout能够在它发送的元组处理失败时重新发送该元组,以确保所有的元组都能得到正确的处理;相对应的,不可靠的 Spout 就不会在元组发送之后对元组进行任何其他的处理。一个 Spout可以发送多个数据流。
  • Bolt:拓扑中所有的数据处理均是由 Bolt 完成的。通过数据过滤(filtering)、函数处理(functions)、聚合(aggregations)、联结(joins)、数据库交互等功能,Bolt 几乎能够完成任何一种数据处理需求。一个 Bolt 可以实现简单的数据流转换,而更复杂的数据流变换通常需要使用多个 Bolt 并通过多个步骤完成。
  • Stream grouping:为拓扑中的每个 Bolt 的确定输入数据流是定义一个拓扑的重要环节。数据流分组定义了在 Bolt 的不同任务(tasks)中划分数据流的方式。在 Storm 中有八种内置的数据流分组方式。
  • Reliability:可靠性。Storm 可以通过拓扑来确保每个发送的元组都能得到正确处理。通过跟踪由 Spout 发出的每个元组构成的元组树可以确定元组是否已经完成处理。每个拓扑都有一个“消息延时”参数,如果 Storm 在延时时间内没有检测到元组是否处理完成,就会将该元组标记为处理失败,并会在稍后重新发送该元组。

Storm程序再Storm集群中运行的示例图如下:

Topology

为什么把Topology单独提出来呢,因为Topology是我们开发程序主要的用的组件。
Topology和MapReduce很相像。
MapReduce是Map进行获取数据,Reduce进行处理数据。
而Topology则是使用Spout获取数据,Bolt来进行计算。
总的来说就是一个Topology由一个或者多个的Spout和Bolt组成。

具体流程是怎么走,可以通过查看下面这张图来进行了解。
示例图:

注:图片来源http://www.tianshouzhi.com/api/tutorials/storm/52。

图片有三种模式,解释如下:
第一种比较简单,就是由一个Spout获取数据,然后交给一个Bolt进行处理;
第二种稍微复杂点,由一个Spout获取数据,然后交给一个Bolt进行处理一部分,然后在交给下一个Bolt进行处理其他部分。
第三种则比较复杂,一个Spout可以同时发送数据到多个Bolt,而一个Bolt也可以接受多个Spout或多个Bolt,最终形成多个数据流。但是这种数据流必须是有方向的,有起点和终点,不然会造成死循环,数据永远也处理不完。就是Spout发给Bolt1,Bolt1发给Bolt2,Bolt2又发给了Bolt1,最终形成了一个环状。

Storm 集群安装

之前已经写过了,这里就不在说明了。
博客地址:http://www.panchengming.com/2018/01/26/pancm70/

Storm Hello World

前面讲了一些Storm概念,可能在理解上不太清楚,那么这里我们就用一个Hello World代码示例来体验下Storm运作的流程吧。

环境准备

在进行代码开发之前,首先得做好相关的准备。
本项目是使用Maven构建的,使用Storm的版本为1.1.1。
Maven的相关依赖如下:

  <!--storm相关jar  -->
  <dependency>
    <groupId>org.apache.storm</groupId>
    <artifactId>storm-core</artifactId>
    <version>1.1.1</version>
    <scope>provided</scope>
 </dependency> 

具体流程

在写代码的时候,我们先来明确要用Storm做什么。
那么第一个程序,就简单的输出下信息。
具体步骤如下:

  1. 启动topology,设置好Spout和Bolt。
  2. 将Spout获取的数据传递给Bolt。
  3. Bolt接受Spout的数据进行打印。
Spout

那么首先开始编写Spout类。一般是实现 IRichSpout 或继承BaseRichSpout该类,然后实现该方法。
这里我们继承BaseRichSpout这个类,该类需要实现这几个主要的方法:

一、open

open()方法中是在ISpout接口中定义,在Spout组件初始化时被调用。
有三个参数,它们的作用分别是:

  1. Storm配置的Map;
  2. topology中组件的信息;
  3. 发射tuple的方法;

代码示例:

  @Override
    public void open(Map map, TopologyContext arg1, SpoutOutputCollector collector) {
        System.out.println("open:"+map.get("test"));
        this.collector = collector;
    }
二、nextTuple

nextTuple()方法是Spout实现的核心。
也就是主要执行方法,用于输出信息,通过collector.emit方法发射。

这里我们的数据信息已经写死了,所以这里我们就直接将数据进行发送。
这里设置只发送两次。
代码示例:

     @Override
    public void nextTuple() {
        if(count<=2){
            System.out.println("第"+count+"次开始发送数据...");
            this.collector.emit(new Values(message));
        }
        count++;
    }
三、declareOutputFields

declareOutputFields是在IComponent接口中定义,用于声明数据格式。
即输出的一个Tuple中,包含几个字段。

因为这里我们只发射一个,所以就指定一个。如果是多个,则用逗号隔开。
代码示例:

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        System.out.println("定义格式...");
        declarer.declare(new Fields(field));
    }
四、ack

ack是在ISpout接口中定义,用于表示Tuple处理成功。

代码示例:

    @Override
    public void ack(Object obj) {
        System.out.println("ack:"+obj);
    }
五、fail

fail是在ISpout接口中定义,用于表示Tuple处理失败。

代码示例:

    @Override
    public void fail(Object obj) {
        System.out.println("失败:"+obj);
    }
六、close

close是在ISpout接口中定义,用于表示Topology停止。

代码示例:

  @Override
    public void close() {
        System.out.println("关闭...");
    }

至于还有其他的,这里就不在一一列举了。

Bolt

Bolt是用于处理数据的组件,主要是由execute方法来进行实现。一般来说需要实现 IRichBolt 或继承BaseRichBolt该类,然后实现其方法。
需要实现方法如下:

一、prepare

在Bolt启动前执行,提供Bolt启动环境配置的入口。
参数基本和Sqout一样。
一般对于不可序列化的对象进行实例化。
这里的我们就简单的打印下

    @Override
    public void prepare(Map map, TopologyContext arg1, OutputCollector collector) {
        System.out.println("prepare:"+map.get("test"));
        this.collector=collector;
    }

注:如果是可以序列化的对象,那么最好是使用构造函数。

二、execute

execute()方法是Bolt实现的核心。
也就是执行方法,每次Bolt从流接收一个订阅的tuple,都会调用这个方法。
从tuple中获取消息可以使用 tuple.getString()和tuple.getStringByField();这两个方法。个人推荐第二种,可以通过field来指定接收的消息。
注:如果继承的是IRichBolt,则需要手动ack。这里就不用了,BaseRichBolt会自动帮我们应答。
代码示例:

    @Override
    public void execute(Tuple tuple) {
//      String msg=tuple.getString(0);
        String msg=tuple.getStringByField("test");
        //这里我们就不做消息的处理,只打印
        System.out.println("Bolt第"+count+"接受的消息:"+msg); 
        count++;
        /**
         * 
         * 没次调用处理一个输入的tuple,所有的tuple都必须在一定时间内应答。
         * 可以是ack或者fail。否则,spout就会重发tuple。
         */
//      collector.ack(tuple);
    }
三、declareOutputFields

和Spout的一样。
因为到了这里就不再输出了,所以就什么都没写。

    @Override
    public void declareOutputFields(OutputFieldsDeclarer arg0) {        
    }
cleanup

cleanup是IBolt接口中定义,用于释放bolt占用的资源。
Storm在终止一个bolt之前会调用这个方法。
因为这里没有什么资源需要释放,所以就简单的打印一句就行了。

@Override
    public void cleanup() {
        System.out.println("资源释放");
    }
Topology

这里我们就是用main方法进行提交topology。
不过在提交topology之前,需要进行相应的设置。
这里我就不一一细说了,代码的注释已经很详细了。
代码示例:

    import org.apache.storm.Config;
    import org.apache.storm.LocalCluster;
    import org.apache.storm.StormSubmitter;
    import org.apache.storm.topology.TopologyBuilder;
    
    /**
     * 
    * Title: App
    * Description:
    * storm测试 
    * Version:1.0.0  
    * @author pancm
    * @date 2018年3月6日
     */
    public class App {
        
        private static final String str1="test1"; 
        private static final String str2="test2"; 
    
        public static void main(String[] args)  {
            // TODO Auto-generated method stub
            //定义一个拓扑
            TopologyBuilder builder=new TopologyBuilder();
            //设置一个Executeor(线程),默认一个
            builder.setSpout(str1, new TestSpout());
            //设置一个Executeor(线程),和一个task
            builder.setBolt(str2, new TestBolt(),1).setNumTasks(1).shuffleGrouping(str1);
            Config conf = new Config();
            conf.put("test", "test");
            try{
              //运行拓扑
           if(args !=null&&args.length>0){ //有参数时,表示向集群提交作业,并把第一个参数当做topology名称
             System.out.println("远程模式");
                 StormSubmitter.submitTopology(args[0], conf, builder.createTopology());
          } else{//没有参数时,本地提交
        //启动本地模式
         System.out.println("本地模式");
        LocalCluster cluster = new LocalCluster();
        cluster.submitTopology("111" ,conf,  builder.createTopology() );
        Thread.sleep(10000);
    //  关闭本地集群
        cluster.shutdown();
          }
            }catch (Exception e){
                e.printStackTrace();
            }   
        }
    }

运行该方法,输出结果如下:

本地模式
定义格式...
open:test
第1次开始发送数据...
第2次开始发送数据...
prepare:test
Bolt第1接受的消息:这是个测试消息!
Bolt第2接受的消息:这是个测试消息!
资源释放
关闭...
 

到这里,是不是基本上对Storm的运作有些了解了呢。
这个demo达到了上述的三种模式图中的第一种,一个Spout传输数据, 一个Bolt处理数据。

那么如果我们想达到第二种模式呢,那又该如何做呢?
假如我们想统计下在一段文本中的单词出现频率的话,我们只需执行一下步骤就可以了。
1.首先将Spout中的message消息进行更改为数组,并依次将消息发送到TestBolt。
2.然后TestBolt将获取的数据进行分割,将分割的数据发送到TestBolt2。
3.TestBolt2对数据进行统计,在程序关闭的时候进行打印。
4.Topology成功配置并且启动之后,等待20秒左右,关闭程序,然后得到输出的结果。

代码示例如下:

Spout
用于发送消息。

    import java.util.Map;
    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;
    
    /**
     * 
    * Title: TestSpout
    * Description:
    * 发送信息
    * Version:1.0.0  
    * @author pancm
    * @date 2018年3月6日
     */
    public class TestSpout extends BaseRichSpout{
    
        private static final long serialVersionUID = 225243592780939490L;
    
        private SpoutOutputCollector collector;
        private static final String field="word";
        private int count=1;
        private String[] message =  {
    "My nickname is xuwujing",
    "My blog address is http://www.panchengming.com/",
    "My interest is playing games"
    };
        
        /**
     * open()方法中是在ISpout接口中定义,在Spout组件初始化时被调用。
     * 有三个参数:
     * 1.Storm配置的Map;
     * 2.topology中组件的信息;
     * 3.发射tuple的方法;
     */
        @Override
        public void open(Map map, TopologyContext arg1, SpoutOutputCollector collector) {
            System.out.println("open:"+map.get("test"));
            this.collector = collector;
        }
    
    /**
     * nextTuple()方法是Spout实现的核心。
     * 也就是主要执行方法,用于输出信息,通过collector.emit方法发射。
     */
        @Override
        public void nextTuple() {
                
            if(count<=message.length){
                System.out.println("第"+count +"次开始发送数据...");
                this.collector.emit(new Values(message[count-1]));
            }
            count++;
        }
    
    
        /**
     * declareOutputFields是在IComponent接口中定义,用于声明数据格式。
     * 即输出的一个Tuple中,包含几个字段。
     */
        @Override
        public void declareOutputFields(OutputFieldsDeclarer declarer) {
            System.out.println("定义格式...");
            declarer.declare(new Fields(field));
        }
    
        /**
         * 当一个Tuple处理成功时,会调用这个方法
         */
        @Override
        public void ack(Object obj) {
            System.out.println("ack:"+obj);
        }
        
        /**
         * 当Topology停止时,会调用这个方法
         */
        @Override
        public void close() {
            System.out.println("关闭...");
        }
        
        /**
         * 当一个Tuple处理失败时,会调用这个方法
         */
        @Override
        public void fail(Object obj) {
            System.out.println("失败:"+obj);
        }
        
    }

TestBolt

用于分割单词。

    import java.util.Map;
    
    import org.apache.storm.task.OutputCollector;
    import org.apache.storm.task.TopologyContext;
    import org.apache.storm.topology.OutputFieldsDeclarer;
    import org.apache.storm.topology.base.BaseRichBolt;
    import org.apache.storm.tuple.Fields;
    import org.apache.storm.tuple.Tuple;
    import org.apache.storm.tuple.Values;
    
    
    /**
     * 
    * Title: TestBolt
    * Description: 
    * 对单词进行分割
    * Version:1.0.0  
    * @author pancm
    * @date 2018年3月16日
     */
    public class TestBolt extends BaseRichBolt{
    
        /**
         * 
         */
        private static final long serialVersionUID = 4743224635827696343L;
        
        private OutputCollector collector;
       
        /**
    * 在Bolt启动前执行,提供Bolt启动环境配置的入口
    * 一般对于不可序列化的对象进行实例化。
    * 注:如果是可以序列化的对象,那么最好是使用构造函数。
    */
        @Override
        public void prepare(Map map, TopologyContext arg1, OutputCollector collector) {
            System.out.println("prepare:"+map.get("test"));
            this.collector=collector;
        }
      
        /**
         * execute()方法是Bolt实现的核心。
         * 也就是执行方法,每次Bolt从流接收一个订阅的tuple,都会调用这个方法。
         */
        @Override
        public void execute(Tuple tuple) {
            String msg=tuple.getStringByField("word");
        System.out.println("开始分割单词:"+msg);
    String[] words = msg.toLowerCase().split(" ");
    for (String word : words) {
    this.collector.emit(new Values(word));//向下一个bolt发射数据
    } 
        
        }
    
        /**
         * 声明数据格式
         */
        @Override
        public void declareOutputFields(OutputFieldsDeclarer declarer) {
            declarer.declare(new Fields("count"));
        }
        
        /**
     * cleanup是IBolt接口中定义,用于释放bolt占用的资源。
     * Storm在终止一个bolt之前会调用这个方法。
         */
        @Override
        public void cleanup() {
            System.out.println("TestBolt的资源释放");
        }
    }
    

Test2Bolt
用于统计单词出现次数。

  
    import java.util.HashMap;
    import java.util.Map;
    
    import org.apache.storm.task.OutputCollector;
    import org.apache.storm.task.TopologyContext;
    import org.apache.storm.topology.OutputFieldsDeclarer;
    import org.apache.storm.topology.base.BaseRichBolt;
    import org.apache.storm.tuple.Tuple;
    
    /**
     * 
    * Title: Test2Bolt
    * Description:
    * 统计单词出现的次数 
    * Version:1.0.0  
    * @author pancm
    * @date 2018年3月16日
     */
    public class Test2Bolt extends BaseRichBolt{
    
        /**
         * 
         */
        private static final long serialVersionUID = 4743224635827696343L;
        
        
        /**
         * 保存单词和对应的计数
         */
        private HashMap<String, Integer> counts = null;
         
        private long count=1;
        /**
    * 在Bolt启动前执行,提供Bolt启动环境配置的入口
    * 一般对于不可序列化的对象进行实例化。
    * 注:如果是可以序列化的对象,那么最好是使用构造函数。
    */
        @Override
        public void prepare(Map map, TopologyContext arg1, OutputCollector collector) {
            System.out.println("prepare:"+map.get("test"));
            this.counts=new HashMap<String, Integer>();
        }
      
        /**
         * execute()方法是Bolt实现的核心。
         * 也就是执行方法,每次Bolt从流接收一个订阅的tuple,都会调用这个方法。
         * 
         */
        @Override
        public void execute(Tuple tuple) {
            String msg=tuple.getStringByField("count");
            System.out.println("第"+count+"次统计单词出现的次数");
            /**
             * 如果不包含该单词,说明在该map是第一次出现
             * 否则进行加1
             */
            if (!counts.containsKey(msg)) {
                counts.put(msg, 1);
            } else {
                counts.put(msg, counts.get(msg)+1);
            }
            count++;
        }
    
        
        /**
     * cleanup是IBolt接口中定义,用于释放bolt占用的资源。
     * Storm在终止一个bolt之前会调用这个方法。
         */
        @Override
        public void cleanup() {
            System.out.println("===========开始显示单词数量============");
            for (Map.Entry<String, Integer> entry : counts.entrySet()) {
                System.out.println(entry.getKey() + ": " + entry.getValue());
            }
            System.out.println("===========结束============");
           System.out.println("Test2Bolt的资源释放");
        }
        
        /**
         * 声明数据格式
         */
        @Override
        public void declareOutputFields(OutputFieldsDeclarer arg0) {
            
        }
    }
    

Topology

主程序入口。

  import org.apache.storm.Config;
    import org.apache.storm.LocalCluster;
    import org.apache.storm.StormSubmitter;
    import org.apache.storm.topology.TopologyBuilder;
    import org.apache.storm.tuple.Fields;
    
    /**
     * 
    * Title: App
    * Description:
    * storm测试 
    * Version:1.0.0  
    * @author pancm
    * @date 2018年3月6日
     */
    public class App {
        
        private static final String test_spout="test_spout"; 
        private static final String test_bolt="test_bolt"; 
        private static final String test2_bolt="test2_bolt"; 
    
        public static void main(String[] args)  {
            //定义一个拓扑
            TopologyBuilder builder=new TopologyBuilder();
            //设置一个Executeor(线程),默认一个
            builder.setSpout(test_spout, new TestSpout(),1);
            //shuffleGrouping:表示是随机分组
            //设置一个Executeor(线程),和一个task
            builder.setBolt(test_bolt, new TestBolt(),1).setNumTasks(1).shuffleGrouping(test_spout);
            //fieldsGrouping:表示是按字段分组
            //设置一个Executeor(线程),和一个task
            builder.setBolt(test2_bolt, new Test2Bolt(),1).setNumTasks(1).fieldsGrouping(test_bolt, new Fields("count"));
            Config conf = new Config();
            conf.put("test", "test");
            try{
              //运行拓扑
           if(args !=null&&args.length>0){ //有参数时,表示向集群提交作业,并把第一个参数当做topology名称
             System.out.println("运行远程模式");
                 StormSubmitter.submitTopology(args[0], conf, builder.createTopology());
          } else{//没有参数时,本地提交
        //启动本地模式
            System.out.println("运行本地模式");
        LocalCluster cluster = new LocalCluster();
        cluster.submitTopology("Word-counts" ,conf,  builder.createTopology() );
        Thread.sleep(20000);
    //  //关闭本地集群
        cluster.shutdown();
          }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

输出结果:

运行本地模式
定义格式...
open:test
第1次开始发送数据...
第2次开始发送数据...
第3次开始发送数据...
prepare:test
prepare:test
开始分割单词:My nickname is xuwujing
开始分割单词:My blog address is http://www.panchengming.com/
开始分割单词:My interest is playing games
第1次统计单词出现的次数
第2次统计单词出现的次数
第3次统计单词出现的次数
第4次统计单词出现的次数
第5次统计单词出现的次数
第6次统计单词出现的次数
第7次统计单词出现的次数
第8次统计单词出现的次数
第9次统计单词出现的次数
第10次统计单词出现的次数
第11次统计单词出现的次数
第12次统计单词出现的次数
第13次统计单词出现的次数
第14次统计单词出现的次数
===========开始显示单词数量============
address: 1
interest: 1
nickname: 1
games: 1
is: 3
xuwujing: 1
playing: 1
my: 3
blog: 1
http://www.panchengming.com/: 1
===========结束============
Test2Bolt的资源释放
TestBolt的资源释放
关闭...

上述的是本地模式运行,如果想在Storm集群中进行使用,只需要将程序打包为jar,然后将程序上传到storm集群中,
输入:

storm jar xxx.jar xxx xxx
说明:第一个xxx是storm程序打包的包名,第二个xxx是运行主程序的路径,第三个xxx则表示主程序输入的参数,这个可以随意。

如果是使用maven打包的话,则需要在pom.xml加上

<plugin>
          <artifactId>maven-assembly-plugin</artifactId>
          <configuration>
            <descriptorRefs>
              <descriptorRef>jar-with-dependencies</descriptorRef>
            </descriptorRefs>
            <archive>
              <manifest>
                <mainClass>com.pancm.storm.App</mainClass>
              </manifest>
            </archive>
          </configuration>
      </plugin>

成功运行程序之后,可以在Storm集群的UI界面查看该程序的状态。

到此,本文结束,谢谢阅读!

保姆级教程:用Unidbg搞定阿里系App的x-sign和长x-mini-wua签名(附完整Java代码) 本文详细介绍了如何使用Unidbg框架模拟执行阿里系App的原生库,生成关键的x-sign和x-mini-wua签名参数。通过完整的Java代码示例和实战技巧,帮助开发者高效实现签名算法,适用于安全研究、数据分析和第三方应用开发场景。 阅读详情

相关推荐

python采集keep运动数据

我国2009年确立“全民健身日”;2012年,“广泛开展全民健身运动”写入十八大报告;到2014年上升为国家战略,全民健身的分量越来越重。推动全民健身和全民健康深度融合,通过全民健身实现全民健康。 全民健身运动在我国越来越普及,每天清晨和傍晚时分,城市的广场上、公园里,到处是运动健身的人们,跑步、打球、跳舞、游泳、打太极拳等运动项目十分丰富,人们在运动中获得越来越多的幸福感。 随之诞生出了很多运动app,例如keep,咪咕,微信等,大家可以通过app随时记录自己的运动数据,特别是对于很多的减肥人群来说,通过

Z_suger7的博客 5662

Storm 流式计算框架介绍

Storm流式计算框架介绍

weixin_44911248的博客 4708

LangFuse部署与实践

LangFuse的原理主要是基于可观察性和分析技术来监控和优化低延迟消息(LLM)应用。它提供了一套完整的解决方案,通过收集、处理和分析LLM应用在运行过程中产生的各种数据,来生成实时的、深入的、可操作的见解。通过提供实时的、深入的见解和可视化的跟踪功能,LangFuse使得识别和解决应用性能问题变得更加简单和高效。总的来说,LangFuse的原理是通过综合运用可观察性和分析技术,来提供对LLM应用的全面监控和优化能力。这使得开发者和运维团队能够更加高效地管理和维护他们的应用,从而提升用户体验和业务效益。

pumpkin84514的博客 7950

Storm简单demo

Storm简单demo ​ 上一篇介绍了Storm的基础概念,下面就来实际写个demo。 ​ 因为是开发,所以基础的配置还是没有做,就是说是在本地跑的,没有集群之类的。 ​ 先整合一个基础的架子,使用的是SpringBoot的框架,但是移除了基础依赖,添加了Storm的依赖。上代码 前还是需要先解释一下一些基础的概念。然后再上代码。 ​ Storm中使用tuple来作为数据元,相当于一个一个水滴,很多水滴汇集成流。每个tuple是一堆值,每个值有一个名字,并且每个值可以是任何类型。tuple中有两个概念,V

qq_38533859的博客 501

西门子S7-1500 PLC模块化编程与生产线自动化实践

PLC(可编程逻辑控制器)作为工业自动化核心设备,其模块化编程技术能显著提升产线控制系统的开发效率。通过SCL高级语言实现算法封装、功能块(FB)复用等工程实践,可构建稳定可靠的分层式控制架构。本文以西门子TIA Portal平台为例,详解S7-1500系列PLC在汽车零部件产线中的标准化应用方案,包含配方管理、设备联动等典型场景的SCL实现,以及Profinet通信、虚拟轴同步等进阶技巧。特别适用于需要快速实施中大型生产线自动化改造的工程师,提供经过验证的异常处理机制和模块化设计规范。

weixin_34341229的博客 460

多模态对齐方案

本文中我们介绍了 13 中常见的大型多模态模型(Large Multimodal Models, LMM),包括 BLIP-2,LLaVA、MiniGPT、Qwen-VL 以及 Ferret 等。最全 LMM 模型结构(13种)综述。单层linear投影、两层mlp。

liguandong 2089

大数据与云计算:Storm部署配置及运行WordCountTopology (保姆级教程!)

当今世界正处于云计算和大数据的快速发展阶段,而Storm作为一种高效、可靠的实时计算框架,受到了广泛的关注和应用。在这篇文章中,我们将从头开始,将提供一份保姆级教程,帮助进行相关配置和运行WordCountTopology。向您展示如何配置Storm环境。我们将详细介绍所需的软件和工具,并提供逐步指导,帮助您完成安装和配置过程。本人也在不断努力进步,希望自己的博文能够希望对各位有所帮助。

专注 AI、大数据、Python、爬虫、数据分析可视化、机器学习、推荐算法、知识图谱、大模型应用与全栈系统开发,长期沉淀真实项目案例、源码解析、系统设计、部署经验与工程化实践,分享可运行、可复用、可落地的技术方案。 2473

深度强化学习 | 基于DQN实现Flappy Bird游戏与分析

在Flappy Bird中,玩家需要通过控制小鸟安全穿过随机长度的水管来得分。本文基于深度Q网络DQN来实现Flappy Bird游戏的自主探索与学习

FRIGIDWINTER的博客 5915

【Storm】入门的Demo教程

Storm介绍 Storm是Twitter开源的分布式实时大数据处理框架,最早开源于github,从0.9.1版本之后,归于Apache社区,被业界称为实时版Hadoop。随着越来越多的场景对Hadoop的MapReduce高延迟无法容忍,比如网站统计、推荐系统、预警系统、金融系统(高频交易、股票)等等,大数据实时处理解决方案(流计算)的应用日趋广泛,目前已是分布式技术领域最新爆发点,而Stor...

qq_43227967的博客 345

【思博伦】史上最详细Spirent TestCenter测试仪使用教程精讲(一)!图解超赞超详细!!!

3. 在弹出的界面中,找到菜单栏中的“Connect/Create”,选择下拉框中的“Connect to Physical/Visual Chassis”,在弹出的对话框中输入思博伦测试仪的IP地址:192.168.6.244,点击“OK”;说明:目前我们只需要使用到Raw Stream Block,不需要用到Bound Stream Block。说明:如果要使用100G模式,由于硬件限制,必须连续3个面板端口同时配置为100G使用。打开安装包,并按照提示按照即可。

风云说通信 6483

LVGL core group焦点分组管理(lv_group.c)

lv_group_t是用于焦点管理的,将需要获取焦点的对像加入到同一个分组内,再将其通过挂到指定的事件驱动中,就可以控制焦点了。而被加入的对象又可以通过焦点状态事件和事件来控制对象的焦点逻辑了。创建好的分组通过接口挂事件驱动中,这样就可以指定一个自定义的焦点分组了。;) {if(!} }友情提示:无论是接口还是都是单例的,即被设置后前一个被设置的值就失效了;此方案可以保证焦点的唯一 性,但也一定要记住要在适合的位置设置回来,以防丢失焦点。

Bigan(安)的博客 3910

Storm Spring Boot Demo 项目教程

Storm Spring Boot Demo 项目教程 1. 项目目录结构及介绍 storm_spring_boot_demo/ ├── src/ │ ├── main/ │ │ ├── java/ │ │ │ ├── com/ │ │ │ │ ├── example/ │ │ │ │ │ ├── config/ │ │ │ ...

gitblog_00790的博客 870

【新能源汽车DCDC变换器测试优化全攻略:解决电能质量/发热/过充等核心痛点】

高压直流转12V低压的DCDC变换器是新能源汽车电源系统的核心枢纽,承担着为整车低压附件、控制器及12V蓄电池供电/补电的关键作用。在新能源汽车乘用车、商用车等不同车型实际运营中,因PDU内DC/AC等模块干扰、DCDC自身设计缺陷、整车匹配性不佳及测试验证不充分,频发12V输出电能质量差导致后端元器件烧毁、变换器发热严重、蓄电池过充/欠充、智能补电功能失效等问题,还伴随低压侧电压瞬跌/浪涌、电磁干扰超标、振动后接触不良、高温下效率骤降等行业高频故障,直接影响整车可靠性和运营安全性。本文基于国标。

优快云-新能源汽车研发测试专业博主 1271

storm入门demo

一.storm入门demo的介绍 storm的入门helloworld有2种方式,一种是本地的,另一种是远程。   本地实现:     本地写好demo之后,不用搭建storm集群,下载storm的相关jar包即可实现storm的相关操作   远程实现:     本地写好demo之后,需要将其打成jar包,然后通过nimbus将jar包运行即可     本地打包...

weixin_30808253的博客 144

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

原生Canvas视频截图原理与实战:从黑屏到高清PNG

Canvas截图是前端实现网页内视频/图片帧捕获的核心技术,其本质是通过drawImage接口直接读取GPU解码后的原始像素数据,绕过DOM渲染路径。该能力依赖浏览器内核级支持,具备零依赖、低延迟、高保真等技术价值,广泛应用于在线教育关键帧标记、远程医疗影像存档、工业视觉实时标注等场景。但实际落地需深入理解readyState状态校验、devicePixelRatio适配、跨域CORS策略及toBlob异步可靠性等关键原理。本文聚焦原生Canvas截图,详解视频帧采集、像素空间转换与落盘导出三阶段机制,并提

weixin_33796205的博客 392

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

storm入门demo测试

组织架构 ** 主程序 ** package com.wenglei.storm.demo; import org.apache.storm.Config; import org.apache.storm.LocalCluster; import org.apache.storm.topology.TopologyBuilder; public class TopologMain { public static void main(String[] args) { //1.

weixin_44393345的博客 401

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Apache Storm理解与入门Demo

Apache torm入门

万物皆字节 934

Storm快速入门与大数据架构之Storm集群的搭建部署教程

Storm快速入门与大数据架构之Storm集群的搭建部署教程 Storm是一个流式计算框架,数据源源不断的产生,源源不断的收集,源源不断的计算。(数据实时产生、实时传输、实时计算、实时展示)。 Storm只负责数据的计算,不负责数据的存储。 2013年前后,阿里巴巴基于storm框架,使用java语言开发了类似的流式计算框架佳作,Jstorm。2016年年底阿里巴巴将源码贡献给了Apache st...

fengliaoai的博客 1万+

一个demo快速入门Storm

Storm是什么? 简单地说:storm是一个分布式实时大数据处理系统,主要用于做实时流式计算。 记录一个应用场景架构:数据被采集到后,由datahub/kafka做数据缓冲,通过storm实时抽取计算,计算结果由redis进行消费,最终存到rds中。 Storm框架主要由7部分组成:Topology、Spout、Bolt、Stream、Stream grouping、Task、Worker To...

我的兔子丢了的博客 383

STORM 项目教程

STORM 项目教程 【免费下载链接】storm An LLM-powered knowledge curation system that researches a topic and generates a full-length report with citations. ...

gitblog_00017的博客 464

java storm demo_1 storm基本概念 + storm编程规范及demo编写

本博文的主要内容有.Storm的单机模式安装.Storm的分布式安装(3节点).No space left on device.storm工程的eclipse的java编写分布式的一个计算系统,但是跟mr不一样,就是实时的,实时的跟Mr离线批处理不一样。离线mr主要是做数据挖掘、数据分析、数据统计和br分析。Storm,主要是在线的业务系统。数据像水一样,源源不断的来,然后,在流动的过程中啊,就要...

weixin_30563489的博客 1037
上一篇: storm入门--storm的第一个示例
下一篇: KafkaProducer-kafka生产者Java客户端
learn_tech
博客等级 码龄10年 68粉丝 10原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值