通过 DataFrame 将数据导入到 MongoDB。_dataframe 数据写入 mongo-CSDN博客

本文链接：https://blog.csdn.net/qq_32783151/article/details/117934836

1、创建 DataFrame

  /**声明样本类*/
  case class Data(val uid:Int,
               val tag:String,
               val info:String
              )

  /**声明Spark环境*/
    val conf = new SparkConf().setMaster("local[2]").setAppName("DataLoading")
//  val sc = new SparkConf(conf)
    val spark = SparkSession.builder().config(conf).getOrCreate()

    //加载数据集
    val dataRDD = spark.sparkContext.textFile("加载地址")

    import spark.implicits._
    //将RDD转化成DataFrame
    val dataFrame = dataRDD.map(lines =>{
    val x = lines.split(",")   
    Data(x(0).trim.toInt,x(1).trim,x(2).trim)
    }).toDF()

    spark.close()

2、通过 DataFrame 将数据导入到 MongoDB。

    //创建到MongoDB的链接
    val mongoClient = MongoClient(MongoClientURI("mongodb://ip:27017/库名"))

    //删除Mongo相关表。
    mongoClient("数据库名")("表名").dropCollection()

    //将数据写入MongoDB
    dataFrame.write
      .option("uri","mongodb://ip:27017/库名")
      .option("collectiong","表名")
      .mode("overwrite")
      .format("com.mongodb.spark.sql")
      .save()

    //MongoDB创建索引
    mongoClient("数据库名")("表名").createIndex(MongoDBObject("列名" ->1))
    
    //关闭MongoDB连接
    mongoClient.close()

案例：将 Movies Rating Tag 导入 MongoDB 数据库中。

1、样本类封装 Model.scala：

package DataLoader

/**
  * @author youngx
  * @date 2021/4/25 14:51
  *
  * movies.csv(电影基本信息) 用 ^ 隔开
  *       1^Toy Story (1995)^ ^81 minutes^March 20, 2001^1995^English ^
  *       Adventure|Animation|Children|Comedy|Fantasy ^
  *      Tom Hanks|Tim Allen|Don Rickles|Jim Varney|Wallace Shawn|John Ratzenberger|Annie Potts|John Morris|Erik von Detten|Laurie Metcalf|R. Lee Ermey|Sarah Freeman|Penn Jillette|Tom Hanks|Tim Allen|Don Rickles|Jim Varney|Wallace Shawn ^
  *       John Lasseter
  *       电影ID^电影的名称^电影的描述^电影时长^电影的发行日期^电影拍摄日期^电影的语言^
  *       电影的类型^
  *       电影的演员^
  *       电影的导演^
  * ratings.csv(用户对电影的评分数据集) 用 , 隔开
  *       1,31,2.5,1260759144
  *       用户ID,电影ID,用户对电影的评分,用户对电影评分的时间
  * tags.csv(用户对电影的标签数据集)用 , 隔开
  *       15,339,sandra 'boring' bullock,1138537770
  *       用户ID,电影ID,标签内容,时间
  */

**
  * Movie【 电 影 数 据 表 】
  * @param mid  电影的 ID
  * @param name 电影的名称
  * @param descri 电影的描述
  * @param timelong 电影的时长
  * @param issue 电影发布时间
  * @param shoot 电影拍摄时间
  * @param language 电影语言
  * @param genres 电影所属类别
  * @param actors 电影的演员
  * @param director 电影的导演
  */
case class Movies(val mid:Int,
                  val name:String,
                  val descri:String,
                  val timelong:String,
                  val issue:String,
                  val shoot:String,
                  val language:String,
                  val genres:String,
                  val actors:String,
                  val director:String
                  )

/**
  * Rating【 用 户 评 分 表 】
  * @param uid 用户的 ID
  * @param mid 电影的 ID
  * @param score 电影的分值
  * @param timestamp 评分的时间
  */
case class Ratings(val uid:Int,
                  val mid:Int,
                  val score:Double,
                  val timestamp:Long)

/**
  * Tags【 电 影 标 签 表
  * @param uid 用户的 ID
  * @param mid 电影的 ID
  * @param tag 电影的标签内容
  * @param timestamp 评分的时间
  */
case class Tags(val uid:Int,
               val mid:Int,
               val tag:String,
               val timestamp:Long
              )

/**
  * 封装 MongoConfig配置
  * @param uri  MongoDB uri
  * @param db  数据库名
  */
case class MongoConfig(val uri:String,val db:String)

2、DataLoad.scala：

package DataLoader

import com.mongodb.casbah.commons.MongoDBObject
import com.mongodb.casbah.{MongoClient, MongoClientURI}
import org.apache.spark.SparkConf
import org.apache.spark.sql.{DataFrame, SparkSession}

/**
  * @author youngx
  * @date 2021/4/25 13:32
  * 将数据导入到系统：MongoDB 与 ES
  * 使用 Spark SQL 导入数据
  */

object DataLoad {

