一、下载依赖jar包

具体可以参考：SparkStreaming整合kafka编程

二、创建Java工程

太简单，略。

三、实际例子

spark的安装包里面有好多例子，具体路径：spark-2.1.1-bin-hadoop2.7\examples。

JavaDirectKafkaWordCount.java

  1. package com.spark.test;
  2. import java.util.HashMap;
  3. import java.util.HashSet;
  4. import java.util.Arrays;
  5. import java.util.Iterator;
  6. import java.util.Map;
  7. import java.util.Set;
  8. import java.util.regex.Pattern;
  9. import scala.Tuple2;
  10. import kafka.serializer.StringDecoder;
  11. import org.apache.spark.SparkConf;
  12. import org.apache.spark.api.java.function.*;
  13. import org.apache.spark.streaming.api.java.*;
  14. import org.apache.spark.streaming.kafka.KafkaUtils;
  15. import org.apache.spark.streaming.Durations;
  16. public class JavaDirectKafkaWordCount {
  17. public static void main(String[] args) throws Exception {
  18. //String brokers = args[0];
  19. // String topics = args[1];
  20. // Create context with a 2 seconds batch interval
  21. /**
  22. * setMaster("local[2]")，至少要指定两个线程，一条用于用于接收消息，一条线程用于处理消息
  23. */
  24. SparkConf sparkConf = new SparkConf().setAppName("JavaDirectKafkaWordCount").setMaster("local[2]");
  25. JavaStreamingContext jssc = new JavaStreamingContext(sparkConf, Durations.seconds(2));
  26. Set<String> topicsSet = new HashSet<>(Arrays.asList("test"));
  27. Map<String, String> kafkaParams = new HashMap<>();
  28. kafkaParams.put("metadata.broker.list", "192.168.168.200:9092");
  29. // Create direct kafka stream with brokers and topics
  30. JavaPairInputDStream<String, String> messages = KafkaUtils.createDirectStream(
  31. jssc,
  32. String.class,
  33. String.class,
  34. StringDecoder.class,
  35. StringDecoder.class,
  36. kafkaParams,
  37. topicsSet
  38. );
  39. // Get the lines, split them into words, count the words and print
  40. JavaDStream<String> lines = messages.map(new Function<Tuple2<String, String>, String>() {
  41. @Override
  42. public String call(Tuple2<String, String> tuple2) {
  43. return tuple2._2();
  44. }
  45. });
  46. JavaDStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() {
  47. @Override
  48. public Iterator<String> call(String line) {
  49. return Arrays.asList(line.split(" ")).iterator();
  50. }
  51. });
  52. JavaPairDStream<String, Integer> wordCounts = words.mapToPair(
  53. new PairFunction<String, String, Integer>() {
  54. @Override
  55. public Tuple2<String, Integer> call(String s) {
  56. return new Tuple2<>(s, 1);
  57. }
  58. }).reduceByKey(
  59. new Function2<Integer, Integer, Integer>() {
  60. @Override
  61. public Integer call(Integer i1, Integer i2) {
  62. return i1 + i2;
  63. }
  64. });
  65. wordCounts.print();
  66. // Start the computation
  67. jssc.start();
  68. jssc.awaitTermination();
  69. }
  70. }

JavaKafkaWordCount.java

  1. package com.spark.test;
  2. import java.util.Arrays;
  3. import java.util.Iterator;
  4. import java.util.Map;
  5. import java.util.HashMap;
  6. import java.util.regex.Pattern;
  7. import scala.Tuple2;
  8. import org.apache.spark.SparkConf;
  9. import org.apache.spark.api.java.function.FlatMapFunction;
  10. import org.apache.spark.api.java.function.Function;
  11. import org.apache.spark.api.java.function.Function2;
  12. import org.apache.spark.api.java.function.PairFunction;
  13. import org.apache.spark.streaming.Duration;
  14. import org.apache.spark.streaming.api.java.JavaDStream;
  15. import org.apache.spark.streaming.api.java.JavaPairDStream;
  16. import org.apache.spark.streaming.api.java.JavaPairReceiverInputDStream;
  17. import org.apache.spark.streaming.api.java.JavaStreamingContext;
  18. import org.apache.spark.streaming.kafka.KafkaUtils;
  19. public class JavaKafkaWordCount{
  20. public static void main(String[] args) throws InterruptedException {
  21. SparkConf sparkConf = new SparkConf().setAppName("JavaKafkaWordCount").setMaster("local[2]");
  22. // Create the context with 2 seconds batch size
  23. JavaStreamingContext jssc = new JavaStreamingContext(sparkConf, new Duration(2000));
  24. int numThreads = Integer.parseInt("2");
  25. Map<String, Integer> topicMap = new HashMap<>();
  26. String[] topics = "test".split(",");
  27. for (String topic: topics) {
  28. topicMap.put(topic, numThreads);
  29. }
  30. JavaPairReceiverInputDStream<String, String> messages =
  31. KafkaUtils.createStream(jssc, "192.168.168.200:2181", "test-group", topicMap);
  32. JavaDStream<String> lines = messages.map(new Function<Tuple2<String, String>, String>() {
  33. @Override
  34. public String call(Tuple2<String, String> tuple2) {
  35. return tuple2._2();
  36. }
  37. });
  38. JavaDStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() {
  39. @Override
  40. public Iterator<String> call(String line) {
  41. return Arrays.asList(line.split(" ")).iterator();
  42. }
  43. });
  44. JavaPairDStream<String, Integer> wordCounts = words.mapToPair(
  45. new PairFunction<String, String, Integer>() {
  46. @Override
  47. public Tuple2<String, Integer> call(String s) {
  48. return new Tuple2<>(s, 1);
  49. }
  50. }).reduceByKey(new Function2<Integer, Integer, Integer>() {
  51. @Override
  52. public Integer call(Integer i1, Integer i2) {
  53. return i1 + i2;
  54. }
  55. });
  56. wordCounts.print();
  57. jssc.start();
  58. jssc.awaitTermination();
  59. }
  60. }

