Scala Reflection - Mirrors,ClassTag,TypeTag and WeakTypeTag

2024-04-09 04:58

本文主要是介绍Scala Reflection - Mirrors,ClassTag,TypeTag and WeakTypeTag,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

    反射reflection是程序对自身的检查、验证甚至代码修改功能。反射可以通过它的Reify功能来实时自动构建生成静态的Scala实例如:类(class)、方法(method)、表达式(expression)等。或者动态跟踪当前程序运算事件如:方法运算(method invocation)、字段引用(field access)等。反射又分编译时段与运算时段反射即:compile-time-reflection及runtime-reflection。我们使用compile-time-reflection在编译程序时指导编译器修改编译中代码或者产生新的代码,用runtime-reflection来进行实例的类型匹配、验证等。在v2.10之前,Scala没有自备的Reflection工具库,只能用Java Reflection库提供的部分功能来动态检验类型(class)或对象(object)及使用它们的字段(member access)。但java-reflection无法提供对某些scala项目的支持如:function、trait以及特殊类型如:existential、high-kinder、path-dependent、abstract types。特别是java-reflection无法获取泛类型在runtime过程中的信息,这个一直是一个诟病。直到scala2.10增加了新的reflection库才从根本上解决了针对scala特性的反射(refective)功能问题。scala-reflection同样提供了compile-time-reflection和runtime-reflection。其中compile-time-reflection是通过独立的macro库实现的。在这篇讨论里我们主要介绍runtime-reflection功能。

scala runtime-reflection有以下几项主要功能:

1、动态检验对象类型,包括泛类型

2、实时构建类型实例

3、实时调用类型的运算方法

反射功能可以在两种环境下体现:compile-time及runtime,是通过反射库的universe命名空间分辨的,即:

runtime-reflection     : scala.reflect.runtime.universe

compile-time-reflection: scala.reflect.macros.universe

我们必须import相应的命名空间来获取compile-time或runtime反射功能。

各种具体的runtime反射功能是通过Mirror来获取的,以runtimeMirror(...)为入口。下面是各种Mirror的获取和使用方法示范:

 val ru = scala.reflect.runtime.universe//runtime reflection入口val m = ru.runtimeMirror(getClass.getClassLoader)  //m: ru.Mirror = JavaMirror with java.net.URLClassLoader...//sample classclass Person(name: String, age: Int) {var hight: Double = 0.0def getName = name}val john = new Person("John", 23) {hight = 1.7}//instance mirrorval im = m.reflect(john)//im: ru.InstanceMirror = instance mirror for...//query method on instanceval mgetName = ru.typeOf[Person].decl(ru.TermName("getName")).asMethod//mgetName: ru.MethodSymbol = method getName//get methodval invoke_getName = im.reflectMethod(mgetName) //invoke_getName: ru.MethodMirror = ...invoke_getName()//res0: Any = John//query field on instanceval fldHight = ru.typeOf[Person].decl(ru.TermName("hight")).asTerm//fldHight: ru.TermSymbol = variable hight//get fieldval fmHight = im.reflectField(fldHight) //fmHight: ru.FieldMirror = ...fmHight.get //res1: Any = 1.7fmHight.set(1.6)fmHight.get//res3: Any = 1.6val clsP = ru.typeOf[Person].typeSymbol.asClass//get class mirrorval cm = m.reflectClass(clsP)//get constructor symbolval ctorP = ru.typeOf[Person].decl(ru.nme.CONSTRUCTOR).asMethod//get contructor mirrorval ctorm = cm.reflectConstructor(ctorP)val mary = ctorm("mary", 20).asInstanceOf[Person]println(mary.getName)    // maryobject OB {def x = 3}//get object symbolval objOB = ru.typeOf[OB.type].termSymbol.asModule//get module mirrorval mOB = m.reflectModule(objOB)//get object instanceval instOB = mOB.instance.asInstanceOf[OB.type]println(instOB.x)  // 3


