首页 > 其他分享 >Storm实战——起步

Storm实战——起步

时间：2023-07-24 16:07:52浏览次数：34  
标签：实战 起步 word Storm storm new import collector


翻译自：Getting Started With Storm （作者：Jonathan Leibiusky, Gabriel Eisbruch and Dario Simonassi）


    在这一章，我们将动手创建一个Storm项目和第一个Storm topology。

    下面假定你已经安装了最新的Jre 1.6。我们推荐使用Oracle提供的JRE，你可以在http://www.java.com/downloads/找到。

 

操作模式

       在我们开始操作之前，理解Storm的操作方式是很重要的。运行Storm有两种方式。

 

本地模式

       在本地模式下，Storm拓扑（topology）运行在本地机器的单个JVM中。这种模式被用于开发、测试和调试，因为它非常容易观察到所有的拓扑组件一起工作。在这种模式下，我们可以调整参数使我们看到我们的拓扑在不同的Storm配置环境下的运行状况。要在本地模式下运行拓扑，我们必须下载Storm开发依赖包，它们负责开发和测试我们的拓扑的所有事情。我们将在我们创建第一个Storm项目时见到。

       在本地模式下运行一个拓扑和在Storm集群中运行时相似的。然而，确保所有的组件式线程安全的非常重要，因为当它们以远程模式部署时（即在不同的JVM或不同的物理机器）将不会有直接通信和共享内存。

       在本章的所有示例中，我们将以本地模式运行。

 

远程模式

       在远程模式下，我们向Storm集群提交拓扑。Storm集群由很多进程组成，通常运行在不同的机器中。远程模式不会显示调试信息，这也是它也被认为是生产模式的原因。然而，也可以在单个开发机器上创建一个Storm集群，为了确保在生产环境下运行拓扑不会有任何问题，在部署到生产环境前这么做是一个好方法。

       你将会在第六章学习到更多有关远程模式的内容，我将在附录B中告诉你如何安装一个集群。

 

Hello World Storm

       在这个项目中，我们将创建一个计数单词的简单拓扑。我们可以叫这个Storm拓扑为“Hello World”。然而，这个一个非常强大的拓扑，因为它可以扩展到几乎无限的大小，同时在一些小的修改后还可以使用它来构建一个统计系统。例如，我们可以修改项目来找Twitter中热门话题。

       创建拓扑，我们需要使用一个spout来负责读入单词，第一个bolt来标准化单词，第二个bolt来计数单词，如图2-1所示。

 

Storm实战——起步_git

图2-1 topology初步

       你可以在https://github.com/storm-book/examples-ch02-getting_started/zipball/master

下载示例zip形式源代码。 

       如果你使用git（分布式的版本控制和源代码管理），你可以在你想要存储源代码的目录中运行git clone [email protected]:storm-book/examples-ch02-getting_started.git

 

检查Java安装

       创建环境的第一步是检查你正在运行的Java版本。打开一个windows终端，运行命令java –version。我们可以看到类似下面的内容。

 



1. java -version  
2. java version "1.6.0_26"  
3. Java(TM) SE Runtime Environment (build 1.6.0_26-b03)  
4. Java HotSpot(TM) Server VM (build 20.1-b02, mixed mode)


 

如果不是，检查Java安装。（查看http://www.java.com/download/）

 

创建项目

       首先创建一个你准备存放应用的文件夹（如其它Java应用一样）。这个文件夹将用于存放项目源代码。

       下一步，我们需要下载Storm依赖包：将会被加入到应用类路径（classpath）的jar包集。你可以在下面两种方式中任选其一来完成。

l  下载依赖包，解压，加入到项目类路径

