用户画像的匹配标签代码（性别,职业,国籍）

职业标签代码

import java.util.Properties

import com.czxy.MathTag.bean.{HBaseMeta, TagRule}
import org.apache.spark.sql.{DataFrame, Dataset, Row, SparkSession}

object JobTag {

  // 职业

  def main(args: Array[String]): Unit = {
    //1、创建sparkSQL实例没用于读取hbase    mysql数据
    val spark: SparkSession = SparkSession.builder().appName("JobTag").master("local[*]").getOrCreate()

    //2、链接mysql数据库
    //url: String, table: String, properties: Properties
    var url="jdbc:mysql://bd001:3306/tags_new?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&user=root&password=123456"
    var table="tbl_basic_tag"
    var properties=new Properties
    val mysqlConn: DataFrame = spark.read.jdbc(url,table,properties)

    //隐式转换
    import spark.implicits._
    import scala.collection.JavaConverters._
    import org.apache.spark.sql.functions._



    //3、读取四级标签数据
    //inType=HBase##zkHosts=192.168.10.20##zkPort=2181##hbaseTable=tbl_users##family=detail##selectFields=id,job
    val fourDS: Dataset[Row] = mysqlConn.select("rule").where("id=66")

    val fourMap: Map[String, String] = fourDS.map(row => {
      //使用##  切分再使用=切分
      row.getAs("rule").toString.split("##") //zkHosts=192.168.10.20      zkPort=2181
        .map(kv => {
        //zkHosts=192.168.10.20
        //zkPort=2181
        val arr: Array[String] = kv.split("=") // zkHosts    192.168.10.20,zkPort    2181
        (arr(0), arr(1))
      })
    }).collectAsList().get(0).toMap

 /* for(a <- fourMap){
    println(a._2)
  }*/



    //将map 转换成样HBaseMeta例类
    var hbaseMeta:HBaseMeta=getHBaseMeta(fourMap)

    //println(hbaseMeta.selectFields)


    //4、读取五级标签数据
     val fiveDS: Dataset[Row] = mysqlConn.select("id","rule").where("pid=66")
     //封装成 TagRule样例类
     val fiveTagRule: List[TagRule] = fiveDS.map(row => {
       //获取数据
       val id: Int = row.getAs("id").toString.toInt
       val rule: String = row.getAs("rule").toString
       //封装
       TagRule(id, rule)
     }).collectAsList().asScala.toList

       /*   for(a<-fiveTagRule){
             println(a.rule)
          }*/


     //5、读取hbase数据  com.czxy.Job.tools
     val HBaseDatas: DataFrame = spark.read.format("com.czxy.MathTag.tools.HBaseDataSource")
       .option(HBaseMeta.ZKHOSTS, hbaseMeta.zkHosts)
       .option(HBaseMeta.ZKPORT, hbaseMeta.zkPort)
       .option(HBaseMeta.HBASETABLE, hbaseMeta.hbaseTable)
       .option(HBaseMeta.FAMILY, hbaseMeta.family)
       .option(HBaseMeta.SELECTFIELDS, hbaseMeta.selectFields)
       .load()
     // HBaseDatas.show()



     //职业变换的自定义函数
     var  getTags=udf((rule:String)=>{
       //遍历每一个rule  判断是否与数据中的相同，若相同返回对应的ID
       //默认的tag ID0
       var tagId=0
       for(tagRule<-fiveTagRule){
         if (tagRule.rule==rule){
           tagId=tagRule.id
         }
       }
       tagId
     })

     //6、使用五级标签与hbase数据进行匹配获得标签
     //id    job
     val JobNewTags: DataFrame = HBaseDatas.select('id. as ("userId"),getTags('job).as("tagsId"))
     JobNewTags.show()

    // 为了避免你覆盖和重复


     //新数据（job）的结构  userId   tagsId
     //老数据（sex）的结构  userId   tagsId
     //使用join 将两个数据的tagsId合并到一起

     var getAllTagas=udf((oldTagsId:String,newTagsId:String)=>{
       if (oldTagsId==""){
         newTagsId
       }else if (newTagsId==""){
         oldTagsId
       }else if(oldTagsId==""&& newTagsId==""){
         ""
       }else{
         //拼接历史数据和新数据（可能有重复的数据）
         val alltags   = oldTagsId+","+newTagsId   //83,94,94
         //对重复数据区中去重
         alltags.split(",").distinct//83  94
           //使用逗号分隔，返回字符串类型。
           .mkString(",")//83,94
       }
     })


