大数据IMF传奇行动绝密课程第98-99课：使用Spark Streaming实战对论坛网站动态行为的多维度分析

使用Spark Streaming实战对论坛网站动态行为的多维度分析

package com.tom.spark.SparkApps.sparkstreaming;

import java.io.PrintWriter;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import kafka.serializer.StringDecoder;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.streaming.Durations;
import org.apache.spark.streaming.api.java.JavaPairDStream;
import org.apache.spark.streaming.api.java.JavaPairInputDStream;
import org.apache.spark.streaming.api.java.JavaStreamingContext;
import org.apache.spark.streaming.kafka.KafkaUtils;

import scala.Tuple2;

public class OnlineBBSUserLogs {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/**
* 第一步：配置SparkConf，
* 1、至少2条线程：因为Spark Streaming应用程序在运行的时候至少有一条
* 线程用于不断的循环接收数据，并且至少有一条线程用于处理接收的数据（否则的话无法有线程用
* 于处理数据，随着时间的推移，内存和磁盘都会不堪重负）
* 2、对于集群而言，每个Executor一般肯定不止一个Thread，那对于处理Spark Streaming
* 应用程序而言，每个Executor一般分配多少Core比较合适？根据经验，5个左右的Core是最佳的
* （一个段子：分配为奇数个Core表现最佳，例如3个、5个、7个Core等
*/
SparkConf conf = new SparkConf().setMaster("local[2]").setAppName("OnlineBBSUserLogs");
/**
* 第二步：创建Spark StreamingContext：
* 1、这是SparkStreaming应用程序所有功能的起始点和程序调度的核心.
* SparkStreamingContext的构建可以基于SparkConf参数，也可以基于持久化的SparkStreamingContext的
* 内容来恢复过来（典型的场景是Driver崩溃后重新启动，由于Spark Streaming具有连续7*24小时不间断运行的特征，
* 所以需要在Driver重新启动后继续上一次的状态，此时的状态恢复需要基于曾经的Checkpoint）
* 2、在一个Spark Streaming应用程序中可以创建若干个SparkStreamingContext对象，使用下一个SparkStreaming
* 之前需要把前面正在运行的SparkStreamingContext对象关闭掉，由此，我们得出一个重大启发，SparkStreaming框架也只是
* Spark Core上的一个应用程序而已，只不过Spark Streaming框架想运行的话需要Spark工程师写业务逻辑处理代码
*/
JavaStreamingContext javassc = new JavaStreamingContext(conf, Durations.seconds(5));

/**
* 第三步：创建Spark Streaming输入数据来源input Stream:
* 1、数据输入来源可以基于File、HDFS、Flume、Kafka、Socket等
* 2、在这里我们指定数据来源于网络Socket端口，Spark Streaming连接上该端口并在运行的时候一直监听该端口的数据
*      (当然该端口服务首先必须存在），并且在后续会根据业务需要不断有数据产生（当然对于Spark Streaming
*      应用程序的运行而言，有无数据其处理流程都是一样的）
* 3、如果经常在每间隔5秒钟没有数据的话不断启动空的Job其实会造成调度资源的浪费，因为并没有数据需要发生计算；所以
*      实际的企业级生成环境的代码在具体提交Job前会判断是否有数据，如果没有的话就不再提交Job；
*/
Map<String, String> kafkaParameters = new HashMap<String, String>();
kafkaParameters.put("metadata.broker.list", "Master:9092,Worker1:9092,Worker2:9092");
Set<String> topics = new HashSet<String>();
topics.add("UserLogs");

JavaPairInputDStream<String, String> lines = KafkaUtils.createDirectStream(javassc,
String.class, String.class,
StringDecoder.class, StringDecoder.class,
kafkaParameters,
topics);
//在线PV计算
onlinePagePV(lines);
//在线UV计算
onlineUV(lines);
//在线注册人数
onlineRegistered(lines);
//在线跳出率
onlineJumped(lines);
//在线不同模块的PV
onlineChannelPV(lines);

/**
* Spark Streaming 执行引擎也就是Driver开始运行，Driver启动的时候是位于一条新的线程中的，当然其内部有消息循环体，用于
* 接收应用程序本身或者Executor中的消息，
*/
javassc.start();
javassc.awaitTermination();
//      javassc.close();
}
private static void onlineChannelPV(
JavaPairInputDStream<String, String> lines) {
// TODO Auto-generated method stub
lines.mapToPair(new PairFunction<Tuple2<String, String>, String, Long>() {

public Tuple2<String, Long> call(Tuple2<String, String> t) throws Exception {
// TODO Auto-generated method stub
String[] logs = t._2.split("\t");
String channelName = logs[4];
return new Tuple2<String, Long>(channelName, 1L);
}
}).reduceByKey(new Function2<Long, Long, Long>(){
//对相同的key，进行Value的累加（包括Local和Reducer级别同时Reduce）
public Long call(Long v1, Long v2) throws Exception {
// TODO Auto-generated method stub
return v1 + v2;
}

}).print();
}
private static void onlineJumped(JavaPairInputDStream<String, String> lines) {
// TODO Auto-generated method stub
lines.mapToPair(new PairFunction<Tuple2<String, String>, Long, Long>() {

public Tuple2<Long, Long> call(Tuple2<String, String> t) throws Exception {
// TODO Auto-generated method stub
String[] logs = t._2.split("\t");
Long userId = Long.valueOf("null".equals(logs[2]) ? "-1" : logs[2]);
return new Tuple2<Long, Long>(userId, 1L);
}
}).reduceByKey(new Function2<Long, Long, Long>(){
//对相同的key，进行Value的累加（包括Local和Reducer级别同时Reduce）
public Long call(Long v1, Long v2) throws Exception {
// TODO Auto-generated method stub
return v1 + v2;
}

}).filter(new Function<Tuple2<Long, Long>, Boolean>() {

public Boolean call(Tuple2<Long, Long> v1) throws Exception {
// TODO Auto-generated method stub

return 1L == v1._2;
}
}).count().print();
}
private static void onlineRegistered(
JavaPairInputDStream<String, String> lines) {
// TODO Auto-generated method stub
lines.filter(new Function<Tuple2<String,String>, Boolean>() {

public Boolean call(Tuple2<String, String> v1) throws Exception {
// TODO Auto-generated method stub
String[] logs = v1._2.split("\t");
String action = logs[5];
return "register".equals(action);
}
}).count().print();
}
/**
* 因为要计算UV，所以需要获得同样的Page的不同的User，这个时候就需要去重操作，DStream中有distinct吗？当然没有（截止到Spark1.6.1）
* 此时我们就需要求助于DStream魔术般的方法transform，在该方法内部直接对RDD进行distinct操作，这样就是实现了用户UserID的去重，进而计算UV
* @param lines
*/
private static void onlineUV(JavaPairInputDStream<String, String> lines) {
// TODO Auto-generated method stub
/**
* 第四步：接下来就像对于RDD编程一样基于DStream进行编程，原因是DStream是RDD产生的模板（或者说类），在Spark Streaming具体
* 发生计算前，其实质是把每个Batch的DStream的操作翻译成为对RDD的操作！
*
*/
JavaPairDStream<String, String> logsDStream = lines.filter(new Function<Tuple2<String,String>, Boolean>() {

public Boolean call(Tuple2<String, String> v1) throws Exception {
// TODO Auto-generated method stub
String[] logs = v1._2.split("\t");
String action = logs[5];
return "view".equals(action);
}
});

/**
* 第4.2步：在单词拆分的基础上对每个单词实例计数为1，也就是word => (word, 1)
*/
logsDStream.map(new Function<Tuple2<String,String>, String>() {

public String call(Tuple2<String, String> v1) throws Exception {
// TODO Auto-generated method stub
String[] logs = v1._2.split("\t");
Long userId = Long.valueOf(logs[2] != null ? logs[2] : "-1");
Long pageId = Long.valueOf(logs[3]);
return pageId + "_" + userId;
}
}).transform(new Function<JavaRDD<String>, JavaRDD<String>>() {

public JavaRDD<String> call(JavaRDD<String> v1) throws Exception {
// TODO Auto-generated method stub
return v1.distinct();
}
}).mapToPair(new PairFunction<String, Long, Long>() {

public Tuple2<Long, Long> call(String t) throws Exception {
// TODO Auto-generated method stub
String[] logs = t.split("_");
Long pageId = Long.valueOf(logs[0]);
return new Tuple2<Long, Long>(pageId, 1L);
}
}).reduceByKey(new Function2<Long, Long, Long>(){
//对相同的key，进行Value的累加（包括Local和Reducer级别同时Reduce）
public Long call(Long v1, Long v2) throws Exception {
// TODO Auto-generated method stub
return v1 + v2;
}

}).print();
}

