SPark学习笔记：11 SparkSQL 的用户自定义函数UDF、UDAF、UDTF

最新推荐文章于 2024-04-01 09:25:04 发布

wangzhongyudie

最新推荐文章于 2024-04-01 09:25:04 发布

阅读量1.3k

点赞数

分类专栏： Spark 大数据文章标签： spark 学习 scala

本文链接：https://blog.csdn.net/wangzhongyudie/article/details/126107509

版权

大数据同时被 2 个专栏收录

47 篇文章 2 订阅

订阅专栏

Spark

13 篇文章 1 订阅

订阅专栏

文章目录

UDF 用户自定义函数(一对一)
UDAF 用户自定义聚合函数(多对一)
UDTF 用户自定义表函数(一对多)
- 说明：
- 实现

UDF 用户自定义函数(一对一)

说明

UDF输入一条记录，输出一条记录，一对一的关系，有点类似于map算子，是一对一的关系

使用

UDF的使用有两种方式，一种方式是在SQL中使用，另一种方式是在DSL方式使用

使用SQL的方式

val myconcat3 = sparkSession.udf.register("myconcat3",new MyConcat)

sparkSession.sql("select myconcat3(id,timestamp) as newid,temperature")

在DSL中使用

val myconcat3 = sparkSession.udf.register("myconcat3",new MyConcat)

df.select(myconcat3($"id",$"timestamp") as "newid",$"temperature").show()

实现方式

UDF函数有3中实现方式：

使用匿名函数

val myconcat = sparkSession.udf.register("myconcat",(data1:String,data2:Long)=>{
  data1.concat(data2.toString)
})

使用udf函数实现

//引入udf方法
import org.apache.spark.sql.functions.{col, udf}
val myconcat2 = udf[String,String,Long]((data1:String,data2:Long)=>{
  data1.concat(data2.toString)
})

说明： udf函数可以有多个输入参数，如上述我们实现的是两个输入参数则udf的原型是udf[R,T1,T2]

R表示返回值的类型，T1表示第一个参数的类型，T2表示第2个参数的类型

继承Function函数接口的方式

class MyConcat extends Function2[String,Long,String] with Serializable{
override def apply(v1: String, v2: Long): String = {
  v1.concat(v2.toString)
}
}

说明：Function2[T1,T2,R]

因为我们要实现的UDF有两个输入参数，所以需要继承的是Function2
T1 表示第一个参数的类型，T2表示第二个参数的类型
R表示是返回值的类型
继承Function Trait的时候，还需要继承Serializable接口，不然会报错。

完整示例

package com.hjt.yxh.hw.sql

import org.apache.spark.SparkConf
import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.functions.{col, udf}

object UDFApp {
  def main(args: Array[String]): Unit = {
    val conf:SparkConf = new SparkConf()
    conf.setMaster("local[*]").setAppName("UDFApp")

    val sparkSession:SparkSession = SparkSession.builder()
      .config(conf)
      .config("spark.sql.legacy.charVarcharAsString",true)
      .getOrCreate()

    import sparkSession.implicits._

    val inpath = "D:\\javaworkspace\\BigData\\Spark\\SparkApp\\src\\main\\resources\\sensor.txt"
    val df = sparkSession.read
      .format("csv")
      .schema("id VARCHAR(32),timestamp BIGINT,temperature DECIMAL(5,2)")
      .load(inpath)

    df.show(false)

    //方式一，使用匿名函数实现
    val myconcat = sparkSession.udf.register("myconcat",(data1:String,data2:Long)=>{
      data1.concat(data2.toString)
    })
    df.select(myconcat($"id",$"timestamp") as "newid",$"temperature").show()

    //方式二、使用udf函数实现
    val myconcat2 = udf[String,String,Long]((data1:String,data2:Long)=>{
      data1.concat(data2.toString)
    })

    sparkSession.udf.register("myconcat2",myconcat2)
    df.select(myconcat2($"id",$"timestamp") as "newid",$"temperature").show()

    //方式三、继承类的方式
    val myconcat3 = sparkSession.udf.register("myconcat3",new MyConcat)

    df.select(myconcat3($"id",$"timestamp") as "newid",$"temperature").show()

    sparkSession.close()
  }

  class MyConcat extends Function2[String,Long,String] with Serializable{
    override def apply(v1: String, v2: Long): String = {
      v1.concat(v2.toString)
    }
  }
}

Tips:我们在指定schema中使用VARCHAR类型时会报错，因为spark默认是没有开启VARCHAR或者CHAR类型支持的，需要设置一下参数spark.sql.legacy.charVarcharAsString为true

val sparkSession:SparkSession = SparkSession.builder()
  .config(conf)
  .config("spark.sql.legacy.charVarcharAsString",true)
  .getOrCreate()

UDAF 用户自定义聚合函数(多对一)

说明

UDAF是用户自定义聚合函数，一次输入多行做聚合运算输出一个聚合值作为输出结果。

使用

UDF的使用有两种方式，一种方式是在SQL中使用，另一种方式是在DSL方式使用

使用SQL的方式