上面例子里的typeOf[T]和typeTag[T].tpe及implicitly[TypeTag[T]].tpe是通用的,看下面的示范:

  val clsP = ru.typeTag[Person].tpe.typeSymbol.asClass  //ru.typeOf[Person].typeSymbol.asClassval clsP1 = implicitly[ru.TypeTag[Person]].tpe.typeSymbol.asClass //clsP1: ru.ClassSymbol = class Personval clsP2 = ru.typeTag[Person].tpe.typeSymbol.asClass //clsP2: ru.ClassSymbol = class Person

讲到TypeTag[T],这本是一个由compiler产生的结构,可以把在编译时段(compile-time)类型T的所有信息带到运算时段(runtime)。主要目的可能是为了解决JVM在编译过程中的类型擦拭(type erasure)问题:在运算过程中可以从TypeTag[T]中获取T类型信息(通过typeTag[T]),最终实现类型T的对比验证等操作:

 def getType[T: ru.TypeTag](obj: T) = ru.typeTag[T].tpe//> getType: [T](obj: T)(implicit evidence$1: ru.TypeTag[T]) ru.Typedef getType2[T: ru.TypeTag](obj: T) = ru.typeOf[T]//> getType2: [T](obj: T)(implicit evidence$2: ru.TypeTag[T]) ru.TypegetType(List(1,2)) =:= getType2(List(3,4))       //> res0: Boolean = truegetType(List(1,2)) =:= getType2(List(3.0,4.0))   //> res1: Boolean = falsegetType(List(1,2)) =:= ru.typeOf[List[Int]]      //> res2: Boolean = true

以上是通过隐式参数(implicit parameters)或者上下文界线(context bound)来指示compiler产生TypeTag[T]结构的。

我们可能经常碰到TypeTag的调用例子,还有WeakTypeTag和ClassTag。ClassTag应该是有明显区别的,因为它在另外一个命名空间里:

 import scala.reflect.ClassTagdef extract[T: ClassTag](list: List[Any]) =  list.flatMap {case elem: T => Some(elem)case _ => None}    //> extract: [T](list: List[Any])(implicit evidence$3: scala.reflect.ClassTag[T] )List[T]extract[String](List(1,"One",2,3,"Four",List(5)))//> res4: List[String] = List(One, Four)


ClassTag在scala.reflect.ClassTag里。这个extract函数的目的是把T类型的值过滤出来。上面的例子里list里的String元素被筛选出来了。但是如果我们像下面这样使用extract呢?

extract[List[Int]](List(List(1,2),List("a","b")))//> res5: List[List[Int]] = List(List(1, 2), List(a, b))


这次extract得出错误的运算结果,因为我们指明的是过滤List[Int]。这是因为ClassTag不支持高阶类型,List[Int]就是个高阶类型。那么extract[String]是怎样正确工作的呢?是因为compiler对模式匹配进行了这样的转换处理:

case elem: T >>> case elem @tag(_:T)

通过ClassTag[T]隐式实例(implicit instance)可以正确推导出elem的类型。在上面的例子里我们通过ClassTag得出T就是String。分析得出ClassTag可以分辨基础类型但无法分辨像List[Int],List[String]这样的高阶类型。

TypeTag包含了完整的类型信息可以分辨List[Int],List[String],甚至List[Set[Int]],List[Set[String]]这样的高阶类型。也就是TypeTag结构内包含了高阶类型内包嵌的类型,只有如此才能解决类型擦拭(type erasure)问题。我们用下面的例子来示范TypeTag的内容:

 def getInnerType[T: ru.TypeTag](obj: T) = ru.typeTag[T].tpe match {case ru.TypeRef(utype,usymb,args) =>List(utype,usymb,args).mkString("\n")}      //> getInnerType: [T](obj: T)(implicit evidence$4: worksheets.reflect.ru.TypeTag[T])StringgetInnerType(List(1,2))                          //> res6: String = scala.collection.immutable.type//| class List//| List(Int)getInnerType(List(List(1,2)))                    //> res7: String = scala.collection.immutable.type//| class List//| List(List[Int])getInnerType(Set(List(1,2)))                     //> res8: String = scala.collection.immutable.type//| trait Set//| List(List[Int])getInnerType(List(Set("a","b")))                 //> res9: String = scala.collection.immutable.type//| class List//| List(scala.collection.immutable.Set[java.lang.String])