private static void onlinePagePV(JavaPairInputDStream<String, String> lines) {
/**
* 第四步：接下来就像对于RDD编程一样基于DStream进行编程，原因是DStream是RDD产生的模板（或者说类），在Spark Streaming具体
* 发生计算前，其实质是把每个Batch的DStream的操作翻译成为对RDD的操作！
*/
JavaPairDStream<String, String> logsDStream = lines.filter(new Function<Tuple2<String,String>, Boolean>() {

public Boolean call(Tuple2<String, String> v1) throws Exception {
// TODO Auto-generated method stub
String[] logs = v1._2.split("\t");
String action = logs[5];
return "view".equals(action);
}
});

/**
* 第4.2步：在单词拆分的基础上对每个单词实例计数为1，也就是word => (word, 1)
*/
JavaPairDStream<Long, Long> pairs = logsDStream.mapToPair(new PairFunction<Tuple2<String,String>, Long, Long>() {

public Tuple2<Long, Long> call(Tuple2<String, String> t)
throws Exception {
// TODO Auto-generated method stub
String[] logs = t._2.split("\t");
Long pageId = Long.valueOf(logs[3]);
return new Tuple2<Long, Long>(pageId, 1L);
}
});
/**
* 第4.3步：在单词实例计数为1基础上，统计每个单词在文件中出现的总次数
*/
JavaPairDStream<Long, Long> wordsCount = pairs.reduceByKey(new Function2<Long, Long, Long>(){
//对相同的key，进行Value的累加（包括Local和Reducer级别同时Reduce）
public Long call(Long v1, Long v2) throws Exception {
// TODO Auto-generated method stub
return v1 + v2;
}
});

/**
* 此处的print并不会直接触发Job的支持，因为现在的一切都是在Spark Streaming框架的控制之下的，对于SparkStreaming
* 而言，具体是否触发真正的Job运行是基于设置的Duration时间间隔的
*
* 注意，Spark Streaming应用程序要想执行具体的Job，对DStream就必须有ouptputstream操作
* outputstream有很多类型的函数触发，例如print,saveAsTextFile,saveAsHadoopFiles等，
* 其中最为重要的一个方法是foreachRDD，因为Spark Streaming处理的结果一般会放在Redis、DB、DashBoard
* 等上面，所以foreachRDD主要就是用来完成这些功能的，而且可以随意自定义具体数据到底放在哪里。
*
* 在企业生产环境下，一般会把计算的数据放入Redis或者DB中，采用J2EE等技术进行趋势的绘制等，这就像动态更新的股票交易一样，
* 来实现在线的监控等
*/
wordsCount.print();
}
}