l  使用Apache Maven

 

        Maven是一个软件项目管理和理解工具。它可以被用于管理一个项目开发周期的多个方面，从依赖到发布构建过程。在这本书，我们将广泛地使用它。要检查maven是否已安装，运行命令mvn。如果没有，你可以在http://maven.apache.org/download.html下载到它。

       尽管为了使用Storm成为Maven专家是没有必要的，但了解Maven是如何工作的还是很有用的。你可以在Apache Maven站点（http://maven.apache.org/）了解到更多相关内容。

       定义项目结构，首先需要创建pom.xml（Project objectmodel，项目对象模型）文件，它描述了项目依赖包、如何打包、源代码等等。我们将使用由nathanmarz（https://github.com/nathanmarz/）建立的Maven依赖仓库，具体位置在https://github.com/nathanmarz/storm/wiki/Maven。

       Storm的Maven依赖包包含了所有在本地模式下运行Storm所需的库。

 

       使用这些依赖，我们可以创建一个运行我们的拓扑所必须的基本的组件的描述文件pom.xml。

 


1. <project xmlns="http://maven.apache.org/POM/4.0.0"  
2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0  
4. http://maven.apache.org/xsd/maven-4.0.0.xsd">  
5. <modelVersion>4.0.0</modelVersion>  
6. <groupId>storm.book</groupId>  
7. <artifactId>Getting-Started</artifactId>  
8. <version>0.0.1-SNAPSHOT</version>  
9.   
10. <build>  
11. <plugins>  
12. <plugin>  
13. <groupId>org.apache.maven.plugins</groupId>  
14. <artifactId>maven-compiler-plugin</artifactId>  
15. <version>2.3.2</version>  
16. <configuration>  
17. <source>1.6</source>  
18. <target>1.6</target>  
19. <compilerVersion>1.6</compilerVersion>  
20. </configuration>  
21. </plugin>  
22. </plugins>  
23. </build>  
24.   
25. <repositories>  
26. <!-- Repository where we can found the storm dependencies -->  
27. <repository>  
28. <id>clojars.org</id>  
29. <url>http://clojars.org/repo</url>  
30. </repository>  
31. </repositories>  
32.   
33. <dependencies>  
34. <!-- Storm Dependency -->  
35. <dependency>  
36. <groupId>storm</groupId>  
37. <artifactId>storm</artifactId>  
38. <version>0.6.0</version>  
39. </dependency>  
40. </dependencies>  
41. </project>


          

前几行指定项目名和版本。接下来，加入一个编译器插件，告诉Maven代码必须使用Java1.6进行编译。下一步定义了仓库（Maven支持同一个项目多个仓库）。Clojars是一个存放Storm依赖的仓库。Maven将自动下载所有在本地模式下运行Storm所需的子依赖包。

 

  对于一个典型的Maven Java项目，将会是如下结构。

 our-application-folder/

                 ├── pom.xml

                         └── src

                                 └── main

                                      └── java

                                                 ├── spouts

                                                 └── bolts

                                      └── resources

       文件夹下将包含我们的源代码，同时Word文件将会被放入resource文件夹下处理。

       命令mkdir –p 会创建所需的所有父目录。

 

创建我们的第一个拓扑

       构建我们的第一个拓扑，我们将创建所有的运行单词计数的类。可能在这个阶段有一部分示例不够清晰，但我们将在接下来的章节进行解释。

 

Spout

       WordReader是一个spout类，它将实现接口IRichSpout。我们将在第四章了解到更多细节。WordReader负责读入文件，并将每行提供给bolt进一步处理。

      Spout发送一个定义的字段列表。这种架构允许spout定义字段来让其它bolts消费，不同的bolt可以从相同的spout流中读入数据。

 

示例2-1包含了完整的类代码（我们将按照示例来分析代码的每个部分）。

 

示例2-1src/main/java/spouts/WordReader.java

 