上面的例子里getInnerType可以分辨高阶类型内的类型,args就是承载这个内部类型的List。那么如果我们为extract函数提供一个TypeTag又如何呢?看看下面的示范:

 def extract[T: ru.TypeTag](list: List[Any]) =  list.flatMap {case elem: T => Some(elem)case _ => None}    //> extract: [T](list: List[Any])(implicit evidence$3: ru.TypeTag[T])List[T]extract[String](List(1,"One",2,3,"Four",List(5)))//> res4: List[String] = List(1, One, 2, 3, Four, List(5))extract[List[Int]](List(List(1,2),List("a","b")))//> res5: List[List[Int]] = List(List(1, 2), List(a, b))


可以看到,虽然compiler产生并提供了TypeTag隐式参数evidence$3,但运算结果并不正确,这是为什么呢?从这个例子可以证实了ClassTag和TypeTag最大的区别:ClassTag在运算时提供了一个实例的类型信息,而TypeTag在运算时提供了一个类型的完整信息。我们只能用ClassTag来比较某个值的类型,而在运算时用TypeTag只能进行类型对比。extract中elem是List里的一个元素,是个值,所以只能用ClassTag来判别这个值的类型。如果使用TypeTag的话我们只能实现像下面示例中的类型对比:

 def meth[T: ru.TypeTag](xs: List[T]) = ru.typeTag[T].tpe match {case t if t =:= ru.typeOf[Int] => "list of integer"case t if t =:= ru.typeOf[List[String]] => "list of list of string"case t if t =:= ru.typeOf[Set[List[Int]]] => "list of set of list of integer"case _ => "some other types"}     //> meth: [T](xs: List[T])(implicit evidence$5: ru.TypeTag[T])Stringmeth(List(1,2,3))                                //> res10: String = list of integermeth(List("a","b"))                              //> res11: String = some other typesmeth(List(List("a","a")))                        //> res12: String = list of list of stringmeth(List(Set(List(1,20))))                      //> res13: String = list of set of list of integer


我们只能在运算时对T进行类型匹配。总结以上分析,ClassTag与TypeTag有下面几点重要区别:

1、ClassTag不适用于高阶类型:对于List[T],ClassTag只能分辨是个List,但无法获知T的类型。所以ClassTag不能用来解决类型擦拭(type erasure)问题

2、TypeTag通过完整的类型信息可以分辨高阶类型的内部类型,但它无法提供运算时(runtime)某个实例的类型。总的来说:TypeTag提供了runtime的类型信息,ClassTag提供runtime实例信息(所以ClassTag就像typeclass,能提供很多类型的隐型实例)

那么这个WeakTypeTag又是用来干什么的?它与TypeTag又有什么分别呢?如果我们把上面的meth函数改成使用WeakTypeTag:

 def meth[T: ru.WeakTypeTag](xs: List[T]) = ru.weakTypeTag[T].tpe match {case t if t =:= ru.typeOf[Int] => "list of integer"case t if t =:= ru.typeOf[List[String]] => "list of list of string"case t if t =:= ru.typeOf[Set[List[Int]]] => "list of set of list of integer"case _ => "some other types"}      //> meth: [T](xs: List[T])(implicit evidence$5: ru.WeakTypeTag[T])Stringmeth(List(1,2,3))                                //> res10: String = list of integermeth(List("a","b"))                              //> res11: String = some other typesmeth(List(List("a","a")))                        //> res12: String = list of list of stringmeth(List(Set(List(1,20))))                      //> res13: String = list of set of list of integer


结果与使用TypeTag一致,好像WeakTypeTag和TypeTag没什么分别。从字面解释,WeakTypeTag应该在某些方面要求比较松。在上面的例子里调用meth函数时我们提供了一个实质类型如:List[Int],List[String],List[List[Int]]等。如果我们只能提供像List[T]这样的抽象类型的话,compiler一定会吵闹,像下面的示范:

// def foo[T] = ru.typeTag[T]         //> No TypeTag available for Tdef foo[T] = ru.weakTypeTag[T]       //> foo: [T]=> worksheets.reflect.ru.WeakTypeTag[T]


看来WeakTypeTag可以支持抽象类型。我们再看看下面的示范:

