没有适用于案例类别Type的TypeTag

Question

我想生成一个将Object转换为Map[String, _] ，然后从Map[String, _]为Object 。

我生成初始对象，如下所示：

  case class Name (firstName : String, lastName : String)
  case class Documents (idx: String, name: Name, code: String)

  val mName1 = Name("Roger", "Rabbit")
  val myDoc = Documents("12", mName1, "ABCD")

然后，以下方法将给定的Map[String, _]转换为Object ：

def fromMap[T : TypeTag: ClassTag ](m: Map[String,_]) = {
    val rm = runtimeMirror(classTag[T].runtimeClass.getClassLoader)
    val classTest = typeOf[T].typeSymbol.asClass
    val classMirror = rm.reflectClass(classTest)
    val constructor = typeOf[T].decl(termNames.CONSTRUCTOR).asMethod
    val constructorMirror = classMirror.reflectConstructor(constructor)

    val constructorArgs = constructor.paramLists.flatten.map( (param: Symbol) => {
      val paramName = param.name.toString
      if(param.typeSignature <:< typeOf[Option[Any]])
        m.get(paramName)
      else
        m.get(paramName).getOrElse(throw new IllegalArgumentException("Map is missing required parameter named " + paramName))
    })

    constructorMirror(constructorArgs:_*).asInstanceOf[T]
  }

在以下方法中，我将初始Object转换为Map[String, _] ，然后又返回Object （通过调用上述方法）：

def fromMapToObject(input: Any) : Unit= {

    println("input: "+input)

    //Converting an Object into a Map
    val r = currentMirror.reflect(input)
    val docAsMapValues = r.symbol.typeSignature.members.toStream
      .collect{case s : TermSymbol if !s.isMethod => r.reflectField(s)}
      .map(r => r.symbol.name.toString.trim -> r.get)
      .toMap

    println("intermediate: "+docAsMapValues)


    val obj = fromMap[Documents](docAsMapValues)
    println("output: "+obj)

  }

因此，如果我致电：

 fromMapToObject(myDoc)

输入和输出将匹配。

问题 ，尝试更进一步，我现在想对字段name （类型为Name 。 但是我希望此步骤是通用的，因为在不知道字段name的类型的情况下，我可以将其转换为Map[String, _] ，然后从Map[String, _]回Object 。

所以我现在在fromMapToObject中要做的是：

1. 从输入中提取Map[String, _]
2. 从输入中提取Map[String, Types]
3. 将字段name的值从Name转换为Map[String, _]
4. 还原第3步以取回Name类型的Object

这就是我试图处理这种新情况的方式：

def fromMapToObject[T: TypeTag: ClassTag](input: Any) : Unit = {

    println("input: "+input)

    //Converting an Object into a Map
    val r = currentMirror.reflect(input)
    val docAsMapValues = r.symbol.typeSignature.members.toStream
      .collect{case s : TermSymbol if !s.isMethod => r.reflectField(s)}
      .map(r => r.symbol.name.toString.trim -> r.get)
      .toMap

    val docAsMapTypes = r.symbol.typeSignature.members.toStream
      .collect{case s : TermSymbol if !s.isMethod => r.reflectField(s)}
      .map(r => r.symbol.name.toString.trim -> r.symbol.typeSignature)
      .toMap

    // Here I extract from the map the value and type of the attribute name 
    val nameType = docAsMapValues("name")
    val nameValue =  docAsMapValues("name")

    // Converting Name into a map
    val r2 = currentMirror.reflect(nameValue)
    val nameAsMapValues = r2.symbol.typeSignature.members.toStream
      .collect{case s : TermSymbol if !s.isMethod => r2.reflectField(s)}
      .map(r2 => r2.symbol.name.toString.trim -> r2.get)
      .toMap

    type nameT = nameType.type
    val obj = fromMap[nameT](nameAsMapValues)

}

但是在Intellij中编译时出现以下错误：

Error:(111, 29) No TypeTag available for nameT
    val obj = fromMap[nameT](nameAsMapValues)

我想知道如何将r.symbol.typeSignature返回的runtime.universe.Type转换为TypeTag : ClassTag

Answer 1

我不确定我是否正确解释了您的问题，但是据我了解，这可以很好地解决并且可以通过无形安全键入。 首先，您需要将Document转换为Map 。 shapeless可以在该类型类的一个为你做这个现成的ops文件夹中。 如果我们将其捆绑为一个函数，并使用某种机器将所有内容组合在一起，我们将得到类似以下内容的信息：

import shapeless._

def ObjectToMap[A, Repr <: HList](obj: A)(
  implicit
  gen: LabelledGeneric.Aux[A,Repr], //Convert to generic representation
  toMap: ops.record.ToMap[Repr] //Convert generic representation to Map[Symbol,_]
) = toMap(gen.to(obj))

