spark学习五——归属地计算案例

cache方法

他可以将数据标记为cache，在触发action的时候，会将数据缓存进内存当中，并进行计算。被标记为cache的RDD第一次触发action的时候，因为需要将数据缓存入内存当中，时间会比平时慢。但是在后续需要运用该被标记RDD进行计算的时候，计算会快特别多，十分快。所以需要多次重复运用的数据的时候可以将其cache，极大提高效率。比如机器学算法的多次迭代什么的

cache的前提

要求的计算速度快，
集群的资源要足够大 .
重要：cache的数据会多次的触发Action，这个时候需要缓存，没这个前提用一次没必要缓存
.先进行过滤，然后将缩小范围的数据在cache到内存，过滤拿掉一部分数据。

val cache =RDD.cache   //将RDD进行缓存放不下只会放一部分，

将RDD释放内存

cache.uppersist(true)   //Ture 表示异步（先释放内存，再执行后续代码），表是False同步（一边释放内存，一边执行后续代码）

cache 底层调的方法persist()

底层调用的是persist(),这个方法很灵活，里面可以传参数

可以通过该StorageLevel.MEMORY_ONLY ，进行缓存磁盘和内存，还可以组合缓存，甚至对数据序列化。序列化可以将数据压缩，节省空间，但是会多花一点时间。

在这里插入图片描述参数含义：
第一个参数，放到磁盘
第二个参数，放到内存
第三个参数，磁盘中的数据，不是以java对象的方式保存
第四个参数，内存中的数据，以java对象的方式保存

val MEMORY_AND_DISK = new StorageLevel(true, true, false, true)

带2是可以存副本，防止丢失

时间换空间，空间换时间

Checkpoint

在做了复杂的计算后，可以将数据Checkphoint，然后存入HDFS当中，保证数据安全。

1.迭代计算，保证数据安全
2.对速度的要求不高（相对于cache至内存当中）
3.中间结果存入HDFS

步骤

1.设置checkpoint的目录，通常是HDFS文件系统的目录
2.经过复杂计算得到中间结果
3.将中间结果checkpoint缓存到HDFS中
4后续的计算可以使用之前checkpoint的数据

val sc =SparkContext(conf)
//设置checkpoint的目录
sc.setCheckpointDir("hdfs://node-4:")
//对数据进行checkpoint
RDD.checkpoint()

归属地计算案例

首先将URL中的ip地址给提取出来，然后将IP地址根据ip规则转化成归属地，然后计算每个城市的用户数量。

URL

每条URL当中包含了一名顾客的许多信息，比如ip地址，操作系统等等

20090121000133331104000|123.197.66.93|www.pkwutai.cn|/down/downLoad-id-45383.html|Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; QQDownload 1.7)|http://www.baidu.com/s?tn=b1ank_pg&ie=gb2312&bs=%C3%C0%C6%BC%B7%FE%D7%B0%B9%DC%C0%ED%C8%ED%BC%FE&sr=&z=&cl=3&f=8&wd=%C6%C6%BD%E2%C3%C0%C6%BC%B7%FE%D7%B0%B9%DC%C0%ED%C8%ED%BC%FE&ct=0|

ip规则：

1.0.1.0|1.0.3.255|16777472|16778239|亚洲|中国|福建|福州||电信|350100|China|CN|119.306239|26.075302

规则解释：第一第二个字段是ip的起始和结束，然后第三第四就是ip起始和结束转化为十进制的形式，后面就是对应的地址。

将URL中提取ip，将ip转化为十进制，根据规则进行匹配，在该城市的ip区间，则将其城市输出。

二分法查找

二分法查找针对的是一个有序的数据集合,每次通过与区间的中间元素对比,将待查找的区间缩小为之前的一半,直到找到要查找的元素,或者区间被缩小为0

二分查找非常高效,假设数据大小是n,每次查找后数据都会缩小为原来的一半,也就是会除以2,最坏情况下,直到查找区间被缩小为空,才停止

单机计算ip地址

要求

需求:根据访问日志的ip地址计算出访问者的归属地,并且按照省份,计算出访问次数,然后将计算好的结果写入到SQL。
步骤：

1,整理数据,切分出ip字段,然后将ip地址转换成十进制
2然后将数据缓存到内存中( Executors中的内存中)
3,将访问log和ip规则进行匹配（二分法查找）
4.取出对份名称,然后将其和一组合在一起
5.按省份名进行累合
6.将累合后的数据写入到MySQL中

package cn.edu360.day4

import java.sql.{Connection, DriverManager, PreparedStatement}

import scala.io.{BufferedSource, Source}

/**
  * Created by zx on 2017/10/9.
  */

