五种WordCound

 

一、MR的WordCound

public class MyWordCount {
	/**
//1、map阶段
	 * @author lyd
	 */
	public static class MyMapper extends Mapper<LongWritable, Text, Text,IntWritable>{
		public Text k = new Text();
		public IntWritable v = new IntWritable(1);
		/**
		 * map()函数：每一行数据执行一次map()函数
		 */
		@Override
		protected void map(LongWritable key, Text value,Context context)
				throws IOException, InterruptedException {
			//1、获取每一行的文本数据
			String line = value.toString();
			//2、将每行数据进行切割
			String[] words = line.split(" ");
			/*for (String s : words) {
				k.set(s);
				v.set(1);
				//输出
				context.write(k, v);
			}*/
   StringTokenizer st = new StringTokenizer(line);
			     while (st.hasMoreTokens()) {
			     	k.set(st.nextToken());
				//输出
				context.write(v, k);
			     }			
		}
	}
	/**
//2、reduce阶段
	 * @author lyd
	 */
	public static class MyReducer extends Reducer<Text, IntWritable, Text, IntWritable>{
		/**
		 * reduce()函数：map阶段输出的一个key就执行一次reduce()函数
 * Interable是一个迭代器，也就是一个容器
		 */
		@Override
		protected void reduce(Text key, Iterable<IntWritable> value,Context context)
				throws IOException, InterruptedException {
			//定义一个计数器
			int count = 0;
			for (IntWritable i : value) {
				count += i.get();
			}
			//输出
			context.write(key, new IntWritable(count));
		}		
	}
	/**
//3、驱动方法
    * 驱动方法是为job配置一些信息，告诉作业输入输出
	 */
	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
		//1、获取配置对象，从hadoop配置文件中读取参数
		Configuration conf = new Configuration();

		//2、为conf对象设置值
		//	可以暂时不设置，设置比如job的属性，job用几个reduce等。

		//3、获取作业对象，作业的名字可以自己随意起，new job是一个过时的方法。
		Job job = Job.getInstance(conf, "wordcount"); //new Job(conf, "wordcount");

		//4、为作业设置运行主类
		job.setJarByClass(MyWordCount.class);

		//5、设置map端的属性
//Map阶段的输入，数据必须在hdfs上面，如果在本地做MR，那么必须去改配置文件
//new Path里传入的是数据在hdfs上的路径，
FileInputFormat.setInputPaths(job, new Path(args[0]));
		job.setMapperClass(MyMapper.class);
		job.setMapOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);

		//6、设置reduce阶段属性
		job.setReducerClass(MyReducer.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);
		FileOutputFormat.setOutputPath(job, new Path(args[1]));

		//7、提交作业并打印信息
		int isok = job.waitForCompletion(true) ? 0 : 1;
		System.exit(isok);  //退出
	}
}

二、Scala的WorkCount

 

object ScalaWC {
  def main(args: Array[String]): Unit = {
    val lines = List("hello tom hello jerry", "hello suke hello", " hello tom")

    // 把数据切分并压平
    val words: List[String] = lines.flatMap(_.split(" "))

    // 过滤空格
    val filtered: List[String] = words.filter(_ != "")

    // 生成一个个元组：(word, 1)
    val tuples: List[(String, Int)] = filtered.map((_, 1))

    // 以key进行分组
    val grouped: Map[String, List[(String, Int)]] = tuples.groupBy(x => x._1)

    // 开始统计分组后相同单词的个数，其实只需要统计单词对应的list的长度就可以
//    val sumed: Map[String, Int] = grouped.map(x => (x._1, x._2.size))
    val sumed: Map[String, Int] = grouped.mapValues(_.size)

    // 降序排序
    val sorted: List[(String, Int)] = sumed.toList.sortBy(_._2).reverse

    println(sorted)
  }
}

 

三、Spark的WordCount