abstract class SomeClass[T] {def getInnerWeakType[T: ru.WeakTypeTag](obj: T) = ru.weakTypeTag[T].tpe match {case ru.TypeRef(utype,usymb,args) =>List(utype,usymb,args).mkString("\n")}val list: List[T]val result = getInnerWeakType(list)
}
val sc = new SomeClass[Int] { val list = List(1,2,3) }//> sc  : SomeClass[Int] 
println(sc.result)                                //> scala.type//| type List//| List(T)


首先我们可以得出List[T]的内部类型就是T。更重要的是如果不使用WeakTypeTag的话getInnerWeakType(list)根本无法通过编译。















这篇关于Scala Reflection - Mirrors,ClassTag,TypeTag and WeakTypeTag的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/887225

相关文章

【scala 安装错误】错误: 找不到或无法加载主类 scala.tools.nsc.MainGenericRunner

错误: 找不到或无法加载主类 scala.tools.nsc.MainGenericRunner 原因: Scala安装路径中包含空格。 解决办法:scala 不要安装在E:\Program Files 这种有空格的目录下,简直坑

Scala模式匹配下提取器构造

示例代码: object :> {def unapply[A] (list:List[A]) = {Some( (list.init,list.last) )}}object Extractor_Advanced {def main(args: Array[String]): Unit = {(1 to 9).toList match{ case _ :> 9 => println(

从spark源码的角度思考scala中的模式匹配

1.scala中模式匹配 2.spark源码中的模式匹配思考 spark中master会收到worker发过来的akka的消息, 此消息是case class即(Master.class中): case class RegisterWorker(id:String,host:String,port:Int,cores:Int,memory:Int,webUiPort:int

Scala界面事件处理

示例代码: import scala.swing.SimpleSwingApplicationimport scala.swing.MainFrameimport scala.swing.Buttonimport scala.swing.Labelimport scala.swing.Orientationimport scala.swing.BoxPanelimpo

Scala界面Panel、Layout初探

示例代码: package com.dt.scala.guiimport scala.swing.SimpleSwingApplicationimport scala.swing.MainFrameimport scala.swing.Buttonimport scala.swing.Labelimport scala.swing.Orientationimport scal

scala界面GUI编程实战初步了解

示例代码: import scala.swing._//SimpleSwingApplication继承自SwingApplication类(此类中有main方法,因此可以运行显示界面)object Hello_GUI extends SimpleSwingApplication {def top = new MainFrame{ //顶级容器title = "Hello GUI"co

Scala并发编程react、loop代码实战详解

示例代码及注释: //scala并发编程中的react和loop,共同特点://通过线程存用的方式让性能有所提升。//Actor本身的运行,被actor子系统管理的时候,会有一个或者多个远程的线程让当前的actor使用//一般情况下每个Actor都有自己的线程。只有有自己的线程时,我们的Actor中的actor方法才会执行。//但是,这样线程的开销会非常大,所以为了共用线

scala并发编程原生线程Actor、Case Class下的消息传递和偏函数实战

参考代码: import scala.actors._case class Person(name:String,age:Int)class HelloActor extends Actor{def act(){while(true){receive{case Person(name,age)=>{ //偏函数println("Name: "+ name + ":" +"Age:"

scala基础概念

Scala是面向行的语言,Scala 语句末尾的分号写或者不写都可以。 对象 - 对象有属性和行为。例如:一只哈士奇的属性有:颜色,名字,行为有:叫、跑、吃等。对象是一个类的实例。 类 - 类是对象的抽象;对象是类的具体实例。 方法 - 方法描述的基本的行为,一个类可以包含多个方法。 字段 - 每个对象都有它唯一的实例变量集合,即字段。对象的属性通过给字段赋值来创建。 基本语法

Scala:Scala基础语法【Scala语言是一个完全面向对象编程语言-->万物皆对象;Scala语言是一个完全函数式编程语言-->万物皆函数】

一、变量和数据类型 1、变量 说明:在Scala中声明一个变量时,可以不指定类型,编译器根据值确定 var | val 变量名 [: 变量类型] = 变量值 声明变量时,类型可以省略(编译器自动推导,即类型推导)类型确定后,就不能修改,说明Scala是强数据类型语言。变量声明时,需要初始值object TestVar {def main(args: Array[String]): Uni