一、下载依赖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. django本身提供了runserver，为什么不能用来部署（runserver与uWSGI的区别）

    runserver方法是调试django时经常用到的运行方式,它使用django自带的. WSGI Server 运行,主要在测试和开发使用,并且runserver 开启的方式也是单线程. uWSGI ...

  2. 识别图片验证码的三种方式(scrapy模拟登陆豆瓣网)

    1.通过肉眼识别,然后输入到input里面 from PIL import image Image request.urlretrieve(url,'image')  #下载验证码图片 image = ...

  3. HDU 6092 17多校5 Rikka with Subset（dp+思维）

    Problem Description As we know, Rikka is poor at math. Yuta is worrying about this situation, so he ...

  4. 基于CART的回归和分类任务

    CART 是 classification and regression tree 的缩写,即分类与回归树. 博主之前学习的时候有用过决策树来做预测的小例子:机器学习之决策树预测--泰坦尼克号乘客数据 ...

  5. 【linux基础】如何确定系统使用的Eigen库的版本

    path /usr/include/eigen3/Eigen/src/Core/util 文件 Macros.h #define EIGEN_WORLD_VERSION 3 #define EIGEN ...

  6. [LeetCode&Python] Problem 520. Detect Capital

    Given a word, you need to judge whether the usage of capitals in it is right or not. We define the u ...

  7. jsp中<%两个最容易搞混淆的用法，附：out.println与out.write的用法

    jsp中的<% java代码 %>,表示的是在html中写入java代码,其写入的格式就是在java代码的两头加上<% %>.搞明白这些以后,我们再来看看在js中,最易搞混淆的 ...

  8. UVA10341 Solve It

    题意 PDF 分析 在\(0\le x\le 1\)时,\(f(x)=pe^{-x}+q\sin x+r\cos x+s\tan x+tx^2+u\)是减函数,所以当\(f(0)\ge 0 \wedg ...

  9. doubleclick video notes

    1,vast duration it must math this format ,if use “00:00:7 ”  it will tip “ ” <Duration>00:00:0 ...

  10. centos7如何安装zabbix

    只需要按照第三次修改版本的内容安装就可以了(水平线内的内容),主要是执行两个脚本就可以完成自动化安装了,其他内容是以前写的,仅留下来作为参考 第三次修改:(此次为zabbix4.0版本的,进一步的自动 ...