sparkstream 2.2.0 结合 kafka_2.10-0.10.2.1 的消费示例演示
今天讲了kafka和sparkstream的一个简单结合，试着在网上找了一个例子进行实现
1、相关配置 spark2.2.0，scala2.11.8，kafka_2.10-0.10.2.1,jdk1.8
2、这里是自己的pom.xml文件 如下
4.0.0
make
Spark_code_hive
1.0-SNAPSHOT
2008
2.11.8
1.8
1.8
UTF-8
2.2.0
2.9.1
0.10.2.1
scala-tools.org
Scala-Tools Maven2 Repository
http://scala-tools.org/repo-releases
scala-tools.org
Scala-Tools Maven2 Repository
http://scala-tools.org/repo-releases
org.scala-lang
scala-library
${scala.version}
junit
junit
4.4
test
org.specs
specs
1.2.5
test
org.apache.spark
spark-core_2.11
${spark.version}
compile
org.apache.spark
spark-sql_2.11
${spark.version}
compile
org.apache.spark
spark-streaming_2.11
${spark.version}
compile
org.apache.spark
spark-streaming-kafka-0-10_2.11
${spark.version}
compile
org.apache.kafka
kafka_2.11
${kafka.version}
compile
org.apache.hadoop
hadoop-client
${hadoop.version}
compile
org.apache.spark
spark-hive_2.11
${spark.version}
compile
org.spark-project.hive
hive-jdbc
1.2.1.spark2
com.databricks
spark-csv_2.11
1.5.0
mysql
mysql-connector-java
5.1.27
com.alibaba
fastjson
1.2.47
src/main/scala
src/test/scala
org.scala-tools
maven-scala-plugin
compile
testCompile
${scala.version}
-target:jvm-1.5
org.apache.maven.plugins
maven-eclipse-plugin
true
ch.epfl.lamp.sdt.core.scalabuilder
ch.epfl.lamp.sdt.core.scalanature
org.eclipse.jdt.launching.JRE_CONTAINER
ch.epfl.lamp.sdt.launching.SCALA_CONTAINER
org.scala-tools
maven-scala-plugin
${scala.version}
3、创建一个相关的配置文件，my.properties 如下，就是你的kafka的一些topic的相关设置
# kafka configs
kafka.bootstrap.servers=make.spark.com:9092,make.spark.com:9093,make.spark.com:9094
kafka.topic.source=spark-kafka-demo
kafka.topic.sink=spark-sink-test
kafka.group.id=spark_demo_gid1
4、创建我们的相关代码代码
4.1 首先创建读取我们配置文件my.properties的工具类，如下
package Utils
import java.util.Properties
/**
* Properties的工具类
* Created by make on 2017-08-08 18:39
*/
object PropertiesUtil {
/**
* 获取配置文件Properties对象
* @author make
* @return java.util.Properties
*/
def getProperties() :Properties = {
val properties = new Properties()
//读取源码中resource文件夹下的my.properties配置文件,得到一个properties
val reader = getClass.getResourceAsStream("/my.properties")
properties.load(reader)
properties
}
/**
* 获取配置文件中key对应的value
* @author make
* @return java.util.Properties
*/
def getPropString(key : String) : String = {
getProperties().getProperty(key)
}
/**
* 获取配置文件中key对应的整数值，可能后面这里会需要其他的值
* @author yore
* @return java.util.Properties
*/
def getPropInt(key : String) : Int = {
getProperties().getProperty(key).toInt
}
/**
* 获取配置文件中key对应的布尔值
* @author make
* @return java.util.Properties
*/
def getPropBoolean(key : String) : Boolean = {
getProperties().getProperty(key).toBoolean
}
}
4.2 我们创建一个kafkasink类用来 实例化producer以及向kafka发送数据 如下
package spark_stream
import java.util.concurrent.Future
import org.apache.kafka.clients.producer.{KafkaProducer, ProducerRecord, RecordMetadata}
/**
* 手动实现一个KafkaSink类，并实例化producer 将数据发送到kafka的对应topic
* This is the key idea that allows us to work around running into NotSerializableExceptions.
* Created by make on 2018-08-08 18:50
*/
class KafkaSink[K,V](createProducer: () => KafkaProducer[K, V]) extends Serializable {
//创建一个 生产者
lazy val producer = createProducer()
/** 发送消息 */
//本质是调用producer.send进行数据发送
def send(topic : String, key : K, value : V) : Future[RecordMetadata] =
producer.send(new ProducerRecord[K,V](topic,key,value))
def send(topic : String, value : V) : Future[RecordMetadata] =
producer.send(new ProducerRecord[K,V](topic,value))
}
//使用了伴生对象，简单实例化kafkasink
object KafkaSink {
import scala.collection.JavaConversions._
def apply[K, V](config: Map[String, Object]): KafkaSink[K, V] = {
val createProducerFunc = () => {
val producer = new KafkaProducer[K, V](config)
sys.addShutdownHook {
// Ensure that, on executor JVM shutdown, the Kafka producer sends
// any buffered messages to Kafka before shutting down.
producer.close()
}
producer
}
//返回一个producer
new KafkaSink(createProducerFunc)
}
def apply[K, V](config: java.util.Properties): KafkaSink[K, V] = apply(config.toMap)
}
4.3、创建我们的主方法类
package spark_stream
import java.util.Properties
import Utils.PropertiesUtil
import com.alibaba.fastjson.{JSON, JSONObject}
import org.apache.commons.lang3.StringUtils
import org.apache.kafka.common.serialization.{StringDeserializer, StringSerializer}
import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkConf
import org.apache.spark.broadcast.Broadcast
import org.apache.spark.streaming.kafka010.KafkaUtils
import org.apache.spark.streaming.{Milliseconds, StreamingContext}
import org.apache.spark.streaming.kafka010.ConsumerStrategies._
import org.apache.spark.streaming.kafka010.LocationStrategies._
object SparkKafkaDemo extends App {
// default a Logger Object
val LOG = org.slf4j.LoggerFactory.getLogger(SparkKafkaDemo.getClass)
/*if (args.length < 2) {
System.err.println(s"""
|Usage: DirectKafkaWordCount
| is a list of one or more Kafka brokers
| is a list of one or more kafka topics to consume from
|
""".stripMargin)
System.exit(1)
}*/
// 设置日志级别
Logger.getLogger("org.apache.spark").setLevel(Level.WARN)
Logger.getLogger("org.apache.spark.sql").setLevel(Level.WARN)
val Array(brokers, topics, outTopic) = /*args*/ Array(
PropertiesUtil.getPropString("kafka.bootstrap.servers"),
PropertiesUtil.getPropString("kafka.topic.source"),
PropertiesUtil.getPropString("kafka.topic.sink")
)
// Create context
/* 第一种方式 */
val sparkConf = new SparkConf().setMaster("local[2]")
.setAppName("spark-kafka-demo1")
val ssc = new StreamingContext(sparkConf, Milliseconds(1000))
/* 第二种方式 */
/*val spark = SparkSession.builder()
.appName("spark-kafka-demo1")
.master("local[2]")
.getOrCreate()
// 引入隐式转换方法，允许ScalaObject隐式转换为DataFrame
import spark.implicits._
val ssc = new StreamingContext(spark.sparkContext,Seconds(1))*/
// 设置检查点
ssc.checkpoint("spark_demo_cp1")
// Create direct Kafka Stream with Brokers and Topics
// 注意：这个Topic最好是Array形式的，set形式的匹配不上
//var topicSet = topics.split(",")/*.toSet*/
val topicsArr: Array[String] = topics.split(",")
// set Kafka Properties
val kafkaParams = Map[String, Object](
"bootstrap.servers" -> brokers,
"key.deserializer" -> classOf[StringDeserializer],
"value.deserializer" -> classOf[StringDeserializer],
"group.id" -> PropertiesUtil.getPropString("kafka.group.id"),
"auto.offset.reset" -> "latest",
"enable.auto.commit" -> (false: java.lang.Boolean)
)
/**
* createStream是Spark和Kafka集成包0.8版本中的方法，它是将offset交给ZK来维护的
*
* 在0.10的集成包中使用的是createDirectStream，它是自己来维护offset，在这个版本中
* zkCli中是看不到每个分区，到底消费到了那个偏移量，而在老的版本中，是可以看到的
* 速度上要比交给ZK维护要快很多，但是无法进行offset的监控。
* 这个方法只有3个参数，使用起来最为方便，但是每次启动的时候默认从Latest offset开始读取，
* 或者设置参数auto.offset.reset="smallest"后将会从Earliest offset开始读取。
*
* 官方文档@see Spark Streaming + Kafka Integration Guide (Kafka broker version 0.10.0 or higher)
*
*/
val stream = KafkaUtils.createDirectStream[String, String](
ssc,
PreferConsistent,
Subscribe[String, String](topicsArr, kafkaParams)
)
/** Kafak sink */
//set producer config
val kafkaProducer: Broadcast[KafkaSink[String, String]] = {
val kafkaProducerConfig = {
val p = new Properties()
p.setProperty("bootstrap.servers", brokers)
p.setProperty("key.serializer", classOf[StringSerializer].getName)
p.setProperty("value.serializer", classOf[StringSerializer].getName)
p
}
LOG.info("kafka producer init done!")
// 广播KafkaSink 传入kafkaProducerConfig，在kafkaSink中实例化producer
ssc.sparkContext.broadcast(KafkaSink[String, String](kafkaProducerConfig))
}
var jsonObject = new JSONObject()
//对传入的流中的数据，进行筛选和逻辑处理
stream.filter(record => {
// 过滤掉不符合要求的数据
try {
jsonObject = JSON.parseObject(record.value)
} catch {
case e: Exception => {
LOG.error("转换为JSON时发生了异常！\t{}", e.getMessage)
}
}
// 如果不为空字符时，为null，返回false过滤，否则为true通过
StringUtils.isNotEmpty(record.value) && null != jsonObject
}).map(record => {
//这个地方可以写自己的业务逻辑代码，因为本次是测试，简单返回一个元组
jsonObject = JSON.parseObject(record.value)
// 返出一个元组，(时间戳，json的数据日期，json的关系人姓名)
(System.currentTimeMillis(),
jsonObject.getString("date_dt"),
jsonObject.getString("relater_name")
)
}).foreachRDD(rdd => {
if (!rdd.isEmpty()) {
rdd.foreach(kafkaTuple => {
//向Kafka发送数据，outTopic，value，也就是我们kafkasink的第二种send方法
//取出广播的value 调用send方法 对每个数据进行发送 和 打印
kafkaProducer.value.send(
outTopic,
kafkaTuple._1 + "\t" + kafkaTuple._2 + "\t" + kafkaTuple._3
)
//同时将信息打印到控制台，以便查看
println(kafkaTuple._1 + "\t" + kafkaTuple._2 + "\t" + kafkaTuple._3)
})
}
})
// 启动streamContext
ssc.start()
//一直等待数据 直到关闭
ssc.awaitTermination()
}
5、我们在我们kafka集群上，创建对应的一个生产者，以及消费者
创建两个对应的topic
bin/kafka-topics.sh --create --zookeeper make.spark.com:2181/kafka_10 --topic spark-kafka-demo --partitions 3 --replication-factor 2bin/kafka-topics.sh --create --zookeeper make.spark.com:2181/kafka_10 --partitions 3 --replication-factor 1 --topic spark-sink-test创建一个对我们的程序发送数据的生产者
bin/kafka-console-producer.sh --broker-list make.spark.com:9092,make.spark.com:9093,make.spark.com:9094 --topic spark-kafka-demo创建一个消费我们的程发送数据的消费者
bin/kafka-console-consumer.sh --bootstrap-server make.spark.com:9092,make.spark.com:9093,make.spark.com:9094 --from-beginning --topic spark-sink-test6、启动生产者，启动我们的程序，并在生产者窗口，写入我们的测试数据 如下
{"date_dt": "201808081823","relater_name": "make"}
{"date_dt": "201808081823","relater_name": "make"}
{"date_dt": "201808081823","relater_name": "make"}
{"date_dt": "201808081823","relater_name": "make"}
{"date_dt": "201808081823","relater_name": "make"}
{"date_dt": "201808081823","relater_name": "make"}
{"date_dt": "201808081823","relater_name": "make"}
{"date_dt": "201808081823","relater_name": "make"}
{"date_dt": "201808081823","relater_name": "make"}
{"date_dt": "201808081823","relater_name": "make"}
{"date_dt": "201808081823","relater_name": "make"}切换到我们的idea 可以看到我们的打印信息已经输出了，name我么的数据也发送出去了
切换到我们的消费者窗口，也可以看到数据已经过来了
到这里，就实现一个接受，发送的一个kafka-stream-kafka这样的一个流程，也学到不少东西，以上
参考文章：参考文章点这里！！谢谢博主