JavaLocalWordCount.java

  1. package com.spark.test;
  2. import java.util.Arrays;
  3. import java.util.Iterator;
  4. import org.apache.spark.SparkConf;
  5. import org.apache.spark.api.java.JavaPairRDD;
  6. import org.apache.spark.api.java.JavaRDD;
  7. import org.apache.spark.api.java.JavaSparkContext;
  8. import org.apache.spark.api.java.function.FlatMapFunction;
  9. import org.apache.spark.api.java.function.Function2;
  10. import org.apache.spark.api.java.function.PairFunction;
  11. import org.apache.spark.api.java.function.VoidFunction;
  12. import scala.Tuple2;
  13. public class JavaLocalWordCount {
  14. public static void main(String[] args) {
  15. /**
  16. * 第一步，创建Spark的配置对象SparkConf，设置Spark程序的运行时的配置信息，
  17. * 例如说通过setMaster来设置程序要链接的Spark集群的Master的URL，
  18. * 如果设置为local，则代表Spark程序在本地运行，特别适合于机器配置较差的情况
  19. */
  20. SparkConf sparkConf = new SparkConf().setAppName("LocalWordCountByJava").setMaster("local");
  21. /**
  22. * 第二步，创建SparkContext对象
  23. * SparkContext是Spark程序所有功能的唯一入口，无论是采用Scala，java，python，R等都
  24. * 必须有一个SparkContext（不同语言具体类名称不同，如果是Java的话，则为JavaSparkContext）
  25. * 同时还会负责Spark程序在Master注册程序等
  26. * SparkContext是整个Spark应用程序至关重要的一个对象
  27. */
  28. JavaSparkContext jsc = new JavaSparkContext(sparkConf);//其底层实际上是Scala的SparkContext
  29. /**
  30. * 第三步，根据具体的数据来源（HDFS，HBase，Local，FS，DB，S3等），通过JavaSparkContext来创建JavaRDD
  31. * JavaRDD的创建方式有三种：根据外部数据来源（例如HDFS），
  32. * 根据Scala集合，由其他的RDD操作数据会将RDD划分成一系列Partition，
  33. * 分配到每个Partition的数据属于一个Task处理范畴
  34. */
  35. JavaRDD<String> lines = jsc.textFile("words.txt");
  36. //如果是Scala，由于SAM转化，所以可以写成val words=lines.flatMap{line =>line.split(" ")}
  37. JavaRDD<String> words = lines.flatMap(new FlatMapFunction<String, String>() {
  38. @Override
  39. public Iterator<String> call(String line) {
  40. return Arrays.asList(line.split(" ")).iterator();
  41. }
  42. });
  43. /**
  44. * 第4步：对初始的JavaRDD进行Transformation级别的处理，例如map，filter等高阶函数等的编程，来进行具体的数据计算
  45. * 第4.1步：在单词拆分的基础上对每个单词实例进行计数为1，也就是word =>(word,1)
  46. */
  47. JavaPairRDD<String, Integer> pairs = words.mapToPair(new PairFunction<String, String, Integer>() {
  48. public Tuple2<String, Integer> call(String word) throws Exception{
  49. return new Tuple2<String, Integer>(word, 1);
  50. }
  51. });
  52. /**
  53. * 统计总次数
  54. */
  55. JavaPairRDD<String,Integer> wordCount=pairs.reduceByKey(new Function2<Integer,Integer,Integer>()
  56. {
  57. public Integer call(Integer v1,Integer v2)throws Exception
  58. {
  59. return v1+v2;
  60. }
  61. });
  62. wordCount.foreach(new VoidFunction<Tuple2<String,Integer>>(){
  63. public void call(Tuple2<String,Integer> pairs) throws Exception {
  64. System.out.println(pairs._1()+":"+pairs._2());
  65. }
  66. });
  67. jsc.close();
  68. }
  69. }

