Storm让大数据分析变得轻松加愉快。

最新推荐文章于 2023-10-25 11:17:11 发布
最新推荐文章于 2023-10-25 11:17:11 发布
阅读量597 收藏
点赞数
分类专栏： hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/miketom155/article/details/50343023
版权

简单和明了，Storm让大数据分析变得轻松加愉快。

当今世界，公司的日常运营经常会生成TB级别的数据。数据来源囊括了互联网装置可以捕获的任何类型数据，网站、社交媒体、交易型商业数据以及其它商业环境中创建的数据。考虑到数据的生成量，实时处理成为了许多机构需要面对的首要挑战。我们经常用的一个非常有效的开源实时计算工具就是Storm —— Twitter开发，通常被比作“实时的Hadoop”。然而Storm远比Hadoop来的简单，因为用它处理大数据不会带来新老技术的交替。

Shruthi Kumar、Siddharth Patankar共同效力于Infosys，分别从事技术分析和研发工作。本文详述了Storm的使用方法，例子中的项目名称为“超速报警系统（Speeding Alert System）”。我们想实现的功能是：实时分析过往车辆的数据，一旦车辆数据超过预设的临界值 —— 便触发一个trigger并把相关的数据存入数据库。

Storm

对比Hadoop的批处理，Storm是个实时的、分布式以及具备高容错的计算系统。同Hadoop一样Storm也可以处理大批量的数据，然而Storm在保证高可靠性的前提下还可以让处理进行的更加实时；也就是说，所有的信息都会被处理。Storm同样还具备容错和分布计算这些特性，这就让Storm可以扩展到不同的机器上进行大批量的数据处理。他同样还有以下的这些特性：

  • 易于扩展。对于扩展，你只需要添加机器和改变对应的topology（拓扑）设置。Storm使用Hadoop Zookeeper进行集群协调，这样可以充分的保证大型集群的良好运行。
  • 每条信息的处理都可以得到保证。
  • Storm集群管理简易。
  • Storm的容错机能：一旦topology(拓补)递交，Storm会一直运行它直到topology被废除或者被关闭。而在执行中出现错误时，也会由Storm重新分配任务。
  • 尽管通常使用Java，Storm中的topology可以用任何语言设计。

当然为了更好的理解文章，你首先需要安装和设置Storm。需要通过以下几个简单的步骤：

  • 从Storm官方下载Storm安装文件
  • 将bin/directory解压到你的PATH上，并保证bin/storm脚本是可执行的。

Storm组件

Storm集群主要由一个主节点和一群工作节点（worker node）组成，通过 Zookeeper进行协调。

主节点：

主节点通常运行一个后台程序 —— Nimbus，用于响应分布在集群中的节点，分配任务和监测故障。这个很类似于Hadoop中的Job Tracker。

工作节点：

工作节点同样会运行一个后台程序 —— Supervisor，用于收听工作指派并基于要求运行工作进程。每个工作节点都是topology中一个子集的实现。而Nimbus和Supervisor之间的协调则通过Zookeeper系统或者集群。

Zookeeper

Zookeeper是完成Supervisor和Nimbus之间协调的服务。而应用程序实现实时的逻辑则被封装进Storm中的“topology”。topology则是一组由Spouts（数据源【喷嘴】）和Bolts（数据操作【螺栓】）通过Stream Groupings进行连接的图。下面对出现的术语进行更深刻的解析。

Spout：

简而言之，Spout从来源处读取数据并放入topology。Spout分成可靠和不可靠两种；当Storm接收失败时，可靠的Spout会对tuple（元组，数据项组成的列表）进行重发；而不可靠的Spout不会考虑接收成功与否只发射一次。而Spout中最主要的方法就是nextTuple（），该方法会发射一个新的tuple到topology，如果没有新tuple发射则会简单的返回。

Bolt：

Topology中所有的处理都由Bolt完成。Bolt可以完成任何事，比如：连接的过滤、聚合、访问文件/数据库、等等。Bolt从Spout中接收数据并进行处理，如果遇到复杂流的处理也可能将tuple发送给另一个Bolt进行处理。而Bolt中最重要的方法是execute（），以新的tuple作为参数接收。不管是Spout还是Bolt，如果将tuple发射成多个流，这些流都可以通过declareStream（）来声明。

Stream Groupings：

Stream Grouping定义了一个流在Bolt任务间该如何被切分。这里有Storm提供的6个Stream Grouping类型：

