Spark的流式处理数据中使用case class 封装为对象以及简单的黑名单过滤情况

一.

因为作者比较懒，这里没有做流式的数据接入，所以采用sparkcore的方式进行编码，使用者需要在真实环境中注意
1） 数据的接入的改变，如 kafka集成sparkstreaming接入
2） 黑名单过滤时候，应该是dstream作为输入，想要进行rdd操作需要使用transform算子，本文无法展示

import java.util.Properties

import com.alibaba.fastjson. JSONObject
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.SparkSession
import org.apache.spark.{SparkConf, SparkContext}

object ProcessExcelUtils {
  /**
   * 注意在正常情况下，是不建议在此处写账户密码按配置的，还是建议写在配置文件或者单独写一个接口
   */

  lazy val properties = {
    val prop = new Properties()
    prop.put("user", "root")
    prop.put("password", "123456")
    prop
  }
   lazy val url= "jdbc:mysql://localhost:3306/test"


  def main(args: Array[String]): Unit = {

    /**
     * @desc 将rdd中的数据使用对象进行封装，转为json数据格式后可以发往各个地方进行消费，比如
     * KAFKA，数据库，redis等
     */

    val conf=new SparkConf()
      .setMaster("local")
      .setAppName("ProcessExcelUtils")

    /**
     *测试使用的是读取本地文件，正式环境一般是做流处理，接入的是Kafka，按照相应的方法接入数据即可
     */
    val spark = SparkSession.builder.config(conf).getOrCreate()
    val path ="datas/excel.txt"

    val sc: SparkContext =spark.sparkContext
    val rdd: RDD[String] =sc.textFile(path)

    //1. 读取的RDD数据进行格式转换,并封装成一个对象，RDD[AdClickRecord]
    val transFromData: RDD[AdClickRecord] =this.TransfromRdd(rdd)

    //2. 实现黑名单过滤
    val filterBlackList=this.filterBlackList(transFromData)

    /**
     * 使用Fastjson进行数据的转换,可以将转换后的数据发送下游或者存储，具体暂时没有例子
     */
    val jsons = new JSONObject

    filterBlackList.foreach(
      data=>{
       jsons.put("id",data.id)
        jsons.put("Name",data.name)
        jsons.put("stage",data.stage)
        jsons.put("age",data.age)
        jsons.put("sex",data.sex)
        println(jsons)
      }
    )

    spark.stop()

  }




  /**
   *
   * @desc  一. 将rdd中的数据使用对象进行封装
   * @param rdd
   * @return RDD[AdClickRecord]
   */
  def TransfromRdd(rdd:RDD[String]): RDD[AdClickRecord] ={

    rdd
      .map(line=>line.split(" "))
    .map(
      arr=>{
        AdClickRecord(
        arr(0).toInt,
        arr(1),
        arr(2),
        arr(3).toInt,
        arr(4)
        )
      }
    )
  }

  /**
   * @desc ：
   *      黑名单过滤，注意在正式的情况下，黑名单是存储在数据库的，
   *      因此需要使用SQLcontext去读取，而不是测试使用的sparkContext的textFile去读取
   * @return  RDD[AdClickRecord]

   */

  def filterBlackList(rdd:RDD[AdClickRecord]):RDD[AdClickRecord] ={

    /**
     *抽象出一个sparkcontext去读取黑名单，注意在正式中是连接的jdbc,

     @desc :以下提供一个本地测试的方法读取文件
    val sc= rdd.sparkContext
    val blackList="datas/blackList.txt"
    val sc1= rdd.sparkContext
     */

    val blacklistRdd=SparkSession
      .builder.getOrCreate()

    import blacklistRdd.implicits._

    // 通过jdbc读取黑名单数据
   val blackRdd= blacklistRdd.read.jdbc(url ,"blacklist", properties)
     .map(line=>{
       val id = line.getAs[Int]("id")
       val name=line.getAs[String]("name")
       (id ,name)
      }).rdd

    rdd.map(x=>(x.id,x))
      .leftOuterJoin(blackRdd)
      .filter{
        case (_,(record,option))=>{
          option.isEmpty
        }
      }.map{
      case (_,(record,_))=>record
    }
      // .foreach(x=>println(x))  可以打印看结果,注意需要改变返回值
  }

  // 用作封装数据的载体
  case class AdClickRecord(
                            id: Int,
                            name: String,
                            stage: String,
                            age: Int,
                            sex: String
                          )

}