object MyUtils {
  //  将URL中的ip地址给提取出来
  def ip2Long(ip: String): Long = {
    val fragments = ip.split("[.]")
    var ipNum = 0L
    for (i <- 0 until fragments.length){
      ipNum =  fragments(i).toLong | ipNum << 8L
    }
    ipNum
  }
         //根据ip规则，从中提取出ip的起始和结尾将其转化十进制的起始和结尾，并且提取出来，还有省份
  def readRules(path: String): Array[(Long, Long, String)] = {
    //读取ip规则
    //从path中读取文件
    val bf: BufferedSource = Source.fromFile(path)
//取出每一行数据
    val lines: Iterator[String] = bf.getLines()
    //对ip规则进行整理，并放入到内存
    val rules: Array[(Long, Long, String)] = lines.map(line => {
      val fileds = line.split("[|]")
      val startNum = fileds(2).toLong
      val endNum = fileds(3).toLong
      val province = fileds(6)
      (startNum, endNum, province)
    }).toArray     //将它转成数组，则会放入内存当中
    rules
  }
     //二分法查找
  def binarySearch(lines: Array[(Long, Long, String)], ip: Long) : Int = {
    var low = 0
    var high = lines.length - 1
    while (low <= high) {
      val middle = (low + high) / 2
      if ((ip >= lines(middle)._1) && (ip <= lines(middle)._2))
        return middle
      if (ip < lines(middle)._1)
        high = middle - 1
      else {
        low = middle + 1
      }
    }
    -1   //如果没有查找到便输出-1
  }

     //将其存入sql
  def data2MySQL(it: Iterator[(String, Int)]): Unit = {
    //一个迭代器代表一个分区，分区中有多条数据
    //一个分区建立，获得一个JDBC连接
    val conn: Connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/bigdata?characterEncoding=UTF-8", "root", "123568")
    //将数据通过Connection写入到数据库
    val pstm: PreparedStatement = conn.prepareStatement("INSERT INTO access_log VALUES (?, ?)")
    //将分区中的数据一条一条写入到MySQL中
    it.foreach(tp => {
      pstm.setString(1, tp._1)
      pstm.setInt(2, tp._2)
      pstm.executeUpdate()
    })
    //将分区中的数据全部写完之后，在关闭连接
    if(pstm != null) {
      pstm.close()
    }
    if (conn != null) {
      conn.close()
    }
  }


  def main(args: Array[String]): Unit = {
    //数据是在内存中
    val rules: Array[(Long, Long, String)] = readRules("/Users/zx/Desktop/ip/ip.txt")
    //将ip地址转换成十进制
    val ipNum = ip2Long("114.215.43.42")
    //查找
    val index = binarySearch(rules, ipNum)
    //根据脚本到rules中查找对应的数据
    val tp = rules(index)
    val province = tp._3
    println(province)

  }
}

分布式处理计算ip地址1

在这里插入图片描述
步骤：

整理数据,切分出ip字段,然后将ip地址转换成十进制
然后将数据缓存到内存中( Executors中的内存中)
然后使用广播变量,将Drive端的数据广播到Executor中
将访问log和ip规则进行匹配（二分法查找），得出对应的城市
取出对份名称,然后将其和一组合在一起
按省份名进行累合
将累合后的数据写入到MySQL中

package cn.edu360.day4

import org.apache.spark.broadcast.Broadcast
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}


object IpLoaction1 {

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

    val conf = new SparkConf().setAppName("IpLoaction1").setMaster("local[4]")

    val sc = new SparkContext(conf)

    //在Driver端获取到全部的IP规则数据（全部的IP规则数据在某一台机器上，跟Driver在同一台机器上）
    //全部的IP规则在Driver端了（在Driver端的内存中了）
    //arg(0)存入的规则的存储地址
    val rules: Array[(Long, Long, String)] = MyUtils.readRules(args(0))

    //将Drive端的数据广播到Executor中
    //调用sc上的广播方法
    //广播变量的引用（还在Driver端）
    val broadcastRef: Broadcast[Array[(Long, Long, String)]] = sc.broadcast(rules)

    //创建RDD，读取访问日志，从HDFS中读取，arg（1）存其存储地址
    val accessLines: RDD[String] = sc.textFile(args(1))

    //这个函数是在哪一端定义的？（Driver）
    val func = (line: String) => {
      val fields = line.split("[|]")
      val ip = fields(1)
      //将ip转换成十进制
      val ipNum = MyUtils.ip2Long(ip)

      //进行二分法查找，通过Driver端的引用或取到Executor中的广播变量
      //（该函数中的代码是在Executor中别调用执行的，通过广播变量的引用，就可以拿到当前Executor中的广播的规则了）
      val rulesInExecutor: Array[(Long, Long, String)] = broadcastRef.value
      //查找
      var province = "未知"
      val index = MyUtils.binarySearch(rulesInExecutor, ipNum)
      if (index != -1) {
        province = rulesInExecutor(index)._3
      }
      (province, 1)
    }

    //整理数据
    val proviceAndOne: RDD[(String, Int)] = accessLines.map(func)