     //7、解决数据覆盖的问题【职业标签会覆盖前面的所有标签】
     //   读取test，追加标签后覆盖写入
     // 读取test内的历史标签数据，追加新计算出来的标签到历史数据，最后覆盖写入hbase
     //A    读取test内的历史标签数据【不是职业标签，是其他的，已经计算出来的标签】
     val oldTags: DataFrame = spark.read.format("com.czxy.MathTag.tools.HBaseDataSource")
       .option(HBaseMeta.ZKHOSTS, hbaseMeta.zkHosts)
       .option(HBaseMeta.ZKPORT, hbaseMeta.zkPort)
       .option(HBaseMeta.HBASETABLE,"test")
       .option(HBaseMeta.FAMILY, "detail")
       .option(HBaseMeta.SELECTFIELDS, "userId,tagsId")
       .load()

     //B    追加新计算出来的标签到历史数据
     //新表join新表，条件是两个表的userId相等
     val joinTagas: DataFrame = oldTags.join(JobNewTags,    oldTags("userId")===JobNewTags("userId"))

     val allTags: DataFrame = joinTagas.select(
       //处理第一个字段    两个表中的多个userId字段，只读取一个
       when((oldTags.col("userId").isNotNull),(oldTags.col("userId")))
         .when((JobNewTags.col("userId").isNotNull),(JobNewTags.col("userId")))
         .as("userId"),

       //处理第二个字段  将两个字段个合并一起
       //自定义函数用于做数据的凭借
       getAllTagas(oldTags.col("tagsId"),JobNewTags.col("tagsId")).as("tagsId")
     )

     //C    最后覆盖写入hbase
     //8、将最终数据写入hbase
     allTags.write.format("com.czxy.MathTag.tools.HBaseDataSource")
       .option("zkHosts", hbaseMeta.zkHosts)
       //HBaseMeta.ZKPORT=>"zkPort"
       //hbaseMeta.zkPort=>2181
       .option(HBaseMeta.ZKPORT, hbaseMeta.zkPort)

       .option(HBaseMeta.HBASETABLE,"test")
       .option(HBaseMeta.FAMILY, "detail")
       .option(HBaseMeta.SELECTFIELDS, "userId,tagsId")
       .save()

  }



// //将map 转换成样HBaseMeta例类
  def getHBaseMeta(fourMap: Map[String, String]): HBaseMeta ={
    // 读取数据类型
    HBaseMeta(fourMap.getOrElse(HBaseMeta.INTYPE,""),
      // zk 节点
      fourMap.getOrElse(HBaseMeta.ZKHOSTS,""),
      // zk 的端口
      fourMap.getOrElse(HBaseMeta.ZKPORT,""),
      //hbase的表
      fourMap.getOrElse(HBaseMeta.HBASETABLE,""),
      //hbase 的列族
      fourMap.getOrElse(HBaseMeta.FAMILY,""),
      //hbase 的列
      fourMap.getOrElse(HBaseMeta.SELECTFIELDS,""),
      //hbase 的rowkey
      fourMap.getOrElse(HBaseMeta.ROWKEY,"")
    )
  }
}

婚姻

import java.util.Properties

import com.czxy.MathTag.bean.{HBaseMeta, TagRule}
import org.apache.spark.sql.{DataFrame, Dataset, Row, SparkSession}

object marriageTag {

  // 婚姻

  def main(args: Array[String]): Unit = {
    //1、创建sparkSQL实例没用于读取hbase    mysql数据
    val spark: SparkSession = SparkSession.builder().appName("blackListTag").master("local[*]").getOrCreate()

    //2、链接mysql数据库
    //url: String, table: String, properties: Properties
    var url="jdbc:mysql://bd001:3306/tags_new?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&user=root&password=123456"
    var table="tbl_basic_tag"
    var properties=new Properties
    val mysqlConn: DataFrame = spark.read.jdbc(url,table,properties)

    //隐式转换
    import spark.implicits._
    import scala.collection.JavaConverters._
    import org.apache.spark.sql.functions._



    //