val myavg = udaf(new MyAggregator)
sparkSession.udf.register("myavg",myavg)
sparkSession.sql("select id,myavg(temperature) from sensor group by id ").show()

在DSL中使用

val myavg = udaf(new MyAggregator)
sparkSession.udf.register("myavg",myavg)

ds.groupBy("id").agg(myavg($"temperature")).show()

实现方式

方式一：实现自定义Aggregator的方式，Spark3.0中是官方推荐的实现方式

自定义Aggregator的方式需要继承实现Aggregator[IN,BUF,OUT]类。

* IN 输入到聚合运算中的数据类型
* BUF 聚合缓冲区的数据类型
* OUT 结果输出数据类型

弱类型的UDAF的实现

case class AggBuffer(var count:Long,var sum:Double)

class MyAggregator extends Aggregator[Double,AggBuffer,Double]{

  //初始化buffer
  override def zero: AggBuffer = {
    AggBuffer(0,0)
  }

  //reduce操作
  override def reduce(b: AggBuffer, a: Double): AggBuffer = {
    b.count+=1
    b.sum+=a
    b
  }

  //合并多个buffer
  override def merge(b1: AggBuffer, b2: AggBuffer): AggBuffer = {
    b1.sum+= b2.sum
    b1.count += b2.count
    b1
  }

  //取结果输出
  override def finish(reduction: AggBuffer): Double = {
    reduction.sum/reduction.count
  }

  //buffer的序列化器(对于自定义的case类是固定写法，Encoders.product)
  override def bufferEncoder: Encoder[AggBuffer] = Encoders.product

  //输出的序列化器(对于自定义的case类是固定写法，Encoders.product)
  override def outputEncoder: Encoder[Double] = Encoders.scalaDouble
}

package com.hjt.yxh.hw.sparksql

import com.hjt.yxh.hw.transmate.SensorReading
import org.apache.spark.SparkConf
import org.apache.spark.sql.{Dataset, Encoder, Encoders, SparkSession}
import org.apache.spark.sql.expressions.Aggregator
import org.apache.spark.sql.functions.{avg, udaf}


case class AggBuffer(var count:Long,var sum:Double)

class MyAggregator extends Aggregator[Double,AggBuffer,Double]{

  //初始化buffer
  override def zero: AggBuffer = {
    AggBuffer(0,0)
  }

  //reduce操作
  override def reduce(b: AggBuffer, a: Double): AggBuffer = {
    b.count+=1
    b.sum+=a
    b
  }

  //合并多个buffer
  override def merge(b1: AggBuffer, b2: AggBuffer): AggBuffer = {
    b1.sum+= b2.sum
    b1.count += b2.count
    b1
  }

  //取结果输出
  override def finish(reduction: AggBuffer): Double = {
    reduction.sum/reduction.count
  }

  //buffer的序列化器(对于自定义的case类是固定写法，Encoders.product)
  override def bufferEncoder: Encoder[AggBuffer] = Encoders.product

  //输出的序列化器(对于自定义的case类是固定写法，Encoders.product)
  override def outputEncoder: Encoder[Double] = Encoders.scalaDouble
}

object UDAFApp {

  def main(args: Array[String]): Unit = {
    val conf:SparkConf = new SparkConf()
    conf.setMaster("local[*]")
      .setAppName("UDAFApp")

    val sparkSession:SparkSession = SparkSession.builder()
      .config(conf)
      .config("spark.sql.legacy.charVarcharAsString",true)
      .getOrCreate()
    import sparkSession.implicits._

    val inpath = "D:\\javaworkspace\\BigData\\Spark\\SparkApp\\src\\main\\resources\\sensor.txt"

    val df = sparkSession.read.format("CSV")
      .schema("id VARCHAR(32), timestamp BIGINT,temperature Double")
      .load(inpath)

    val ds:Dataset[SensorReading] = df.as[SensorReading]
    ds.createOrReplaceTempView("sensor")

    ds.show()
    val myavg = udaf(new MyAggregator)
    sparkSession.udf.register("myavg",myavg)

    ds.groupBy("id").agg(myavg($"temperature")).show()

    sparkSession.stop()

  }
}

强类型的UDAF实现示例

package com.hjt.yxh.hw.sparksql

import org.apache.spark.SparkConf
import org.apache.spark.sql._
import org.apache.spark.sql.expressions.Aggregator


case class AggBuffer(var count:Long,var sum:Double)
case class SensorReading(id:String,timestamp:BigInt,temperature:Double)

class MyAggregator extends Aggregator[SensorReading,AggBuffer,Double]{

  //初始化buffer
  override def zero: AggBuffer = {
    AggBuffer(0,0)
  }

  //reduce操作
  override def reduce(b: AggBuffer, a: SensorReading): AggBuffer = {
    b.count+=1
    b.sum+=a.temperature
    b
  }

  //合并多个buffer
  override def merge(b1: AggBuffer, b2: AggBuffer): AggBuffer = {
    b1.sum+= b2.sum
    b1.count += b2.count
    b1
  }

