Spark第一个程序开发----WordCount

Spark第一个程序开发WordCount

Java版本

package cn.spark.java.core;

import java.util.Arrays;
import java.util.Iterator;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.api.java.function.VoidFunction;
import scala.Tuple2;

/**
 * zgf
 * java本地测试WordCount程序
 */

public class WordCountJavaLocal {
    public static void main(String[] args) {
        //编写spark程序
        //本地执行
        
        //第一步，创建SparkConf对象，设置spark应用的配置信息
        SparkConf conf = new SparkConf()
                .setAppName("WordCountJavaLocal")
                //设置Master()，可以设置spark程序要连接的spark集群的master节点的url
                //val conf = new SparkConf().setAppName("WordCount").setMaster("spark://master:7077")  // 运行在集群中
                //若果设置成local则代表在本地运行
                .setMaster("local");
                
        //第二步，设置JavaSparkContext对象
        /*
        SparkContext 是spark程序的所有功能的入口，（java，scala，Python）都需要SparkContext，
        他的主要作用是，包括初始化一些spark程序的核心组件，（调度器DAGScheduler,taskScheduler）;
        还会到spark的master节点上进行注册。。。。
        通过传入SparkConf实例来定制Spark运行的具体参数和配置信息
         -java（JavaSparkContext）-scala(原生SparkContext) -sql(SQLContext,HiveContext) -Streaming(原生)
         */
        JavaSparkContext sc = new JavaSparkContext(conf);
        
        /*
        第三步
         根据具体的数据来源(HDFS、 HBase、Local FS、DB、 S3等)通过SparkContext来创建RDD
      RDD 的创建基本有三种方式： 根据外部的数据来源(例如HDFS)、根据Scala集合使用SparkContext的parallelize方法、
       由其他的RDD操作产生
       数据会被RDD划分成为一系列的Partitions，分配到每个Partition的数据属于一个Task的处理范畴
        输入源（hdfs，本地、、），创建一个初始 的RDD
        输入源中的数据会被打散，分配到RDD的每一个partition中，从而形成初始的RDD
        SparkContext中，用于根据文件类型的输入源创建的RDD的方法，叫做textFile()
        java中，创建普通的rdd,都是JavaRDD
         */
        JavaRDD<String> lines = sc.textFile("C://test001.txt");
        
        /*
        第四步，对初始的RDD进行transformation操作，计算操作
        将每一行拆成单词
        */
        JavaRDD<String> words = lines.flatMap(new FlatMapFunction<String, String>() {

            private static final long serialVersionUID = 1L;

            public Iterator<String> call(String line) throws Exception {

                return Arrays.asList(line.split(" ")).iterator();

            }
        });

        /*
        将单词映射为(单词，1)的格式
        只有这样才能操作后面的reduceBykey,将单词的出现个数累加
        mapTopair是将每个单词元素映射为（v1,v2）的tuple2类型的元素
        tuple2就是scala类型
        mapToPair算子，需要配合PairFunction使用，第一个参数泛型是输入类型
        第二个，第三个参数是输出Tuple2类型
        */

        JavaPairRDD<String, Integer> pairs = words.mapToPair(new PairFunction<String, String, Integer>() {


            private static final long serialVersionUID = 1L;

            public Tuple2<String, Integer> call(String word) throws Exception {
                return new Tuple2<String, Integer>(word, 1);
            }
        });
       /*
       以单词作为key,统计单词出现的次数
       reduceByKey算子，对每个key对应的value，都进行reduce操作
      （hello，1）（world,1）(hello,1)（hello，1）....
       例：hello：首先，1+1+2；然后在2+1=3
       最后返回JavaPairRDD的元素，也是tuple,(key,value)
        */
        JavaPairRDD<String, Integer> wordCounts = pairs.reduceByKey(new Function2<Integer, Integer, Integer>() {

            private static final long serialVersionUID = 1L;

            public Integer call(Integer v1, Integer v2) throws Exception {

                return v1 + v2;

            }
        });
        /*
        action操作（一个程序只有transformation操作（flatmap,mapTopair,reduceBykey）是不会执行的）
        foreach操作来触发程序执行
         */
        wordCounts.foreach(new VoidFunction<Tuple2<String, Integer>>() {

            private static final long serialVersionUID = 1L;

            public void call(Tuple2<String, Integer> wordCount) throws Exception {
                System.out.println(wordCount._1 + "------" + wordCount._2 + "times.");
            }
        });
        sc.close();

    }
}

Scala版本

package SparkStudy

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

/**
  * @author: zgf
  * scala 测试WordCount程序
  */
object WordCount {
  def main(args: Array[String]): Unit = {
    //设置Spark配置
    val conf: SparkConf = new SparkConf().setAppName("WordCount") //.setMaster("local[*]")
    //创建Spark上下文
    val sc: SparkContext = new SparkContext(conf)
    //读取输入数据
    val lines = sc.textFile(args(0))
    //处理数据
    val words: RDD[String] = lines.flatMap(_.split(" ")).filter(word => word != " ")//拆分单词，并过滤掉空格，当然还可以继续进行过滤，如去掉标点符号
    val pair: RDD[(String, Int)] = words.map((_, 1)) // 在单词拆分的基础上对每个单词实例计数为1, 也就是 word => (word, 1)
    val reduced: RDD[(String, Int)] = pair.reduceByKey(_ + _)  // 在每个单词实例计数为1的基础之上统计每个单词在文件中出现的总次数, 即key相同的value相加
//  val wordscount = pairs.reduceByKey((v1, v2) => v1 + v2)  
    val ans = reduced.sortBy(_._2, false)

    ans.saveAsTextFile(args(1))
    //    println(ans.collect().toBuffer)

    //关闭释放资源
    sc.stop()
  }
}

scala的简洁强大啊！！！！！

程序集群提交

如果运行在集群中，需要将程序打包成jar包，使用spark提供的spark-submit提交到集群

spark-submit --class SparkStudy.WordCount --master spark://master:7077 --executor-memory 1g --total-executor-cores 2 /root/bigdata/sparkdemo/SparkDemo-1.0-SNAPSHOT.jar hdfs://master:8020/test001.txt hdfs://master:8020/output

- - 参数名	参数说明
–class	应用程序的主入口类，仅针对 java 或 scala 应用
–master	master 的地址，集群的master URL，例如 spark://host:port, yarn, local
–executor-memory	每个 executor 的内存，默认是1G
–executor-core	每个 executor 的核数。在yarn或者standalone下使用