JavaClusterWordCount.java

  1. package com.spark.test;
  2. import java.util.Arrays;
  3. import java.util.Iterator;
  4. import org.apache.spark.SparkConf;
  5. import org.apache.spark.api.java.JavaPairRDD;
  6. import org.apache.spark.api.java.JavaRDD;
  7. import org.apache.spark.api.java.JavaSparkContext;
  8. import org.apache.spark.api.java.function.FlatMapFunction;
  9. import org.apache.spark.api.java.function.Function2;
  10. import org.apache.spark.api.java.function.PairFunction;
  11. import org.apache.spark.api.java.function.VoidFunction;
  12. import scala.Tuple2;
  13. public class JavaClusterWordCount {
  14. public static void main(String[] args) {
  15. /**
  16. * 第一步，创建Spark的配置对象SparkConf，设置Spark程序的运行时的配置信息，
  17. * 例如说通过setMaster来设置程序要链接的Spark集群的Master的URL，
  18. * 如果设置为local，则代表Spark程序在本地运行，特别适合于机器配置较差的情况
  19. */
  20. SparkConf sparkConf = new SparkConf().setAppName("LocalWordCountByJava").setMaster("local");
  21. /**
  22. * 第二步，创建SparkContext对象
  23. * SparkContext是Spark程序所有功能的唯一入口，无论是采用Scala，java，python，R等都
  24. * 必须有一个SparkContext（不同语言具体类名称不同，如果是Java的话，则为JavaSparkContext）
  25. * 同时还会负责Spark程序在Master注册程序等
  26. * SparkContext是整个Spark应用程序至关重要的一个对象
  27. */
  28. JavaSparkContext jsc = new JavaSparkContext(sparkConf);//其底层实际上是Scala的SparkContext
  29. /**
  30. * 第三步，根据具体的数据来源（HDFS，HBase，Local，FS，DB，S3等），通过JavaSparkContext来创建JavaRDD
  31. * JavaRDD的创建方式有三种：根据外部数据来源（例如HDFS），
  32. * 根据Scala集合，由其他的RDD操作数据会将RDD划分成一系列Partition，
  33. * 分配到每个Partition的数据属于一个Task处理范畴
  34. */
  35. JavaRDD<String> lines = jsc.textFile("hdfs://192.168.168.200:9000/input/words.txt");
  36. //如果是Scala，由于SAM转化，所以可以写成val words=lines.flatMap{line =>line.split(" ")}
  37. JavaRDD<String> words = lines.flatMap(new FlatMapFunction<String, String>() {
  38. @Override
  39. public Iterator<String> call(String line) {
  40. return Arrays.asList(line.split(" ")).iterator();
  41. }
  42. });
  43. /**
  44. * 第4步：对初始的JavaRDD进行Transformation级别的处理，例如map，filter等高阶函数等的编程，来进行具体的数据计算
  45. * 第4.1步：在单词拆分的基础上对每个单词实例进行计数为1，也就是word =>(word,1)
  46. */
  47. JavaPairRDD<String, Integer> pairs = words.mapToPair(new PairFunction<String, String, Integer>() {
  48. public Tuple2<String, Integer> call(String word) throws Exception{
  49. return new Tuple2<String, Integer>(word, 1);
  50. }
  51. });
  52. /**
  53. * 统计总次数
  54. */
  55. JavaPairRDD<String,Integer> wordCount=pairs.reduceByKey(new Function2<Integer,Integer,Integer>()
  56. {
  57. public Integer call(Integer v1,Integer v2)throws Exception
  58. {
  59. return v1+v2;
  60. }
  61. });
  62. wordCount.foreach(new VoidFunction<Tuple2<String,Integer>>(){
  63. public void call(Tuple2<String,Integer> pairs) throws Exception {
  64. System.out.println(pairs._1()+":"+pairs._2());
  65. }
  66. });
  67. jsc.close();
  68. }
  69. }