    //聚合
    //val sum = (x: Int, y: Int) => x + y
    val reduced: RDD[(String, Int)] = proviceAndOne.reduceByKey(_+_)

    //将结果打印
    val r = reduced.collect()

    println(r.toBuffer)

    sc.stop()



  }
}

分布式处理计算ip地址2

与上面的区别是，当ip规则过大的时候可以考虑将数据存储至HDFS中，用spark将数据读取至excutor当中，收集到driver，再次广播至各个excutor。

读取存储在HDFS中的IP规则
然后对ip规则进行处理
将分散在多个Executor中的部分IP规则收集到Driver端（collect）
将Driver端的数据广播到Executo
整理数据,切分出ip字段,然后将ip地址转换成十进制
将访问log和ip规则进行匹配（二分法查找），得出对应的城市
取出对份名称,然后将其和一组合在一起
按省份名进行累合
将累合后的数据写入到MySQL中

package cn.edu360.day4

import java.sql.{Connection, DriverManager, PreparedStatement}

import org.apache.spark.broadcast.Broadcast
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}



object IpLoaction2 {

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

    val conf = new SparkConf().setAppName("IpLoaction1").setMaster("local[4]")

    val sc = new SparkContext(conf)

    //取到HDFS中的ip规则
    val rulesLines:RDD[String] = sc.textFile(args(0))
    //整理ip规则数据
    val ipRulesRDD: RDD[(Long, Long, String)] = rulesLines.map(line => {
      val fields = line.split("[|]")
      val startNum = fields(2).toLong
      val endNum = fields(3).toLong
      val province = fields(6)
      (startNum, endNum, province)
    })

    //将分散在多个Executor中的部分IP规则收集到Driver端
    val rulesInDriver: Array[(Long, Long, String)] = ipRulesRDD.collect()

    //将Driver端的数据广播到Executor
    //广播变量的引用（还在Driver端）
    val broadcastRef: Broadcast[Array[(Long, Long, String)]] = sc.broadcast(rulesInDriver)

    //创建RDD，读取访问日志
    val accessLines: RDD[String] = sc.textFile(args(1))

    //整理数据
    val proviceAndOne: RDD[(String, Int)] = accessLines.map(log => {
      //将log日志的每一行进行切分
      val fields = log.split("[|]")
      val ip = fields(1)
      //将ip转换成十进制
      val ipNum = MyUtils.ip2Long(ip)
      //进行二分法查找，通过Driver端的引用或取到Executor中的广播变量
      //（该函数中的代码是在Executor中别调用执行的，通过广播变量的引用，就可以拿到当前Executor中的广播的规则了）
      //Driver端广播变量的引用是怎样跑到Executor中的呢？
      //Task是在Driver端生成的，广播变量的引用是伴随着Task被发送到Executor中的
      val rulesInExecutor: Array[(Long, Long, String)] = broadcastRef.value
      //查找
      var province = "未知"
      val index = MyUtils.binarySearch(rulesInExecutor, ipNum)
      if (index != -1) {
        province = rulesInExecutor(index)._3
      }
      (province, 1)
    })

    //聚合
    //val sum = (x: Int, y: Int) => x + y
    val reduced: RDD[(String, Int)] = proviceAndOne.reduceByKey(_+_)

    //将结果打印
    //val r = reduced.collect()
    //println(r.toBuffer)

    //该方法写入sql，每行调用一次jdbc连接，浪费资源
    /**
    reduced.foreach(tp => {
      //将数据写入到MySQL中
      //问？在哪一端获取到MySQL的链接的？
      //是在Executor中的Task获取的JDBC连接
      val conn: Connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/bigdata?charatorEncoding=utf-8", "root", "123568")
      //写入大量数据的时候，有没有问题？
      val pstm = conn.prepareStatement("...")
      pstm.setString(1, tp._1)
      pstm.setInt(2, tp._2)
      pstm.executeUpdate()
      pstm.close()
      conn.close()
    })
      */

   //一个分区调用建立一次JDBC连接，比较合理
    //一次拿出一个分区(一个分区用一个连接，可以将一个分区中的多条数据写完在释放jdbc连接，这样更节省资源)
//    reduced.foreachPartition(it => {
//      val conn: Connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/bigdata?characterEncoding=UTF-8", "root", "123568")
//      //将数据通过Connection写入到数据库
//      val pstm: PreparedStatement = conn.prepareStatement("INSERT INTO access_log VALUES (?, ?)")
//      //将一个分区中的每一条数据拿出来
//      it.foreach(tp => {
//        pstm.setString(1, tp._1)
//        pstm.setInt(2, tp._2)
//        pstm.executeUpdate()
//      })
//      pstm.close()
//      conn.close()
//    })

    reduced.foreachPartition(it => MyUtils.data2MySQL(it))


    sc.stop()



  }
}

heartless_killer

发布了44 篇原创文章 · 获赞 0 · 访问量 857

私信关注