1. 随机分组（Shuffle grouping）：随机分发tuple到Bolt的任务，保证每个任务获得相等数量的tuple。

2. 字段分组（Fields grouping）：根据指定字段分割数据流，并分组。例如，根据“user-id”字段，相同“user-id”的元组总是分发到同一个任务，不同“user-id”的元组可能分发到不同的任务。

3. 全部分组（All grouping）：tuple被复制到bolt的所有任务。这种类型需要谨慎使用。

4. 全局分组（Global grouping）：全部流都分配到bolt的同一个任务。明确地说，是分配给ID最小的那个task。

5. 无分组（None grouping）：你不需要关心流是如何分组。目前，无分组等效于随机分组。但最终，Storm将把无分组的Bolts放到Bolts或Spouts订阅它们的同一线程去执行（如果可能）。

6. 直接分组（Direct grouping）：这是一个特别的分组类型。元组生产者决定tuple由哪个元组处理者任务接收。

当然还可以实现CustomStreamGroupimg接口来定制自己需要的分组。

项目实施

当下情况我们需要给Spout和Bolt设计一种能够处理大量数据（日志文件）的topology，当一个特定数据值超过预设的临界值时促发警报。使用Storm的topology，逐行读入日志文件并且监视输入数据。在Storm组件方面，Spout负责读入输入数据。它不仅从现有的文件中读入数据，同时还监视着新文件。文件一旦被修改Spout会读入新的版本并且覆盖之前的tuple（可以被Bolt读入的格式），将tuple发射给Bolt进行临界分析，这样就可以发现所有可能超临界的记录。

下一节将对用例进行详细介绍。

临界分析

这一节，将主要聚焦于临界值的两种分析类型：瞬间临界（instant thershold）和时间序列临界（time series threshold）。

  • 瞬间临界值监测：一个字段的值在那个瞬间超过了预设的临界值，如果条件符合的话则触发一个trigger。举个例子当车辆超越80公里每小时，则触发trigger。
  • 时间序列临界监测：字段的值在一个给定的时间段内超过了预设的临界值，如果条件符合则触发一个触发器。比如：在5分钟类，时速超过80KM两次及以上的车辆。

Listing One显示了我们将使用的一个类型日志，其中包含的车辆数据信息有：车牌号、车辆行驶的速度以及数据获取的位置。

AB 123 60 North city
BC 123 70 South city
CD 234 40 South city
DE 123 40 East  city
EF 123 90 South city
GH 123 50 West  city

这里将创建一个对应的XML文件，这将包含引入数据的模式。这个XML将用于日志文件的解析。XML的设计模式和对应的说明请见下表。

XML文件和日志文件都存放在Spout可以随时监测的目录下，用以关注文件的实时更新。而这个用例中的topology请见下图。

Figure 1：Storm中建立的topology，用以实现数据实时处理

如图所示：FilelistenerSpout接收输入日志并进行逐行的读入，接着将数据发射给ThresoldCalculatorBolt进行更深一步的临界值处理。一旦处理完成，被计算行的数据将发送给DBWriterBolt，然后由DBWriterBolt存入给数据库。下面将对这个过程的实现进行详细的解析。

Spout的实现

Spout以日志文件和XML描述文件作为接收对象。XML文件包含了与日志一致的设计模式。不妨设想一下一个示例日志文件，包含了车辆的车牌号、行驶速度、以及数据的捕获位置。（看下图）

Figure2：数据从日志文件到Spout的流程图

Listing Two显示了tuple对应的XML，其中指定了字段、将日志文件切割成字段的定界符以及字段的类型。XML文件以及数据都被保存到Spout指定的路径。

Listing Two：用以描述日志文件的XML文件。

 
 
  1. <TUPLEINFO> 
  2. <FIELDLIST> 
  3. <FIELD> 
  4. <COLUMNNAME>vehicle_number</COLUMNNAME> 
  5. <COLUMNTYPE>string</COLUMNTYPE> 
  6. </FIELD> 
  7.  
  8. <FIELD>
  9. <COLUMNNAME>speed</COLUMNNAME> 
  10. <COLUMNTYPE>int</COLUMNTYPE> 
  11. </FIELD> 
  12.  
  13. <FIELD> 
  14. <COLUMNNAME>location</COLUMNNAME> 
  15. <COLUMNTYPE>string</COLUMNTYPE> 
  16. </FIELD> 
  17. </FIELDLIST> 
  18. <DELIMITER>,</DELIMITER> 
  19. </TUPLEINFO>   