object SparkWC {
  def main(args: Array[String]): Unit = {
    // 创建配置文件信息类，
    // setAppName：设置应用程序名称
    // setMaster：设置为本地模式运行
    // local：用一个线程模拟集群运行程序
    // local[2]：用两个线程模拟集群运行程序
    // local[*]：用所有的空闲线程模拟集群运行程序
    val conf: SparkConf = new SparkConf()
      .setAppName("SparkWC")
//      .setMaster("local[*]")

    // 创建Spark上下文对象，也称为集群的入口类
    val sc: SparkContext = new SparkContext(conf)

    // 读取数据
    val lines: RDD[String] = sc.textFile(args(0))

    // 将数据切分并压平
    val words: RDD[String] = lines.flatMap(_.split(" "))
    // 将一个个单词生成一个个tuple
    val tuples: RDD[(String, Int)] = words.map((_, 1))
    // 将元组以key开进行聚合
    val reduced: RDD[(String, Int)] = tuples.reduceByKey(_+_)
    // 将聚合后的数据进行降序排序
    val sorted: RDD[(String, Int)] = reduced.sortBy(_._2, false, 1)
    println(sorted.collect.toBuffer)
    sorted.saveAsTextFile(args(1))
    sc.stop()
  }
}

 

四、Java的WordCount

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 scala.Tuple2;

import java.util.Arrays;

public class JavaWC {
    public static void main(String[] args) {
        // 创建配置文件信息类
        SparkConf conf = new SparkConf()
                .setAppName("JavaWC")
                .setMaster("local[2]");
        // 创建上下文对象
        JavaSparkContext jsc = new JavaSparkContext(conf);

        // 获取数据
        JavaRDD<String> lines = jsc.textFile(args[0]);

        // 切分数据
        JavaRDD<String> words = lines.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public Iterable<String> call(String s) throws Exception {
                return Arrays.asList(s.split(" "));
            }
        });
        // 把切分后的数据生成元组
        JavaPairRDD<String, Integer> tuples = words.mapToPair(new PairFunction<String, String, Integer>() {
            @Override
            public Tuple2<String, Integer> call(String s) throws Exception {
                return new Tuple2<String, Integer>(s, 1);
            }
        });
        // 聚合
        final JavaPairRDD<String, Integer> reduced = tuples.reduceByKey(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        });
        // Java接口中没有提供sortBy算子，如果需要以value进行排序时，
        // 需要把数据反转一下,排序完成后，再反转回来
        JavaPairRDD<Integer, String> swaped = reduced.mapToPair(new PairFunction<Tuple2<String, Integer>, Integer, String>() {
            @Override
            public Tuple2<Integer, String> call(Tuple2<String, Integer> tup) throws Exception {
//                return new Tuple2<Integer, String>(tup._2, tup._1);
            }
        });
        // 降序排序
        JavaPairRDD<Integer, String> sorted = swaped.sortByKey(false);

        // 把排序后的数据再反转回来
        JavaPairRDD<String, Integer> result = sorted.mapToPair(new PairFunction<Tuple2<Integer, String>, String, Integer>() {
            @Override
            public Tuple2<String, Integer> call(Tuple2<Integer, String> tup) throws Exception {
                return tup.swap();
            }
        });
        System.out.println(result.collect());
        result.saveAsTextFile(args[1])
        jsc.stop();
    }
}

五、SparkStreaming的WordCound

object SparkStreamingWC {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setAppName("SparkStreamingWC").setMaster("local[2]")
    val sc = new SparkContext(conf)
    // 创建SparkStreaming的上下文
    val ssc: StreamingContext = new StreamingContext(sc, Seconds(5))

    // 从NetCat服务端获取数据
    val dStream: ReceiverInputDStream[String] = ssc.socketTextStream("node01", 6666)

    // 数据分析
    val res: DStream[(String, Int)] =
      dStream.flatMap(_.split(" ")).map((_, 1)).reduceByKey(_+_)

    res.print()

    // 提交任务到集群
    ssc.start()

    // 线程等待，等待处理下一批次任务
    ssc.awaitTermination()
  }
}