基于Java+SparkStreaming整合kafka编程的更多相关文章

  1. SparkStreaming整合kafka编程

    1.下载spark-streaming-kafka插件包 由于Linux集群环境我使用spark是spark-2.1.1-bin-hadoop2.7,kafka是kafka_2.11-0.8.2.1, ...

  2. 大数据学习day32-----spark12-----1. sparkstreaming（1.1简介，1.2 sparkstreaming入门程序（统计单词个数，updateStageByKey的用法，1.3 SparkStreaming整合Kafka，1.4 SparkStreaming获取KafkaRDD的偏移量，并将偏移量写入kafka中）

    1. Spark Streaming 1.1 简介(来源:spark官网介绍) Spark Streaming是Spark Core API的扩展,其是支持可伸缩.高吞吐量.容错的实时数据流处理.Sp ...

  3. 基于java的简单Socket编程

    1TCP协议与UDP协议     1.1 TCP               TCP是(Tranfer Control Protocol)的简称,是一种面向连接的保证可靠传输的协议.通过TCP协议传输 ...

  4. SparkStreaming 整合kafka Demo

    这里使用的是低级API,因为高级API非常不好用,需要繁琐的配置,也不够自动化,却和低级API的效果一样,所以这里以低级API做演示 你得有zookeeper和kafka 我这里是3台节点主机 架构图 ...

  5. 大数据学习——SparkStreaming整合Kafka完成网站点击流实时统计

    1.安装并配置zk 2.安装并配置Kafka 3.启动zk 4.启动Kafka 5.创建topic [root@mini3 kafka]# bin/kafka-console-producer. -- ...

  6. scala spark-streaming整合kafka （spark 2.3 kafka 0.10）

    Maven组件如下: ) { System.err.println() } StreamingExamples.setStreamingLogLevels() )) ) { System.) } )) ...

  7. Spark之 Spark Streaming整合kafka（并演示reduceByKeyAndWindow、updateStateByKey算子使用）

    Kafka0.8版本基于receiver接受器去接受kafka topic中的数据(并演示reduceByKeyAndWindow的使用) 依赖 <dependency> <grou ...

  8. 【Spark】SparkStreaming和Kafka的整合

    文章目录 Streaming和Kafka整合 概述 使用0.8版本下Receiver DStream接收数据进行消费 步骤 一.启动Kafka集群 二.创建maven工程,导入jar包 三.创建一个k ...

  9. SparkStreaming和Kafka基于Direct Approach如何管理offset实现exactly once

    在之前的文章<解析SparkStreaming和Kafka集成的两种方式>中已详细介绍SparkStreaming和Kafka集成主要有Receiver based Approach和Di ...

随机推荐

  1. 制作Wi-Fi Ducky远程HID攻击设备

    1.介绍WIFI DUCKY 它是一个Wi-Fi控制的BadUSB设备来远程执行Ducky Scripts. 使用充当键盘的USB设备来注入攻击,Hak5 的 USB Rubber Ducky 是这种 ...

  2. 50_流程控制函数-case结构

    case函数的使用一:switch case 的效果 /* Java中 switch(变量或表达式){ case 常量1:语句1:break: ... default:语句n;break; } MyS ...

  3. 2019-03-08-day007-深浅拷贝

    01 昨日内容回顾 is 两者之间的id是否相同 == 两边的数值是否相等 id 获取该对象的内存地址 代码块: 一个文件,交互式命令行:一行是个一个代码块. 同一代码块下: 字符串的缓存机制,驻留机 ...

  4. box-sizing布局

    box-sizing 语法:box-sizing: content-box | border-box | inherit; 参考: https://www.jianshu.com/p/e2eb0d8c ...

  5. JavaScript中的函数-7---函数的作用,定义,调用

    JavaScript中的函数 函数也是对象,并且是javascript中的一等公民,可以用来创建普通对象.对象只是属性和值的集合 学习目标 1.掌握函数的作用 2.掌握函数的定义 3.掌握函数的调用 ...

  6. 数据文件resize扩容

    表空间不足 Alert日志报错 Mon Dec :: GMT+: Incremental checkpoint up to RBA[ox1af2d.3ddll.], current log tail ...

  7. JAVA基础部分复习(六、常用关键字说明)

    /** * JAVA中常用关键字复习 * final * finalize * finally * * @author dyq * */ public class KeyWordReview exte ...

  8. javascript的this多种场景用法

    作者:刘志祥 时间:2017.11.10 参考:阮一峰的官方网站 this 是javaScript中的一个关键字,只能在函数内使用.随着场合的不同,this的值会发生变化. 1. 单纯的全局函数调用, ...

  9. php基础-3

    php的数据类型 字符串 字符串的声明:$str = "aaa"; 字符串的方法 strpos(str, find_str):该方法在一个字符串中查找需要查找的字符串,并回来该字符 ...

  10. eventEmitter

    wade-mac:fin_server_invest mac$ node > var events =require('events') undefined > var eventEmit ...