一、下载依赖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. Day11作业及默写

    1.写函数,传入n个数,返回字典{'max':最大值,'min':最小值} 例如:min_max(2,5,7,8,4) 返回:{'max':8,'min':2}(此题用到max(),min()内置函数 ...

  2. awk入门及进阶

    awk是Linux下优良的文本处理工具,有自成一体的编程语法规则,在循环和条件判断语句等方面和C语言很像. 其一般形式是:Pattern1 {ACTIONS; } Pattern2 { ACTIONS ...

  3. JavaScript中的内置对象-8--4.date对象中-获取,设置日期时间的方法; 获取,设置年月日时分秒及星期的方法;

    学习目标 1.掌握创建日期对象的方法 2.掌握date对象中获取日期时间的方法 3.掌握date对象中设置日期时间的方法 如何创建一个日期对象 语法:new Date(); 功能:创建一个日期时间对象 ...

  4. bash & vi

    更高效的使用. 选中全文 ggVG 文件头:gg,文档尾:G redo: CTRL+r 折叠代码/打开折叠: zf ,进行折叠 zo, 打开折叠 zc,关闭折叠 跳到匹配{或}处: % 标记当前单词: ...

  5. INS-20802 Oracle Cluster Verification Utility failed解释说明

    背景:安装RAC,安装GI集群管理软件时,在最后快结束时,总是报如上INS-错误 #官方文档:error 说明;字符串解析失败 INS-20802: string failed. Cause: The ...

  6. php curl 传输是url中带有空格的处理方法

    在crul中,应该用%20代替空格,否则,空格以后的数据将get不到.

  7. Unity3D 重写下拉菜单/Dropdown组件、开启每个按钮可用

    Override Dropdown Component 本文提供全流程,中文翻译. Chinar 坚持将简单的生活方式,带给世人!(拥有更好的阅读体验 -- 高分辨率用户请根据需求调整网页缩放比例) ...

  8. C语言常用命令

    ## 基本流程:创建——编辑——编译.链接——执行$ touch 1-1.c$ vim 1-1.c # include <stdio.h>int main{printf("... ...

  9. 开发工具-Eclipse

    1.Eclipse的视窗和视图概述 - A:视窗 每一个基本的窗体被称为视窗  * PackageExplorer 显示项目结构,包,类,及资源   * Outline 显示类的结构,方便查找,识别, ...

  10. C++学习（十六）（C语言部分）之 数组三

    复习 以及 测试 /* 一维数组 数组是相同的数据的一个集合 <类型><数组名>[下标表达式]={数组元素 初始值}; 数组名和变量的命名规则是一样的 数组名是一个地址 数组下 ...