  //定义MongoDB中的表（Collection）
  var MOVIES_COLLECTION_NAME = "Movies"
  var RATINGS_COLLECTION_NAME = "Ratings"
  var TAGS_COLLECTION_NAME = "Tags"


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

    var MOVIES_INPATH = "G:\\School\\Bigdata\\Info\\reco_data\\small\\movies.csv"
    var RATINGS_INPATH = "G:\\School\\Bigdata\\Info\\reco_data\\small\\ratings.csv"
    var TAGS_INPATH = "G:\\School\\Bigdata\\Info\\reco_data\\small\\tags.csv"

    /**创建全局配置*/
    val params = scala.collection.mutable.Map[String,Any]()
    params += (("spark.cores","local[2]"))
    params += "mongo.uri" -> "mongodb://192.168.109.141:27017/recom"
    params += "mongo.db" -> "recom"

    implicit val mongoConfig = new MongoConfig(params("mongo.uri").asInstanceOf[String]
                                ,params("mongo.db").asInstanceOf[String])

    /**声明Spark环境*/
    val conf = new SparkConf().setMaster(params("spark.core").asInstanceOf[String]).setAppName("DataLoading")
//    val sc = new SparkConf(sc)
    val spark = SparkSession.builder().config(conf).getOrCreate()


    //加载数据集：Movies   Rating   Tag
    val moviesRDD = spark.sparkContext.textFile(MOVIES_INPATH)
    val ratingsRDD = spark.sparkContext.textFile(RATINGS_INPATH)
    val tagsRDD = spark.sparkContext.textFile(TAGS_INPATH)

    import spark.implicits._
    //将RDD转化成DataFrame

    //Movie电影数据表
    val moviesDF = moviesRDD.map(lines =>{
      val x = lines.split("\\^")
      Movies(x(0).trim.toInt,x(1).trim,x(2).trim,x(3).trim,x(4).trim,x(5).trim,
        x(6).trim,x(7).trim,x(8).trim,x(9).trim)
    }).toDF()

    //Rating 用户评分表
    val ratingsDF = ratingsRDD.map(lines =>{
      val x = lines.split(",")
      Ratings(x(0).trim.toInt,x(1).trim.toInt,x(2).trim.toDouble,x(3).trim.toLong)
    }).toDF()

    //Tag电影标签表
    val tagsDF = tagsRDD.map(lines =>{
      val x = lines.split(",")
      Tags(x(0).trim.toInt,x(1).trim.toInt,x(2).trim,x(3).trim.toLong)
    }).toDF()

    //将数据写入到mongoDB
    saveData2Mongo(moviesDF,ratingsDF,tagsDF)
  
    spark.close()
  }

  /**
    * 将数据写入到mongoDB的方法
    * @param moviesDF
    * @param ratingsDF
    * @param tagsDF
    * @param mongoConfig
    */

  private def saveData2Mongo(moviesDF: DataFrame, ratingsDF: DataFrame,
                             tagsDF: DataFrame)(implicit mongoConfig: MongoConfig): Unit = {

    //创建到MongoDB的链接
    val mongoClient = MongoClient(MongoClientURI(mongoConfig.uri))

    //删除Mongo相关表。
    mongoClient(mongoConfig.db)(MOVIES_COLLECTION_NAME).dropCollection()
    mongoClient(mongoConfig.db)(RATINGS_COLLECTION_NAME).dropCollection()
    mongoClient(mongoConfig.db)(TAGS_COLLECTION_NAME).dropCollection()

    //将数据写入MongoDB
    moviesDF.write
      .option("uri",mongoConfig.uri)
      .option("collectiong",MOVIES_COLLECTION_NAME)
      .mode("overwrite")
      .format("com.mongodb.spark.sql")
      .save()

    ratingsDF.write
      .option("uri",mongoConfig.uri)
      .option("collectiong",RATINGS_COLLECTION_NAME)
      .mode("overwrite")
      .format("com.mongodb.spark.sql")
      .save()

    tagsDF.write
      .option("uri",mongoConfig.uri)
      .option("collectiong",TAGS_COLLECTION_NAME)
      .mode("overwrite")
      .format("com.mongodb.spark.sql")
      .save()


    //MongoDB创建索引
    mongoClient(mongoConfig.db)(MOVIES_COLLECTION_NAME).createIndex(MongoDBObject("mid" ->1))

    mongoClient(mongoConfig.db)(RATINGS_COLLECTION_NAME).createIndex(MongoDBObject("mid" ->1))
    mongoClient(mongoConfig.db)(RATINGS_COLLECTION_NAME).createIndex(MongoDBObject("uid" ->1))

    mongoClient(mongoConfig.db)(TAGS_COLLECTION_NAME).createIndex(MongoDBObject("mid" ->1))
    mongoClient(mongoConfig.db)(TAGS_COLLECTION_NAME).createIndex(MongoDBObject("uid" ->1))

    //关闭MongoDB连接
    mongoClient.close()

  }
}