Spark之java操作WordCount

可以看到自动为WordCount类创建了main方法。

Maven管理项目的核心就是pom.xml，在这个文件中有工程编写运行时的依赖的支持。

编写程序前需要先修改pom.xml。

[html]  view plain  copy

1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
3.   <modelVersion>4.0.0</modelVersion>  
4.   
5.   
6.   <groupId>com.dt.spark</groupId>  
7.   <artifactId>SparkApps</artifactId>  
8.   <version>0.0.1-SNAPSHOT</version>  
9.   <packaging>jar</packaging>  
10.   
11.   
12.   <name>SparkApps</name>  
13.   <url>http://maven.apache.org</url>  
14.   
15.   
16.   <properties>  
17.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
18.   </properties>  
19.   
20.   
21.   <dependencies>  
22.     <dependency>  
23.       <groupId>junit</groupId>  
24.       <artifactId>junit</artifactId>  
25.       <version>3.8.1</version>  
26.       <scope>test</scope>  
27.     </dependency>  
28.     <dependency>  
29.        <groupId>org.apache.spark</groupId>  
30.        <artifactId>spark-core_2.10</artifactId>  
31.        <version>1.6.0</version>  
32.     </dependency>  
33.     <dependency>  
34.         <groupId>org.apache.spark</groupId>  
35.         <artifactId>spark-sql_2.10</artifactId>  
36.         <version>1.6.0</version>  
37.     </dependency>  
38.     <dependency>  
39.       <groupId>org.apache.spark</groupId>  
40.       <artifactId>spark-hive_2.10</artifactId>  
41.       <version>1.6.0</version>  
42.     </dependency>  
43. <dependency>  
44.      <groupId>org.apache.spark</groupId>  
45.      <artifactId>spark-streaming_2.10</artifactId>  
46.      <version>1.6.0</version>  
47. </dependency>  
48. <dependency>  
49.      <groupId>org.apache.hadoop</groupId>  
50.      <artifactId>hadoop-client</artifactId>  
51.      <version>2.6.0</version>  
52. </dependency>  
53. <dependency>  
54.      <groupId>org.apache.spark</groupId>  
55.      <artifactId>spark-streaming-kafka_2.10</artifactId>  
56.      <version>1.6.0</version>  
57. </dependency>  
58. <dependency>  
59.      <groupId>org.apache.spark</groupId>  
60.      <artifactId>spark-graphx_2.10</artifactId>  
61.      <version>1.6.0</version>  
62. </dependency>  
63.   </dependencies>  
64.     
65.   <build>  
66.      <sourceDirectory>src/main/java</sourceDirectory>  
67.      <testSourceDirectory>src/main/test</testSourceDirectory>  
68.   
69.   
70.      <plugins>  
71.            <plugin>  
72.                <artifactId>maven-assembly-plugin</artifactId>  
73.                <configuration>  
74.                  <descriptorRefs>  
75.                    <descriptorRef>jar-with-dependencies</descriptorRef>  
76.                  </descriptorRefs>  
77.                  <archive>  
78.                     <manifest>  
79.                         <maniClass></maniClass>  
80.                     </manifest>  
81.                  </archive>  
82.                </configuration>  
83.                <executions>  
84.                    <execution>  
85.                       <id>make-assembly</id>  
86.                       <phase>package</phase>  
87.                       <goals>  
88.                          <goal>single</goal>  
89.                       </goals>  
90.                    </execution>  
91.                </executions>  
92.            </plugin>  
93.            <plugin>  
94.                <groupId>org.codehaus.mojo</groupId>  
95.                <artifactId>exec-maven-plugin</artifactId>  
96.                <version>1.3.1</version>  
97.                <executions>  
98.                   <execution>  
99.                      <goals>  
100.                         <goal>exec</goal>  
101.                      </goals>  
102.                   </execution>  
103.                </executions>  
104.                <configuration>  
105.                    <executable>java</executable>  
106.                    <includeProjectDependencies>false</includeProjectDependencies>  
107.                    <classpathScope>compile</classpathScope>  
108.                    <mainClass>com.dt.spark.SparkApps.WordCount</mainClass>  
109.                </configuration>  
110.            </plugin>  
111.            <plugin>  
112.               <groupId>org.apache.maven.plugins</groupId>  
113.               <artifactId>maven-compiler-plugin</artifactId>  
114.               <configuration>  
115.                   <source>1.6</source>  
116.                   <target>1.6</target>  
117.               </configuration>  
118.            </plugin>  
119.      </plugins>  
120. </build>  
121. </project>  

7.编写如下代码后点击右键run as ->  java application，就可以运行了。

[java]  view plain  copy