哪个输出

val m = ObjectToMap(myDoc)
println(m) //Map('code -> ABCD, 'name -> Name(Roger,Rabbit), 'idx -> 12)

往另一个方向走比较复杂。 存在一个ops.maps.FromMap类型类。 但是，我们希望能够指定type参数，然后让编译器仍然验证泛型表示形式为HList ，以与FromMap的签名匹配。 由于从属类型不能与在同一参数列表中定义的其他变量一起使用，并且我们只能得到一个隐式参数列表，因此我们需要采取一些技巧来控制类型参数：

trait MapToObject[A]{
  def from[Repr <: HList](m: Map[_,_])(
    implicit
    gen: LabelledGeneric.Aux[A,Repr],
    fromMap: ops.maps.FromMap[Repr]
  ): Option[A] = fromMap(m).map(gen.from)
}

object MapToObject{
  def apply[A](
    implicit gen: LabelledGeneric[A]
  ): MapToObject[A] = new MapToObject[A]{}
}

当我们运行前一个块的输出时，我们得到：

val doc = MapToObject[Documents].from(m)
println(doc) //Some(Documents(12,Name(Roger,Rabbit),ABCD))

Answer 2

type nameT = nameType.type不正确。 nameType.type是此特定变量nameType （单例）类型，并且您需要name字段的类型。 这是偶然的，因为实际上您不在fromMap2使用T （ runtimeMirror(classTag[T].runtimeClass.getClassLoader)可以在那里替换为currentMirror ）。

你想叫你的原始fromMap内fromMapToObject 。 你知道universe.Type的name和它足以找到TypeTag和ClassTag隐参数fromMap 。 但这还不足以找到T 事实是，由于您使用运行时反射， ClassTag在运行时知道universe.Type （以及TypeTag和ClassTag ）。 但是要调用fromMap您需要在编译时知道T 因此，一种方法是使用编译时反射，即宏。 另一种方法是避免T并像您一样使用值参数。

要在Scala中映射的案例类

Scala：将地图转换为案例类

Answer 3

我找到了解决方案。 由于我无法获取classTag和typeTag将函数toMap修改如下：

def fromMap2[T : ClassTag ](m: Map[String,_], mSymbol: Symbol, mType :Type): Any = {
    val rm = runtimeMirror(classTag[T].runtimeClass.getClassLoader)
    val classTest = mSymbol.asClass
    val classMirror = rm.reflectClass(classTest)
    val constructor = mType.decl(termNames.CONSTRUCTOR).asMethod
    val constructorMirror = classMirror.reflectConstructor(constructor)

    val constructorArgs = constructor.paramLists.flatten.map( (param: Symbol) => {
      val paramName = param.name.toString
      if(param.typeSignature <:< typeOf[Option[Any]])
        m.get(paramName)
      else
        m.get(paramName).getOrElse(throw new IllegalArgumentException("Map is missing required parameter named " + paramName))
    })

    constructorMirror(constructorArgs:_*).asInstanceOf[T]

  }

因此，现在我需要传递T的类型和符号。我可以得到这两个值，如下所示：

//Converting an Object into a Map
val r = currentMirror.reflect(input)
val mapValues = r.symbol.typeSignature.members.toStream
  .collect{case s : TermSymbol if !s.isMethod => r.reflectField(s)}
  .map(r => r.symbol.name.toString.trim -> r.get)
  .toMap

val mapTypes = r.symbol.typeSignature.members.toStream
  .collect{case s : TermSymbol if !s.isMethod => r.reflectField(s)}
  .map(r => r.symbol.name.toString.trim -> r.symbol.typeSignature)
  .toMap

val mapTypesSymbols = r.symbol.typeSignature.members.toStream
  .collect{case s : TermSymbol if !s.isMethod => r.reflectField(s)}
  .map(r => r.symbol.name.toString.trim -> r.symbol.typeSignature.typeSymbol)
  .toMap

val nameType = mapTypes("name")
val nameTypeSymbols =  mapTypesSymbols("name")
val nameValue =  mapValues("name")

// Converting Name into a map
    val r2 = currentMirror.reflect(nameValue)
    val nameAsMapValues = r2.symbol.typeSignature.members.toStream
      .collect{case s : TermSymbol if !s.isMethod => r2.reflectField(s)}
      .map(r2 => r2.symbol.name.toString.trim -> r2.get)
      .toMap

type nameT = nameType.type

val obj = fromMap2[nameT](nameAsMapValues, nameTypeSymbols, nameType)

即使这有效，我相信这也是非常反模式。 因此，如果有人可以指出改进方法，我将保留这个问题。