通过构造函数及它的参数Directory、PathSpout和TupleInfo对象创建Spout对象。TupleInfo储存了日志文件的字段、定界符、字段的类型这些很必要的信息。这个对象通过XSTream序列化XML时建立。

Spout的实现步骤：

  • 对文件的改变进行分开的监听，并监视目录下有无新日志文件添加。
  • 在数据得到了字段的说明后，将其转换成tuple。
  • 声明Spout和Bolt之间的分组，并决定tuple发送给Bolt的途径。

Spout的具体编码在Listing Three中显示。

Listing Three：Spout中open、nextTuple和delcareOutputFields方法的逻辑。

 
 
  1. public void open( Map conf, TopologyContext context,SpoutOutputCollector collector )   
  2. {   
  3.            _collector = collector;   
  4.          try   
  5.          {   
  6.          fileReader  =  new BufferedReader(new FileReader(new File(file)));  
  7.          }  
  8.          catch (FileNotFoundException e)  
  9.          {  
  10.          System.exit(1);   
  11.          }  
  12. }                                                          
  13.  
  14. public void nextTuple()  
  15. {  
  16.          protected void ListenFile(File file)  
  17.          {  
  18.          Utils.sleep(2000);  
  19.          RandomAccessFile access = null;  
  20.          String line = null;   
  21.             try   
  22.             {  
  23.                 while ((line = access.readLine()) != null)  
  24.                 {  
  25.                     if (line !=null)  
  26.                     {   
  27.                          String[] fields=null;  
  28.                           if (tupleInfo.getDelimiter().equals("|"))  fields = line.split("\\"+tupleInfo.getDelimiter());   
  29.                           else   
  30.                           fields = line.split  (tupleInfo.getDelimiter());   
  31.                           if (tupleInfo.getFieldList().size() == fields.length)  _collector.emit(new Values(fields));  
  32.                     }  
  33.                }  
  34.             }  
  35.             catch (IOException ex){ }  
  36.             }  
  37. }  
  38.  
  39. public void declareOutputFields(OutputFieldsDeclarer declarer)  
  40. {  
  41.       String[] fieldsArr = new String [tupleInfo.getFieldList().size()];  
  42.       for(int i=0; i<tupleInfo.getFieldList().size(); i++)  
  43.       {  
  44.               fieldsArr[i] = tupleInfo.getFieldList().get(i).getColumnName();  
  45.       }  
  46. declarer.declare(new Fields(fieldsArr));  
  47. }      

declareOutputFileds（）决定了tuple发射的格式，这样的话Bolt就可以用类似的方法将tuple译码。Spout持续对日志文件的数据的变更进行监听，一旦有添加Spout就会进行读入并且发送给Bolt进行处理。

Bolt的实现

Spout的输出结果将给予Bolt进行更深一步的处理。经过对用例的思考，我们的topology中需要如Figure 3中的两个Bolt。

Figure 3：Spout到Bolt的数据流程。

ThresholdCalculatorBolt

Spout将tuple发出，由ThresholdCalculatorBolt接收并进行临界值处理。在这里，它将接收好几项输入进行检查；分别是：

临界值检查

  • 临界值栏数检查（拆分成字段的数目）
  • 临界值数据类型（拆分后字段的类型）
  • 临界值出现的频数
  • 临界值时间段检查

Listing Four中的类，定义用来保存这些值。

Listing Four:ThresholdInfo类

 
 
  1. public class ThresholdInfo implementsSerializable  
  2.  
  3. {    
  4.         private String action;   
  5.         private String rule;   
  6.         private Object thresholdValue;  
  7.         private int thresholdColNumber;   
  8.         private Integer timeWindow;   
  9.         private int frequencyOfOccurence;   
  10. }   

基于字段中提供的值，临界值检查将被Listing Five中的execute（）方法执行。代码大部分的功能是解析和接收值的检测。