1. import java.util.Arrays;  
2. import org.apache.spark.SparkConf;  
3. import org.apache.spark.api.java.JavaPairRDD;  
4. import org.apache.spark.api.java.JavaRDD;  
5. import org.apache.spark.api.java.JavaSparkContext;  
6. import org.apache.spark.api.java.function.FlatMapFunction;  
7. import org.apache.spark.api.java.function.Function2;  
8. import org.apache.spark.api.java.function.PairFunction;  
9. import org.apache.spark.api.java.function.VoidFunction;  
10. import scala.Tuple2;  
11.   
12. /** 
13.  * 使用Java的方式开发进行本地测试Spark的WordCount程序 
14.  *  
15.  * @author DT大数据梦工厂 http://weibo.com/ilovepains 
16.  */  
17. public class App {  
18.     public static void main(String[] args) {  
19.         /** 
20.          * 第1步：创建Spark的配置对象SparkConf，设置Spark程序的运行时的配置信息， 
21.          * 例如说通过setMaster来设置程序要链接的Spark集群的Master的URL,如果设置 
22.          * 为local，则代表Spark程序在本地运行，特别适合于机器配置条件非常差（例如 只有1G的内存）的初学者 * 
23.          */  
24.         SparkConf conf = new SparkConf().setAppName("Spark WordCount written by Java").setMaster("local");  
25.         /** 
26.          * 第2步：创建SparkContext对象 
27.          * SparkContext是Spark程序所有功能的唯一入口，无论是采用Scala、Java、Python 
28.          * 、R等都必须有一个SparkContext(不同的语言具体的类名称不同，如果是Java的话则为JavaSparkContext) 
29.          * SparkContext核心作用：初始化Spark应用程序运行所需要的核心组件，包括DAGScheduler、TaskScheduler、 
30.          * SchedulerBackend 同时还会负责Spark程序往Master注册程序等 
31.          * SparkContext是整个Spark应用程序中最为至关重要的一个对象 
32.          */  
33.         JavaSparkContext sc = new JavaSparkContext(conf); // 其底层实际上就是Scala的SparkContext  
34.         /** 
35.          * 第3步：根据具体的数据来源（HDFS、HBase、Local FS、DB、S3等）通过JavaSparkContext来创建JavaRDD 
36.          * JavaRDD的创建基本有三种方式：根据外部的数据来源（例如HDFS）、根据Scala集合、由其它的RDD操作 
37.          * 数据会被RDD划分成为一系列的Partitions，分配到每个Partition的数据属于一个Task的处理范畴 
38.          * 注意：文件路径不能直接用Windows路径中的反斜扛\，要改成Linux下的斜扛/ 
39.          */  
40.         JavaRDD<String> lines = sc  
41.                 .textFile("D:/hu.txt");  
42.         /** 
43.          * 第4步：对初始的JavaRDD进行Transformation级别的处理，例如map、filter等高阶函数等的编程，来进行具体的数据计算 
44.          * 第4.1步：讲每一行的字符串拆分成单个的单词 
45.          */  
46.         JavaRDD<String> words = lines  
47.                 .flatMap(new FlatMapFunction<String, String>() { // 如果是Scala，由于SAM转换，所以可以写成val  
48.                                                                     // words =  
49.                                                                     // lines.flatMap  
50.                                                                     // { line =>  
51.                                                                     // line.split(" ")}  
52.                     public Iterable<String> call(String line) throws Exception {  
53.                         return Arrays.asList(line.split(" "));  
54.                     }  
55.                 });  
56.         /** 
57.          * 第4步：对初始的JavaRDD进行Transformation级别的处理，例如map、filter等高阶函数等的编程，来进行具体的数据计算 
58.          * 第4.2步：在单词拆分的基础上对每个单词实例计数为1，也就是word => (word, 1) 
59.          */  
60.         JavaPairRDD<String, Integer> pairs = words  
61.                 .mapToPair(new PairFunction<String, String, Integer>() {  
62.                     public Tuple2<String, Integer> call(String word)  
63.                             throws Exception {  
64.                         return new Tuple2<String, Integer>(word, 1);  
65.                     }  
66.                 });  
67.         /** 
68.          * 第4步：对初始的RDD进行Transformation级别的处理，例如map、filter等高阶函数等的编程，来进行具体的数据计算 
69.          * 第4.3步：在每个单词实例计数为1基础之上统计每个单词在文件中出现的总次数 
70.          */  
71.         JavaPairRDD<String, Integer> wordsCount = pairs  
72.                 .reduceByKey(new Function2<Integer, Integer, Integer>() { // 对相同的Key，进行Value的累计（包括Local和Reducer级别同时Reduce）  
73.                     public Integer call(Integer v1, Integer v2)  
74.                             throws Exception {  
75.                         return v1 + v2;  
76.                     }  
77.                 });  
78.         wordsCount.foreach(new VoidFunction<Tuple2<String, Integer>>() {  
79.             public void call(Tuple2<String, Integer> pairs) throws Exception {  
80.                 System.out.println(pairs._1 + " : " + pairs._2);  
81.             }  
82.         });  
83.         sc.close();  
84.     }  
85. }