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

    1.请使用C3算法计算出链接图中的继承顺序-Link 一 graph BT id1[A]-->id2[B] id2[B]-->id6[F] id6[F]-->id7[G] id1[A ...

  2. mssql,mysql,Oracle 数据库中获得UUID字符串

    sql server : select replace(newId(),'-','') oracle :select sys_guid() from dual SQL> select sys_g ...

  3. JavaScript条件语句4--分支语句--if

    JavaScript条件语句--分支语句 学习目标 1.掌握条件语句if 2.掌握prompt()的应用 3.掌握alert的应用 If语句 语法一: If(condition){ statement ...

  4. 2017-2018-2 20165228 实验三《敏捷开发与XP实践》实验报告

    2017-2018-2 20165228 实验三<敏捷开发与XP实践>实验报告 相关知识点 (一)敏捷开发与XP 通过 XP准则来表达: 沟通 :XP认为项目成员之间的沟通是项目成功的关键 ...

  5. HDU - 5785：Interesting （回文树，求相邻双回文的乘积）

    Alice get a string S. She thinks palindrome string is interesting. Now she wanna know how many three ...

  6. 深入java final关键字

    Java final关键字详解:https://blog.csdn.net/kuangay/article/details/81509164 深入java final关键字 用法注意点和JVM对其进行 ...

  7. 第三次随笔--安装虚拟机及学习linux系统初体验

    第三次随笔--安装虚拟机及学习linux系统初体验 ·学习基于VirtualBox虚拟机安装Ubuntu图文教程在自己笔记本上安装Linux操作系统 首先按照老师的提示步骤进行VirtualBox虚拟 ...

  8. ZOJ 1006：Do the Untwist（模拟）

    Do the Untwist Time Limit: 2 Seconds      Memory Limit: 65536 KB Cryptography deals with methods of ...

  9. PTA——四舍五入

    PTA 7-18 出租车计价 (15 分) #include<stdio.h> int main() { double s,w; int t; scanf("%lf %d&quo ...

  10. Python逻辑运算

    一.运算符种类 1.比较运算符 > ,< , >= ,<= , != , == 2.赋值运算符 =, +=,-=,*=,/=,**=,%= 3.成员运算符 in not in ...