package com.tom.spark.SparkApps.sparkstreaming;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Properties;
import java.util.Random;

import kafka.javaapi.producer.Producer;
import kafka.producer.KeyedMessage;
import kafka.producer.ProducerConfig;

/**
* 论坛数据自动生成代码，该生成的数据会作为Producer的方式发送给Kafka，然后Spark Streaming程序会从
* Kafka中在线Pull到论坛或者网站的用户在线行为信息，进而进行多维度的在线分析 数据格式如下： data:日期，格式为yyyy-MM-dd
* timestamp:时间戳 userID:用户ID pageID:页面ID channelID:板块ID action:点击和注册
*/
public class SparkStreamingDataManuallyProducerForKafka extends Thread {

static String[] channelNames = new String[] { "Spark", "Scala", "Kafka",
"Flink", "Hadoop", "Storm", "Hive", "Impala", "HBase", "ML" };
// 用户的两种行为模式
static String[] actionNames = new String[] { "register", "view" };
private String topic; // 发送给Kafka的数据的类别
private Producer<Integer, String> producerForKafka;

private static String dateToday;
private static Random random;

public SparkStreamingDataManuallyProducerForKafka(String topic) {
random = new Random();
dateToday = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
this.topic = topic;
Properties conf = new Properties();
conf.put("metadata.broker.list",
"Master:9092,Worker1:9092,Worker2:9092");
conf.put("serializer.class", "kafka.serializer.StringEncoder");
producerForKafka = new Producer<Integer, String>(new ProducerConfig(
conf));
}

public void run() {
int counter = 0;
while (true) {
counter++;
String userLog = userlogs();
System.out.println("product:" + userLog);
producerForKafka.send(new KeyedMessage<Integer, String>(topic,
userLog));

if (0 == counter % 500) {
counter = 0;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

public static void main(String[] args) {
new SparkStreamingDataManuallyProducerForKafka("UserLogs").start();
}

private static String userlogs() {
// TODO Auto-generated method stub

StringBuffer userLogBuffer = new StringBuffer("");
int[] unregisteredUsers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };

long timestamp = new Date().getTime();
Long userID = 0L;
long pageID = 0;

// 随机生成的用户ID
if (unregisteredUsers[random.nextInt(8)] == 1) {
userID = null;
} else {
userID = (long) random.nextInt((int) 2000);
}
// 随机生成的页面ID
pageID = random.nextInt((int) 2000);
// 随机生成Channel
String channel = channelNames[random.nextInt(10)];

// 随机生成acton行为
String action = actionNames[random.nextInt(2)];

userLogBuffer.append(dateToday).append("\t").append(timestamp)
.append("\t").append(userID).append("\t").append(pageID)
.append("\t").append(channel).append("\t").append(action);

return userLogBuffer.toString();
}
}