一、下载依赖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. BUG_sql未解决bug

    [SQL]truncate table org_cert;受影响的行: 0时间: 0.021s [Err] 1055 - Expression #1 of ORDER BY clause is not ...

  2. react native 之 事件监听 和 回调函数

    同原生一样,react native 同样也有事件监听和回调函数这玩意. 场景很多,比如:A界面push到B界面,B界面再pop回A界面,可以给A界面传值或者告诉A刷新界面. 事件监听 事件监听类似于 ...

  3. gcc/g++多版本切换 (ubuntu18.04)

    使用Ubuntu18.04已经有一段时间了,在使用过程中经常需要处理不同软件的编译工作,但是这时候就遇到这样一个问题,那就是不同软件,甚至是同一个软件的不同版本都会使用不同版本的gcc/g++来进行编 ...

  4. pprof进行golang程序性能分析

    一.导入包 import _ "net/http/pprof" 二.启动监控routine go func() { http.ListenAndServe("0.0.0. ...

  5. [LeetCode&Python] Problem 108. Convert Sorted Array to Binary Search Tree

    Given an array where elements are sorted in ascending order, convert it to a height balanced BST. Fo ...

  6. Unity LOD-Level of Detail（多层次细节）用法教程

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

  7. java-BigDecimal类

    1.BigDecimal类的概述和方法使用 * A:BigDecimal的概述 * 由于在运算的时候,float类型和double很容易丢失精度. * 所以,为了能精确的表示.计算浮点数,Java提供 ...

  8. Install Java on Ubuntu server

    准备工作 a) 获得超级用户权限 关于超级用户访问权限的说明: 要将 Java 安装在系统级位置(例如 /usr/java),则必须以超级用户身份登录,从而获得必要的权限.如果您不具有超级用户访问权限 ...

  9. URL编码表（收集到的，为了方便查看）

    URL编码表

  10. Redis（一）入门

    最近,学习了一下,Redis 这个Nosql数据库,从安装到基本语法,作为入门.下面,整理一下基本知识. 参考的地址如下: http://www.runoob.com/redis/redis-java ...