1. package spouts;  
2. import java.io.BufferedReader;  
3. import java.io.FileNotFoundException;  
4. import java.io.FileReader;  
5. import java.util.Map;  
6. importbacktype.storm.spout.SpoutOutputCollector;  
7. import backtype.storm.task.TopologyContext;  
8. import backtype.storm.topology.IRichSpout;  
9. importbacktype.storm.topology.OutputFieldsDeclarer;  
10. import backtype.storm.tuple.Fields;  
11. import backtype.storm.tuple.Values;  
12. public class WordReader implements IRichSpout {  
13. private SpoutOutputCollector collector;  
14. private FileReader fileReader;  
15. private boolean completed = false;  
16. private TopologyContext context;  
17. public boolean isDistributed() {return false;}  
18. public void ack(Object msgId) {  
19. System.out.println("OK:"+msgId);  
20. }  
21. public void close() {}  
22. public void fail(Object msgId) {  
23. System.out.println("FAIL:"+msgId);  
24. }  
25. /**
26. * The only thing that the methods will do It is emit each
27. * file line
28. */  
29. public void nextTuple() {  
30. /**
31. * The nextuple it is called forever, so if we have been readed the file
32. * we will wait and then return
33. */  
34. if(completed){  
35. try {  
36. Thread.sleep(1000);  
37. } catch (InterruptedExceptione) {  
38. //Do nothing  
39. }  
40. return;  
41. }  
42. String str;  
43. //Open the reader  
44. BufferedReader reader = new BufferedReader(fileReader);  
45. try{  
46. //Read all lines  
47. while((str = reader.readLine())!= null){  
48. /**
49. * By each line emmit a new value with the line as a their
50. */  
51. this.collector.emit(new Values(str),str);  
52. }  
53. }catch(Exception e){  
54. throw new RuntimeException("Errorreading tuple",e);  
55. }finally{  
56. completed = true;  
57. }  
58. }  
59. /**
60. * We will create the file and get the collector object
61. */  
62. public void open(Map conf,TopologyContext context,  
63. SpoutOutputCollector collector) {  
64. try {  
65. this.context = context;  
66. this.fileReader = new FileReader(conf.get("wordsFile").toString());  
67. } catch (FileNotFoundExceptione) {  
68. throw new RuntimeException("Errorreading file  
69. ["+conf.get("wordFile")+"]");  
70. }  
71. this.collector = collector;  
72. }  
73. /**
74. * Declare the output field "word"
75. */  
76. public void declareOutputFields(OutputFieldsDeclarerdeclarer) {  
77. declarer.declare(new Fields("line"));  
78. }  
79. }


 

public void open(Map conf,TopologyContext ontext, SpoutOutputCollector collector)是所有spout被调用的第一个方法。接收参数包括：TopologyContext，包含所有拓扑数据；conf，在拓扑定义时创建；SpoutOutputCollector，允许我们向bolts发送要处理的数据。接下来的代码是open方法的实现：

 


    1. public void open(Map conf, TopologyContext context,  
2. SpoutOutputCollector collector) {  
3. try {  
4. this.context = context;  
5. this.fileReader = newFileReader(conf.get("wordsFile").toString());  
6. } catch (FileNotFoundException e) {  
7. throw new RuntimeException("Error reading file ["+conf.get("wordFile")+"]");  
8. }  
9. this.collector = collector;  
10. }



    在这个方法中创建了一个reader，它负责读取文件。接下来，我们需要实现public voidnextTuple()，它将向bolts发送要处理的数据。在我们的示例中，该方法将读入文件并将每行数据作为一个值发送。


     

     



    1. public void nextTuple() {  
2. if(completed){  
3. try {  
4. Thread.sleep(1);  
5. } catch (InterruptedException e) {  
6. //Do nothing  
7. }  
8. return;  
9. }  
10. String str;  
11. BufferedReader reader = new BufferedReader(fileReader);  
12. try{  
13. while((str = reader.readLine()) != null){  
14. this.collector.emit(new Values(str));  
15. }  
16. }catch(Exception e){  
17. throw new RuntimeException("Error reading tuple",e);  
18. }finally{  
19. completed = true;  
20. }  
21. }


    Values是ArrayList的实现，链表的元素被传入到构造函数中。

     

     

           nextTuple方法和ack()、fail()方法被以相同周期地调用。在没有要做的事情时，它必须释放线程的控制权，以使其它方法有机会被调用。所以，nextTuple方法的第一行检查工作是否已完成。如果这样，它将会在重新运行前休息至少1ms来降低处理器负载。如果有工作要做，文件的每行内容将被作为一个值发送。

           Tuple是一个命名的值的列表，值可以是任意类型的Java对象（只要是可序列号对象）。默认情况下，Storm可以序列通用的类型，包括字符串、字节数组、ArrayList、HashMap和HashSet等。

     

    Bolts

           现在我们已经拥有一个从文件读入并发送每行内容作为tuple的一个spout。接下来，我们需要创建两个bolts来处理这些tuple（如图2-1）。这些bolt均实现backtype.storm.topology.IRichBolt接口。

           Bolt中最重要的方法是voidexecute(Tuple input)，一旦有tuple输入它就会被调用。Bolt对每个tuple处理后可以发送多个tuple。

           Bolt和spout可以发送任意多的tuple。当nextTuple或execute方法被调用时，它们可以发送0,1或多个tuple。你将在第五章了解到更多相关内容。

     

           第一个bolt，WordNormalizer，将负责处理每行并标准化。它将行拆分为单词，强制转换所有单词为小写和去掉前后空白字符。

           首先，我们需要声明bolt的输出参数：

     



    1. public void declareOutputFields(OutputFieldsDeclarer declarer) {  
2. declarer.declare(new Fields("word"));  
3. }



     

           这里，我们声明bolt发送一个名为word的字段。

           接下来，我们实现方法public void execute(Tupleinput)，负责处理每个tuple输入。

     

    1. public void execute(Tuple input) {  
2. String sentence = input.getString(0);  
3. String[] words = sentence.split(" ");  
4. for(String word : words){  
5. word = word.trim();  
6. if(!word.isEmpty()){  
7. word = word.toLowerCase();  
8. //Emit the word  
9. collector.emit(new Values(word));  
10. }  
11. }  
12. // Acknowledge the tuple  
13. collector.ack(input);  
14. }



     

    第一行从tuple中读入值。值可以按名字或按索引位置读取。值被处理并使用collector对象发送。每一个tuple被处理后，collector的ack方法被调用以指示处理已经完全成功。如果tuple不能被处理，collector的fail方法将会被调用。

     

    示例2-2包含了类的完整代码

     

    示例2-2src/main/java/bolts/WordNormalizer.java

     



      1. package bolts;  
2. import java.util.ArrayList;  
3. import java.util.List;  
4. import java.util.Map;  
5. import backtype.storm.task.OutputCollector;  
6. import backtype.storm.task.TopologyContext;  
7. import backtype.storm.topology.IRichBolt;  
8. import backtype.storm.topology.OutputFieldsDeclarer;  
9. import backtype.storm.tuple.Fields;  
10. import backtype.storm.tuple.Tuple;  
11. import backtype.storm.tuple.Values;  
12. public class WordNormalizer implements IRichBolt {  
13. private OutputCollector collector;  
14. public void cleanup() {}  
15. /**
16. * The bolt will receive the line from the
17. * words file and process it to Normalize this line
18. *
19. * The normalize will be put the words in lower case
20. * and split the line to get all words in this
21. */  
22. public void execute(Tuple input) {  
23. String sentence = input.getString(0);  
24. String[] words = sentence.split(" ");  
25. for(String word : words){  
26. word = word.trim();  
27. if(!word.isEmpty()){  
28. word = word.toLowerCase();  
29. //Emit the word  
30. List a = new ArrayList();  
31. a.add(input);  
32. collector.emit(a,new Values(word));  
33. }  
34. }  
35. // Acknowledge the tuple  
36. collector.ack(input);  
37. }  
38. public void prepare(Map stormConf, TopologyContext context,  
39. OutputCollector collector) {  
40. this.collector = collector;  
41. }  
42. /**
43. * The bolt will only emit the field "word"
44. */  
45. public void declareOutputFields(OutputFieldsDeclarer declarer) {  
46. declarer.declare(new Fields("word"));  
47. }  
48. }



       

              在这个类中，可以看到在单个execute调用中发送了多个tuple。如果方法接收到句子This is the Stormbook，在单次调用后，将会发送五个新的tuple。

       

              下一个bolt，WordCounter，它负责单词计数。当拓扑完成时（即当cleanup方法被调用时），我们将看到每个单词的数目。

             这是一个bolt不发送任何tuple的示例。在本例中，数据被加入到map中，但实际环境下可以将数据存储到数据库中。

       



        1. package bolts;  
2. import java.util.HashMap;  
3. import java.util.Map;  
4. import backtype.storm.task.OutputCollector;  
5. import backtype.storm.task.TopologyContext;  
6. import backtype.storm.topology.IRichBolt;  
7. import backtype.storm.topology.OutputFieldsDeclarer;  
8. import backtype.storm.tuple.Tuple;  
9. public class WordCounter implements IRichBolt {  
10. Integer id;  
11. String name;  
12. Map<String, Integer> counters;  
13. private OutputCollector collector;  
14. /**
15. * At the end of the spout (when the cluster is shutdown
16. * We will show the word counters
17. */  
18. @Override  
19. public void cleanup() {  
20. System.out.println("-- Word Counter["+name+"-"+id+"] --");  
21. for(Map.Entry<String, Integer> entry : counters.entrySet()){  
22. System.out.println(entry.getKey()+": "+entry.getValue());  
23. }  
24. }  
25. /**
26. * On each word We will count
27. */  
28. @Override  
29. public void execute(Tuple input) {  
30. String str = input.getString(0);  
31. /**
32. * If the word dosn't exist in the map we will create
33. * this, if not We will add 1
34. */  
35. if(!counters.containsKey(str)){  
36. counters.put(str, 1);  
37. }else{  
38. Integer c = counters.get(str) + 1;  
39. counters.put(str, c);  
40. }  
41. //Set the tuple as Acknowledge  
42. collector.ack(input);  
43. }  
44. /**
45. * On create
46. */  
47. @Override  
48. public void prepare(Map stormConf, TopologyContext context,  
49. OutputCollector collector) {  
50. this.counters = new HashMap<String, Integer>();  
51. this.collector = collector;  
52. this.name = context.getThisComponentId();  
53. this.id = context.getThisTaskId();  
54. }  
55. @Override  
56. public void declareOutputFields(OutputFieldsDeclarer declarer) {}  
57. }



         

        execute方法使用map来收集和单词的计算。当拓扑结束时，cleanup方法被调用并打印出计数map。（这仅仅是个示例，通常你在拓扑关闭时，需要使用cleanup方法来关闭主动连接和其它资源）

         

        Main函数

               在这个主函数中，我们将创建一个topology和一个LocalCluster对象，使你可以在本地测试和调试这个topology。结合Config对象，LocalCluster允许你试验不同的集群配置。例如，如果一个全局或类变量被偶然使用，你会在测试使用不同数目的workers时发现错误。（你会在第三章了解到更多有关config对象的知识）

               所有的拓扑节点均应独立允许，而不能有进程间共享数据（例如无全局或类变量）。因为当拓扑运行在真实集群中时，这些进程可能运行在不同机器中。

               我们将使用TopologyBuilder创建一个拓扑，它向Storm指定了节点的排列和数据的交换方式。

         




        1. TopologyBuilder builder = new TopologyBuilder();  
2. builder.setSpout("word-reader",new WordReader());  
3. builder.setBolt("word-normalizer", newWordNormalizer()).shuffleGrouping("wordreader");  
4. builder.setBolt("word-counter", newWordCounter()).shuffleGrouping("wordnormalizer");


         

         

               spout和bolts使用shuffleGroupings相连，Storm的这种分组方式决定了从源节点向目标节点以随机分发的方式发送消息。

               接下来，创建一个保护拓扑配置信息的config对象，它将会在运行时与集群配置合并，并通过prepare方法向所有节点发送。

         



        1. Config conf = new Config();  
2. conf.put("wordsFile", args[0]);  
3. conf.setDebug(true);

         

        设置属性wordsFile值为spout要读入的文件名，在开发环境下设置debug为true。当debug为true时，Storm将会打印出所有节点间的交换消息和其它对理解拓扑如何运行有用的信息。

               如之前解释的，我们将使用LocalCluster对象来运行拓扑。在生产环境下，拓扑时持续运行的，但是对于我们的例子，我们只会运行拓扑几秒钟以便你可以看到结果。

         


        1. LocalCluster cluster = new LocalCluster();  
2. cluster.submitTopology("Getting-Started-Toplogie", conf,builder.createTopology());  
3. Thread.sleep(2000);  
4. cluster.shutdown();


         

               使用createTopology、submitTopology方法创建和运行拓扑，休息2s（拓扑运行于不同的线程），接下来通过关闭集群来停止拓扑。

               示例2-3汇总了所有代码。

        示例2-3src/main/java/TopologyMain.java

         


        1. import spouts.WordReader;  
2. import backtype.storm.Config;  
3. import backtype.storm.LocalCluster;  
4. import backtype.storm.topology.TopologyBuilder;  
5. import backtype.storm.tuple.Fields;  
6. import bolts.WordCounter;  
7. import bolts.WordNormalizer;  
8. public class TopologyMain {  
9. public static void main(String[] args) throws InterruptedException {  
10. //Topology definition  
11. TopologyBuilder builder = new TopologyBuilder();  
12. builder.setSpout("word-reader",new WordReader());  
13. builder.setBolt("word-normalizer", new WordNormalizer())  
14. .shuffleGrouping("word-reader");  
15. builder.setBolt("word-counter", new WordCounter(),2)  
16. .fieldsGrouping("word-normalizer", newFields("word"));  
17. //Configuration  
18. Config conf = new Config();  
19. conf.put("wordsFile", args[0]);  
20. conf.setDebug(false);  
21. //Topology run  
22. conf.put(Config.TOPOLOGY_MAX_SPOUT_PENDING, 1);  
23. LocalCluster cluster = new LocalCluster();  
24. cluster.submitTopology("Getting-Started-Toplogie", conf,  
25. builder.createTopology());  
26. Thread.sleep(1000);  
27. cluster.shutdown();  
28. }  
29. }


         

        查看运行结果

               你已经准备好运行你的第一个拓扑了！如果你创建一个拥有一行内容的src/main/resources/words.txt的文件，你就可以使用以下命令来运行拓扑：mvn exec:java-Dexec.mainClass="TopologyMain" -Dexec.args="src/main/resources/words.txt"

        例如，你使用如下的words.txt文件

         


          1. Storm  
2. test  
3. are  
4. great  
5. is  
6. an  
7. Storm  
8. simple  
9. application  
10. but  
11. very  
12. powerful  
13. really  
14. Storm  
15. is  
16. great



           

                  在日志中，你会看到类似如下内容：

           


          1. is: 2  
2. application: 1  
3. but: 1  
4. great: 1  
5. test: 1  
6. simple: 1  
7. Storm: 3  
8. really: 1  
9. are: 1  
10. great: 1  
11. an: 1  
12. powerful: 1  
13. very: 1



           

                 在这个示例中，你仅仅使用在每个节点上运行单个实例。如果你有一个很大的日志文件怎么办？你可以轻易地改变在系统中节点的数目来并行完成这个工作。在本例中，你将创建两个WordCounter实例：

           



          1. builder.setBolt("word-counter", new WordCounter(),2)  
2. .shuffleGrouping("word-normalizer");


           

                如果你重新运行这个项目，你将会看到

           



          1. -- Word Counter [word-counter-2] --  
2. application: 1  
3. is: 1  
4. great: 1  
5. are: 1  
6. powerful: 1  
7. Storm: 3  
8. -- Word Counter [word-counter-3] --  
9. really: 1  
10. is: 1  
11. but: 1  
12. great: 1  
13. test: 1  
14. simple: 1  
15. an: 1  
16. very: 1




           

                  太好了！很简单地改变了并行级别（当然在实际中，每个实例会运行在单独的机器中）。但是这似乎有一个问题：单词is和great在每个WordCounter实例中计数了一次。为什么？当你使用shuffleGrouping时，等于告诉Storm以随机分发方式发送消息给每个bolt。在这个示例中，理想是将相同的单词发送给相同的WordCounter实例。要做到这一点，你可以将shuffleGrouping(“word-normalizer”)改为fieldsGrouping(“word-normalizer”,newFields(“word”))。重运行一次确认一下结果。你将在接下来的章节了解到分组和消息流的更多内容。

           

          结论

                 我们已经讨论了Storm的本地模式和远程操作模式的区别，Storm的强大威力和开发的简单。在接下来的章节，你将会学习到更多Storm更深层次的基本概念。


          标签：实战,起步,word,Storm,storm,new,import,collector
          From： https://blog.51cto.com/u_16087105/6835928

          相关文章

          • python爬虫实战——小说爬取
            python爬虫实战——小说爬取基于requests库和lxml库编写的爬虫，目标小说网站域名http://www.365kk.cc/，类似的小说网站殊途同归，均可采用本文方法爬取。目标网站：传送门本文的目标书籍：《我的师兄实在太稳健了》“渡劫只有九成八的把握，和送死有什么区别？”基本思路网络爬虫的工作实际上主......
          • 一次Java垃圾收集调优实战
            1资料JDK5.0垃圾收集优化之--Don'tPause(花钱的年华) 编写对GC友好，又不泄漏的代码(花钱的年华) JVM调优总结 JDK6所有选项及默认值 2GC日志打印 GC调优是个很实验很伽利略的活儿，GC日志是先决的数据参考和最终验证：-XX:+PrintGCDetails-XX:+PrintGCTimeStamps(GC发生的......
          • 【项目实战】Kafka 的 Leader 选举和负载均衡
            ......
          • Mybatis实战教程
            欢迎大家前来白嫖PDF。下图回复：666本教程致力于最实用mybatis教程，个别图片粘贴有丢失，还有来领取原版。文章目录前言1，什么是Mybatis之JDBC攻城狮1,1，使用idea构建maven工程1，2，引入mysql依赖包1，3，准备数据1,4，jdbc代码回顾1，5，jdbc缺点分析4，MyBatis介绍3，MyBatis整体架构4，快速入门（quicksta......
          • rodert教你学Maven-实战这一篇就够了
            欢迎大家前来白嫖PDF。下图回复：666本教程致力于最实用教程，个别图片粘贴有丢失，还有来领取原版。文章目录前言1.什么是Maven？2.maven的作用2.1.Maven的功能2.2.为什么使用maven3.maven安装和配置3.1.安装3.2.配置4.maven项目规约5.命令行构建maven项目5.1.命令行构建Java项目5.2.使用......
          • Golang 规则引擎原理及实战
            本文主要介绍规则引擎在golang中的使用，将首先介绍golang中主要的规则引擎框架，然后利用golang原生的parser搭建一个简单的规则引擎实现基本的bool表达式解析工作。背景随着业务代码的不断迭代，诞生出了越来越多的if-else，并且if-else中的逻辑越来越复杂，导致代码逻辑复......
          • 【项目实战】Kafka 重平衡 Consumer Group Rebalance 机制
            ......
          • 济南 S NOIP 刷题实战梳理营游记
            前言期末砸力。这次暑假去两个营，一个在烟台，一个在青岛。在烟台的都是学算法，扔到目录里了，这篇文章就是来讲济南营的。一共十二天，每天上午八点到十二点打比赛，然后吃饭，然后讲题。Day-1\(6h\)的大巴，绷不住了，中途在潍坊西休息，热死了。到了济南，住在酒店旁边，楼下全是吃的，很赞。......
          • 1.负载均衡服务LVS及三种模型实战案例
            知识小课堂1.负载均衡会话保持sessionsticky：同一用户调度固定服务器sessionreplication:每台服务器拥有全部sessionsessionserver：专门的session服务器2.LVS集群工作模式NAT:DR:（必须在同一网络，用改内核参数）TUNNEL:(可以跨网络，不用改内核参数,需要单独增加tunnel网卡)FUL......
          • AI识别检验报告 -PaddleNLP UIE-X 在医疗领域的实战
            目录UIE-X在医疗领域的实战1.项目背景2.案例简介3.环境准备数据转换5.模型微调6.模型评估7.Taskflow一键部署UIE-X在医疗领域的实战PaddleNLP全新发布UIE-X......

          赞助商

          阅读排行

          网站主页关于我们联系我们网站地图

          本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

          Copyright © 2020-2023 IPS99 版权所有 IPS99