Listing Five：临界值检测代码段

 
 
  1. public void execute(Tuple tuple, BasicOutputCollector collector)   
  2. {  
  3.     if(tuple!=null)   
  4.     {  
  5.         List<Object> inputTupleList = (List<Object>) tuple.getValues();  
  6.         int thresholdColNum = thresholdInfo.getThresholdColNumber();   
  7.         Object thresholdValue = thresholdInfo.getThresholdValue();   
  8.         String thresholdDataType = tupleInfo.getFieldList().get(thresholdColNum-1).getColumnType();   
  9.         Integer timeWindow = thresholdInfo.getTimeWindow();  
  10.          int frequency = thresholdInfo.getFrequencyOfOccurence();  
  11.          if(thresholdDataType.equalsIgnoreCase("string"))  
  12.          {  
  13.              String valueToCheck = inputTupleList.get(thresholdColNum-1).toString();  
  14.              String frequencyChkOp = thresholdInfo.getAction();  
  15.              if(timeWindow!=null)  
  16.              {  
  17.                  long curTime = System.currentTimeMillis();  
  18.                  long diffInMinutes = (curTime-startTime)/(1000);  
  19.                  if(diffInMinutes>=timeWindow)  
  20.                  {  
  21.                      if(frequencyChkOp.equals("=="))  
  22.                      {  
  23.                           if(valueToCheck.equalsIgnoreCase(thresholdValue.toString()))  
  24.                           {  
  25.                               count.incrementAndGet();  
  26.                               if(count.get() > frequency)  
  27.                                   splitAndEmit(inputTupleList,collector);  
  28.                           }  
  29.                      }  
  30.                      else if(frequencyChkOp.equals("!="))  
  31.                      {  
  32.                          if(!valueToCheck.equalsIgnoreCase(thresholdValue.toString()))  
  33.                          {  
  34.                               count.incrementAndGet();  
  35.                               if(count.get() > frequency)  
  36.                                   splitAndEmit(inputTupleList,collector);  
  37.                           }  
  38.                       }  
  39.                       else                         System.out.println("Operator not supported");   
  40.                   }  
  41.               }  
  42.               else 
  43.               {  
  44.                   if(frequencyChkOp.equals("=="))  
  45.                   {  
  46.                       if(valueToCheck.equalsIgnoreCase(thresholdValue.toString()))  
  47.                       {  
  48.                           count.incrementAndGet();  
  49.                           if(count.get() > frequency)  
  50.                               splitAndEmit(inputTupleList,collector);  
  51.                           }  
  52.                   }  
  53.                   else if(frequencyChkOp.equals("!="))  
  54.                   {  
  55.                        if(!valueToCheck.equalsIgnoreCase(thresholdValue.toString()))  
  56.                        {  
  57.                            count.incrementAndGet();  
  58.                            if(count.get() > frequency)  
  59.                                splitAndEmit(inputTupleList,collector);  
  60.                           }  
  61.                    }  
  62.                }  
  63.             }  
  64.             else if(thresholdDataType.equalsIgnoreCase("int") ||                     thresholdDataType.equalsIgnoreCase("double") ||                     thresholdDataType.equalsIgnoreCase("float") ||                     thresholdDataType.equalsIgnoreCase("long") ||                     thresholdDataType.equalsIgnoreCase("short"))  
  65.             {  
  66.                 String frequencyChkOp = thresholdInfo.getAction();  
  67.                 if(timeWindow!=null)  
  68.                 {  
  69.                      long valueToCheck =                          Long.parseLong(inputTupleList.get(thresholdColNum-1).toString());  
  70.                      long curTime = System.currentTimeMillis();  
  71.                      long diffInMinutes = (curTime-startTime)/(1000);  
  72.                      System.out.println("Difference in minutes="+diffInMinutes);  
  73.                      if(diffInMinutes>=timeWindow)  
  74.                      {  
  75.                           if(frequencyChkOp.equals("<"))  
  76.                           {  
  77.                               if(valueToCheck < Double.parseDouble(thresholdValue.toString()))  
  78.                               {  
  79.                                    count.incrementAndGet();  
  80.                                    if(count.get() > frequency)  
  81.                                        splitAndEmit(inputTupleList,collector);  
  82.                               }  
  83.                           }  
  84.                           else if(frequencyChkOp.equals(">"))  
  85.                           {  
  86.                                if(valueToCheck > Double.parseDouble(thresholdValue.toString()))  
  87.                                 {  
  88.                                    count.incrementAndGet();  
  89.                                    if(count.get() > frequency)  
  90.                                        splitAndEmit(inputTupleList,collector);  
  91.                                }  
  92.                            }  
  93.                            else if(frequencyChkOp.equals("=="))  
  94.                            {  
  95.                               if(valueToCheck == Double.parseDouble(thresholdValue.toString()))  
  96.                               {  
  97.                                   count.incrementAndGet();  
  98.                                   if(count.get() > frequency)  
  99.                                       splitAndEmit(inputTupleList,collector);  
  100.                                }  
  101.                            }  
  102.                            else if(frequencyChkOp.equals("!="))  
  103.                            {  
  104.     . . .  
  105.                             }  
  106.                        }  
  107.              }  
  108.       else 
  109.           splitAndEmit(null,collector);  
  110.       }  
  111.       else 
  112.      {  
  113.            System.err.println("Emitting null in bolt");  
  114.            splitAndEmit(null,collector);  
  115.     }  
  116. } 

经由Bolt发送的的tuple将会传递到下一个对应的Bolt，在我们的用例中是DBWriterBolt。

DBWriterBolt

经过处理的tuple必须被持久化以便于触发tigger或者更深层次的使用。DBWiterBolt做了这个持久化的工作并把tuple存入了数据库。表的建立由prepare（）函数完成，这也将是topology调用的第一个方法。方法的编码如Listing Six所示。

Listing Six：建表编码。

 
 
  1. public void prepare( Map StormConf, TopologyContext context )   
  2. {         
  3.     try   
  4.     {  
  5.         Class.forName(dbClass);  
  6.     }   
  7.     catch (ClassNotFoundException e)   
  8.     {  
  9.         System.out.println("Driver not found");  
  10.         e.printStackTrace();  
  11.     }  
  12.    
  13.     try   
  14.     {  
  15.        connection driverManager.getConnection(   
  16.            "jdbc:mysql://"+databaseIP+":"+databasePort+"/"+databaseName, userName, pwd);  
  17.        connection.prepareStatement("DROP TABLE IF EXISTS "+tableName).execute();  
  18.    
  19.        StringBuilder createQuery = new StringBuilder(  
  20.            "CREATE TABLE IF NOT EXISTS "+tableName+"(");  
  21.        for(Field fields : tupleInfo.getFieldList())  
  22.        {  
  23.            if(fields.getColumnType().equalsIgnoreCase("String"))  
  24.                createQuery.append(fields.getColumnName()+" VARCHAR(500),");  
  25.            else 
  26.                createQuery.append(fields.getColumnName()+" "+fields.getColumnType()+",");  
  27.        }  
  28.        createQuery.append("thresholdTimeStamp timestamp)");  
  29.        connection.prepareStatement(createQuery.toString()).execute();  
  30.    
  31.        // Insert Query  
  32.        StringBuilder insertQuery = new StringBuilder("INSERT INTO "+tableName+"(");  
  33.        String tempCreateQuery = new String();  
  34.        for(Field fields : tupleInfo.getFieldList())  
  35.        {  
  36.             insertQuery.append(fields.getColumnName()+",");  
  37.        }  
  38.        insertQuery.append("thresholdTimeStamp").append(") values (");  
  39.        for(Field fields : tupleInfo.getFieldList())  
  40.        {  
  41.            insertQuery.append("?,");  
  42.        }  
  43.    
  44.        insertQuery.append("?)");  
  45.        prepStatement = connection.prepareStatement(insertQuery.toString());  
  46.     }  
  47.     catch (SQLException e)   
  48.     {         
  49.         e.printStackTrace();  
  50.     }         
  51. }  

数据分批次的插入数据库。插入的逻辑由Listting Seven中的execute（）方法提供。大部分的编码都是用来实现可能存在不同类型输入的解析。

Listing Seven：数据插入的代码部分。

 
 
  1. public void execute(Tuple tuple, BasicOutputCollector collector)   
  2. {  
  3.     batchExecuted=false;  
  4.     if(tuple!=null)  
  5.     {  
  6.        List&#60;Object&#62; inputTupleList = (List&#60;Object&#62;) tuple.getValues();  
  7.        int dbIndex=0;  
  8.        for(int i=0;i&#60;tupleInfo.getFieldList().size();i++)  
  9.        {  
  10.            Field field = tupleInfo.getFieldList().get(i);  
  11.            try {  
  12.                dbIndex = i+1;  
  13.                if(field.getColumnType().equalsIgnoreCase("String"))               
  14.                    prepStatement.setString(dbIndex, inputTupleList.get(i).toString());  
  15.                else if(field.getColumnType().equalsIgnoreCase("int"))  
  16.                    prepStatement.setInt(dbIndex,  
  17.                        Integer.parseInt(inputTupleList.get(i).toString()));  
  18.                else if(field.getColumnType().equalsIgnoreCase("long"))  
  19.                    prepStatement.setLong(dbIndex,   
  20.                        Long.parseLong(inputTupleList.get(i).toString()));  
  21.                else if(field.getColumnType().equalsIgnoreCase("float"))  
  22.                    prepStatement.setFloat(dbIndex,   
  23.                        Float.parseFloat(inputTupleList.get(i).toString()));  
  24.                else if(field.getColumnType().equalsIgnoreCase("double"))  
  25.                    prepStatement.setDouble(dbIndex,   
  26.                        Double.parseDouble(inputTupleList.get(i).toString()));  
  27.                else if(field.getColumnType().equalsIgnoreCase("short"))  
  28.                    prepStatement.setShort(dbIndex,   
  29.                        Short.parseShort(inputTupleList.get(i).toString()));  
  30.                else if(field.getColumnType().equalsIgnoreCase("boolean"))  
  31.                    prepStatement.setBoolean(dbIndex,   
  32.                        Boolean.parseBoolean(inputTupleList.get(i).toString()));  
  33.                else if(field.getColumnType().equalsIgnoreCase("byte"))  
  34.                    prepStatement.setByte(dbIndex,   
  35.                        Byte.parseByte(inputTupleList.get(i).toString()));  
  36.                else if(field.getColumnType().equalsIgnoreCase("Date"))  
  37.                {  
  38.                   Date dateToAdd=null;  
  39.                   if (!(inputTupleList.get(i) instanceof Date))    
  40.                   {    
  41.                        DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");  
  42.                        try   
  43.                        {  
  44.                            dateToAdd = df.parse(inputTupleList.get(i).toString());  
  45.                        }  
  46.                        catch (ParseException e)   
  47.                        {  
  48.                            System.err.println("Data type not valid");  
  49.                        }  
  50.                    }    
  51.                    else 
  52.                    {  
  53.             dateToAdd = (Date)inputTupleList.get(i);  
  54.             java.sql.Date sqlDate = new java.sql.Date(dateToAdd.getTime());  
  55.             prepStatement.setDate(dbIndex, sqlDate);  
  56.             }     
  57.             }   
  58.         catch (SQLException e)   
  59.         {  
  60.              e.printStackTrace();  
  61.         }  
  62.     }  
  63.     Date now = new Date();            
  64.     try 
  65.     {  
  66.         prepStatement.setTimestamp(dbIndex+1, new java.sql.Timestamp(now.getTime()));  
  67.         prepStatement.addBatch();  
  68.         counter.incrementAndGet();  
  69.         if (counter.get()== batchSize)   
  70.         executeBatch();  
  71.     }   
  72.     catch (SQLException e1)   
  73.     {  
  74.         e1.printStackTrace();  
  75.     }             
  76.    }  
  77.    else 
  78.    {  
  79.         long curTime = System.currentTimeMillis();  
  80.        long diffInSeconds = (curTime-startTime)/(60*1000);  
  81.        if(counter.get()&#60;batchSize && diffInSeconds&#62;batchTimeWindowInSeconds)  
  82.        {  
  83.             try {  
  84.                 executeBatch();  
  85.                 startTime = System.currentTimeMillis();  
  86.             }  
  87.             catch (SQLException e) {  
  88.                  e.printStackTrace();  
  89.             }  
  90.        }  
  91.    }  
  92. }  
  93.    
  94. public void executeBatch() throws SQLException  
  95. {  
  96.     batchExecuted=true;  
  97.     prepStatement.executeBatch();  
  98.     counter = new AtomicInteger(0);  
  99. } 

一旦Spout和Bolt准备就绪（等待被执行），topology生成器将会建立topology并准备执行。下面就来看一下执行步骤。

在本地集群上运行和测试topology

  • 通过TopologyBuilder建立topology。
  • 使用Storm Submitter，将topology递交给集群。以topology的名字、配置和topology的对象作为参数。
  • 提交topology。

Listing Eight：建立和执行topology。

 
 
  1. public class StormMain  
  2. {  
  3.      public static void main(String[] args) throws AlreadyAliveException,   
  4.                                                    InvalidTopologyException,   
  5.                                                    InterruptedException   
  6.      {  
  7.           ParallelFileSpout parallelFileSpout = new ParallelFileSpout();  
  8.           ThresholdBolt thresholdBolt = new ThresholdBolt();  
  9.           DBWriterBolt dbWriterBolt = new DBWriterBolt();  
  10.           TopologyBuilder builder = new TopologyBuilder();  
  11.           builder.setSpout("spout", parallelFileSpout, 1);  
  12.           builder.setBolt("thresholdBolt", thresholdBolt,1).shuffleGrouping("spout");  
  13.           builder.setBolt("dbWriterBolt",dbWriterBolt,1).shuffleGrouping("thresholdBolt");  
  14.           if(this.argsMain!=null && this.argsMain.length &#62; 0)   
  15.           {  
  16.               conf.setNumWorkers(1);  
  17.               StormSubmitter.submitTopology(   
  18.                    this.argsMain[0], conf, builder.createTopology());  
  19.           }  
  20.           else 
  21.           {      
  22.               Config conf = new Config();  
  23.               conf.setDebug(true);  
  24.               conf.setMaxTaskParallelism(3);  
  25.               LocalCluster cluster = new LocalCluster();  
  26.               cluster.submitTopology(  
  27.               "Threshold_Test", conf, builder.createTopology());  
  28.           }  
  29.      }  
  30. } 

topology被建立后将被提交到本地集群。一旦topology被提交，除非被取缔或者集群关闭，它将一直保持运行不需要做任何的修改。这也是Storm的另一大特色之一。

这个简单的例子体现了当你掌握了topology、spout和bolt的概念，将可以轻松的使用Storm进行实时处理。如果你既想处理大数据又不想遍历Hadoop的话，不难发现使用Storm将是个很好的选择。

原文链接：Easy, Real-Time Big Data Analysis Using Storm （编译/仲浩 王旭东/审校）

欢迎关注@CSDN云计算微博，了解更多云信息。

本文为CSDN编译整理，未经允许不得转载。如需转载请联系market@csdn.net

miketom155
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用Storm实现实时大数据分析！
02-26
简单和明了，Storm让大数据分析变得轻松加愉快。当今世界，公司的日常运营经常会生成TB级别的数据。数据来源囊括了互联网装置可以捕获的任何类型数据，网站、社交媒体、交易型商业数据以及其它商业环境中创建的数据...
Storm日志分析调研及其实时架构
diaomu5377的博客
09-11 145
1.Storm第一个Demo 2.Windows下基于eclipse的Storm应用开发与调试 3.Storm实例+mysql数据库保存 4.Storm原理介绍 5. flume+kafka+storm+mysql 实时架构 1.Storm第一个Demo 　　Storm运行模式： 本地模式(Local Mode)： 即Topology（相当于一个任务，后续会详细讲解） ...
（3）Storm实时日志分析实战--编码实现
12-27 2438
LogParserBolt类package com.ibeifeng.bigdata.storm.weglog;import backtype.storm.task.OutputCollector; import backtype.storm.task.TopologyContext; import backtype.storm.topology.IBasicBolt; import backtyp
Storm实时计算：Storm的实时计算原理和使用方法
禅与计算机程序设计艺术
07-03 5538
作者：禅与计算机程序设计艺术 Storm 实时计算：Storm 的实时计算原理和使用方法 在大数据处理领域，实时计算是一个重要的话题。在 Hadoop 生态系统中，Storm 是一个实时计算框架，它可以在实时数据流的基础上进行实时计算。本文将介绍 St
大数据-Storm流式框架（一）
最新发布
yaya_jn的博客
10-25 625
实时的分布式高容错。
颠覆大数据分析基于StormSpark等Hadoop替代技术的实时应用
07-23
资源名称：颠覆大数据分析 基于StormSpark等Hadoop替代技术的实时应用 内容简介：Vijay Srinivas Agneeswaran 博士，1998 年于SVCE 的马德拉斯分校获得计算机科学与工程专业的学士学位，2001 年获取了印度理工学院...
Storm数据流模型的分析及讨论
02-25
本文来自于博客园，本文首先介绍了Storm的基本概念和数据流模型，然后结合一个典型应用场景来说明Storm支持Topology之间数据流订阅的必要性，最后对比了Storm与另一个流处理系统在数据流模型上的区别之处。Storm是一...
天猫订单数据分析
sweettwo2的博客
10-25 3490
一、数据理解 1.数据为天猫订单部分真实数据，存放在一个tmall_order_report.csv文件里，总计28010条数据，具体字段为： 订单编号 总金额：订单总金额，共866种 买家实际支付金额：最终支付金额，分为已付款和未付款 已付款：买家实际支付金额 = 总金额 - 退款金额 未付款：买家实际支付金额 = 0 收货地址：共31个省市 订单创建时间：2020年2月1日 至 2020年2月29日 订单付款时间：2020年2月1日 至 2020年3月1日 退款金额：付款后申请退..
Storm例题：双十一订单
weixin_44911248的博客
07-18 484
Storm例题
大数据与云计算——Storm详细配置(保姆级教程！）
未来社会二十年发展的核心技术趋势由ABCD四个字母组成，分别是AI（人工智能）、BlockChain（区块链）、Cloud（云）、和Data（大数据）每一次进步都有新的认知和感触
09-27 908
在这篇文章中，我们将从头开始，将提供一份保姆级教程，帮助进行相关配置和运行WordCountTopology。向您展示如何配置Storm环境。我们将详细介绍所需的软件和工具，并提供逐步指导，帮助您完成安装和配置过程。本人也在不断努力进步，希望自己的博文能够希望对各位有所帮助。
Storm 系列（二）—— Storm 核心概念详解
weixin_30362083的博客
09-03 171
一、Storm核心概念 1.1 Topologies（拓扑） 一个完整的 Storm 流处理程序被称为 Storm topology(拓扑)。它是一个是由 Spouts 和 Bolts 通过 Stream 连接起来的有向无环图，Storm 会保持每个提交到集群的 topology 持续地运行，从而处理源源不断的数据流，直到你将主动其杀死 (kill) 为止。 1.2 Streams...
大数据开源框架环境搭建(八)——Storm完全分布式集群的安装部署以及编程实践(自带的WordCountTopology的例子)
木子一个Lee的博客
02-18 1583
Ubuntu 18.04系统3台Storm 0.9.6(一定要是此版本才有WordCountTopology的例子)
Storm大数据处理
u014659211的专栏
12-09 1360
1.hadoop有master与slave，Storm与之对应的节点是什么？ 2.Storm控制节点上面运行一个后台程序被称之为什么？ 3.Supervisor的作用是什么？ 4.Topology与Worker之间的关系是什么？ 5.Nimbus和Supervisor之间的所有协调工作有master来完成，还是Zookeeper集群完成？ 6.storm稳定的原因是什么？ 7.如何运行Topology？ strom jar all-your-code.jar backtype.storm.MyTopolog
大数据之Storm的安装部署和客户端使用
shairvin的博客
06-01 668
Storm下载地址：http://storm.apache.org/downloads.html。
Storm的基本使用与工作过程理解
网世的博客
07-30 702
一 storm的集群部署 博客地址:http://www.panchengming.com/2018/01/26/pancm70/ 二 storm的常用操作 有许多简单且有用的命令可以用来管理拓扑，它们可以提交、杀死、禁用、再平衡拓扑。 (1).提交任务命令格式：storm jar 【jar路径】 【拓扑包名.拓扑类名】 【拓扑名称】 bin/storm jar examples/s...
Storm超实用教程详解-附示例
编程是一门实践技术
06-08 1393
Storm 中最重要的抽象，应该就是 Stream grouping 了，它能够控制 Spot/Bolt 对应的 Task 以什么样的方式来分发 Tuple，将 Tuple 发射到目的 Spot/Bolt 对应的 Task.定义拓扑的时候，一部分工作是指定每个Bolt应该消费哪些流。是一个轻量级的数据格式，支持基本的类型，如果想实现自定义的类型，需要实现自己的序列化方式。把数据的计算处理过程合理的拆分到多个Bolt、合理设置Bolt的task数量，能够提高Bolt的处理能力，提升流水线的并发度。
Storm 系列（五）—— Storm 编程模型详解
weixin_30362083的博客
09-03 208
一、简介 下图为 Strom 的运行流程图，在开发 Storm 流处理程序时，我们需要采用内置或自定义实现 spout(数据源) 和 bolt(处理单元)，并通过 TopologyBuilder 将它们之间进行关联，形成 Topology。 二、IComponent接口 IComponent 接口定义了 Topology 中所有组件 (spout/bolt) 的公共方法，自定义的 ...
Storm的基础知识-教程（1）
likebutterfly的博客
09-03 460
Storm集群的组件 Storm集群在表面上类似于Hadoop集群。而在Hadoop上运行“MapReduce作业”，在Storm上运行“拓扑”。 “作业”和“拓扑”本身是非常不同的 - 一个关键的区别是MapReduce作业完成会结束，而拓扑一直处理消息（或直到你杀死它）。 Storm集群上有两种节点：主节点和工作节点。 主节点运行一个名为“Nimbus”的守护进程，负责在集群周围分发代码，为...
轻量级大数据分析框架
08-23
有很多轻量级的大数据分析框架可供选择，以下是一些常见的： 1. Apache Hadoop：Hadoop 是一个开源的大数据处理框架，它提供了分布式存储和处理大规模数据的能力。 2. Apache Spark：Spark 是一个快速而通用的大...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值