  //取结果输出
  override def finish(reduction: AggBuffer): Double = {
    reduction.sum/reduction.count
  }

  //buffer的序列化器(对于自定义的case类是固定写法，Encoders.product)
  override def bufferEncoder: Encoder[AggBuffer] = Encoders.product

  //输出的序列化器(对于自定义的case类是固定写法，Encoders.product)
  override def outputEncoder: Encoder[Double] = Encoders.scalaDouble
}

object UDAFApp {

  def main(args: Array[String]): Unit = {
    val conf:SparkConf = new SparkConf()
    conf.setMaster("local[*]")
      .setAppName("UDAFApp")

    val sparkSession:SparkSession = SparkSession.builder()
      .config(conf)
      .config("spark.sql.legacy.charVarcharAsString",true)
      .getOrCreate()
    import sparkSession.implicits._

    val inpath = "D:\\javaworkspace\\BigData\\Spark\\SparkApp\\src\\main\\resources\\sensor.txt"

    val df = sparkSession.read.format("CSV")
      .schema("id VARCHAR(32), timestamp BIGINT,temperature Double")
      .load(inpath)

    val ds:Dataset[SensorReading] = df.as[SensorReading]
    ds.createOrReplaceTempView("sensor")

    val myavg = new MyAggregator().toColumn.name("avg_temperature")
    sparkSession.udf.register("myavg",functions.udaf(new MyAggregator()))

    val ret = ds.select(myavg)

    sparkSession.stop()

  }
}

方式二继承UserDefinedAggregateFunction的方式(在新的版本中已移除)

class MyAvg extends UserDefinedAggregateFunction{

  //定义输入的数据结构
  override def inputSchema: StructType = new StructType()
    .add("temperature","double")


  //定义缓冲区的数据结构
  override def bufferSchema: StructType = new StructType()
    .add("count",LongType)
    .add("sum",DoubleType)

  //定义输出的数据类型
  override def dataType: DataType = DataTypes.DoubleType


  override def deterministic: Boolean = true

  //初始化缓冲区
  override def initialize(buffer: MutableAggregationBuffer): Unit = {
    buffer.update(0,0L)
    buffer.update(1,0.0)
  }

  //做更新缓冲区操作，相当用reduce
  override def update(buffer: MutableAggregationBuffer, input: Row): Unit = {
    var count = buffer.getLong(0)
    var sum = buffer.getDouble(1)
    count+= 1
    sum+= input.getDouble(0)
    buffer.update(0,count)
    buffer.update(1,sum)
  }
  //合并两个缓存去
  override def merge(buffer1: MutableAggregationBuffer, buffer2: Row): Unit = {
    buffer1.update(0,buffer1.getLong(0)+buffer2.getLong(0))
    buffer1.update(1,buffer1.getDouble(1)+buffer2.getDouble(1))
  }

  //计算结果，并输出
  override def evaluate(buffer: Row): Any = {
    buffer.getDouble(1)/buffer.getLong(0)
  }
}

UDTF 用户自定义表函数(一对多)

说明：

SparkSQL本身其实是没有提供UDTF函数功能的，需要启用Hive支持的方式才能使用。

实现

class MySplit extends GenericUDTF {

  override def initialize(argOIs: Array[ObjectInspector]): StructObjectInspector = {
    //判断传入的参数是否只有一个
    if (argOIs.length != 1) {
      throw new UDFArgumentException("有且只能有一个参数")
    }
    //判断参数类型
    if (argOIs(0).getCategory != ObjectInspector.Category.PRIMITIVE) {
      throw new UDFArgumentException("参数类型不匹配")
    }
    val fieldNames = new util.ArrayList[String]
    val fieldOIs = new util.ArrayList[ObjectInspector]
    fieldNames.add("type")
    fieldOIs.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector)
    ObjectInspectorFactory.getStandardStructObjectInspector(fieldNames, fieldOIs)
  }
    
  override def process(objects: Array[AnyRef]): Unit = {
    val data_list:Array[String] = objects(0).toString.split("_")
    //遍历集合
    for(item <- data_list){
      val temp = new Array[String](1)
      temp(0)=item
      forward(temp)
    }
  }

  override def close(): Unit = {}
}


object UDTFApp {

  def main(args: Array[String]): Unit = {
    val conf:SparkConf = new SparkConf()
    conf.setMaster("local[*]").setAppName("UDTFTest")

    val sparkSession:SparkSession = SparkSession.builder().enableHiveSupport().config(conf).getOrCreate()
    import sparkSession.implicits._

    val inpath:String = "D:\\javaworkspace\\BigData\\Spark\\SparkApp\\src\\main\\resources\\sensor.txt"
    val df1 = sparkSession.read.format("csv")
      .schema("id String,timestamp Bigint,temperature double")
      .load(inpath)
    
    //注册表
    df1.createOrReplaceTempView("sensor")
    
    //创建函数，使用类名的方式
    sparkSession.sql("create TEMPORARY function mySplit as 'com.hjt.yxh.hw.sql.MySplit'")

    sparkSession.sql("select mySplit(id) from sensor").show()

    sparkSession.stop()
  }

}