假设我有这个示例案例类
case class Test(key1: Int, key2: String, key3: String)
我有一张地图
myMap = Map("k1" -> 1, "k2" -> "val2", "k3" -> "val3")
我需要在代码的几个地方将此映射转换为我的案例类，如下所示：
myMap.asInstanceOf[Test]
最简单的方法是什么？我可以为此使用隐式吗？
【问题讨论】：
def map2Test(m: Map[String, Any]) = Test(m("k1').asInstanceOf[Int], m("k2") ... ) 如果你想要一个将映射转换为任何案例类的抽象，你可能必须使用反射。
标签： scala
优雅地做到这一点的两种方式。第一种是使用unapply，第二种是使用带有类型类的隐式类（2.10+）为您进行转换。
1) unapply 是编写这种转换的最简单和最直接的方法。它不会做任何“魔术”，如果使用 IDE 可以很容易地找到它。请注意，做这种事情会弄乱你的伴生对象，并导致你的代码在你可能不想要的地方产生依赖：
object MyClass{
def unapply(values: Map[String,String]) = try{
Some(MyClass(values("key").toInteger, values("next").toFloat))
} catch{
case NonFatal(ex) => None
}
}
可以这样使用：
val MyClass(myInstance) = myMap
小心，如果不完全匹配会抛出异常。
2) 使用类型类创建一个隐式类会为您创建更多样板，但也允许大量空间扩展相同的模式以应用于其他案例类：
implicit class Map2Class(values: Map[String,String]){
def convert[A](implicit mapper: MapConvert[A]) = mapper conv (values)
}
trait MapConvert[A]{
def conv(values: Map[String,String]): A
}
作为一个例子，你会做这样的事情：
object MyObject{
implicit val new MapConvert[MyObject]{
def conv(values: Map[String, String]) = MyObject(values("key").toInt, values("foo").toFloat)
}
}
然后可以像上面描述的那样使用它：
val myInstance = myMap.convert[MyObject]
如果无法进行转换，则抛出异常。使用这种在 Map[String, String] 到任何对象之间转换的模式只需要另一个隐式（并且那个隐式在范围内）。
【讨论】：
object MyObject { ... } 代码无法为我编译
MyClass 是一个带有伴随对象的案例类，您的unapply 方法不应该要求对象具有不同的名称since there's already a defined unapply method by default 吗？例如，我只能得到这样的东西来编译：val MyClassOfMap(myInstance) = myMap
override。或者，我应该说，你曾经可以这样做。这个问题和答案现在已经 5 岁了！
unapply 而不是 apply。 Scala 文档说Whereas the apply method is like a constructor which takes arguments and creates an object, the unapply takes an object and tries to give back the arguments.。由于我们将参数（映射）转换为对象（MyClass），不应该使用apply 吗？
我不喜欢这段代码，但我想如果你可以将映射值放入一个元组中，然后为你的案例类使用tupled 构造函数，这是可能的。看起来像这样：
val myMap = Map("k1" -> 1, "k2" -> "val2", "k3" -> "val3")
val params = Some(myMap.map(_._2).toList).flatMap{
case List(a:Int,b:String,c:String) => Some((a,b,c))
case other => None
}
val myCaseClass = params.map(Test.tupled(_))
println(myCaseClass)
您必须小心确保值列表正好是 3 个元素并且它们是正确的类型。如果没有，你最终会得到一个 None 。就像我说的，不是很好，但它表明这是可能的。
【讨论】：
myMap.values替换myMap.map(_._2)
Jonathan Chow 实现了一个 Scala 宏（专为 Scala 2.11 设计），它概括了这种行为并消除了样板。
http://blog.echo.sh/post/65955606729/exploring-scala-macros-map-to-case-class-conversion
import scala.reflect.macros.Context
trait Mappable[T] {
def toMap(t: T): Map[String, Any]
def fromMap(map: Map[String, Any]): T
}
object Mappable {
implicit def materializeMappable[T]: Mappable[T] = macro materializeMappableImpl[T]
def materializeMappableImpl[T: c.WeakTypeTag](c: Context): c.Expr[Mappable[T]] = {
import c.universe._
val tpe = weakTypeOf[T]
val companion = tpe.typeSymbol.companionSymbol
val fields = tpe.declarations.collectFirst {
case m: MethodSymbol if m.isPrimaryConstructor ⇒ m
}.get.paramss.head
val (toMapParams, fromMapParams) = fields.map { field ⇒
val name = field.name
val decoded = name.decoded
val returnType = tpe.declaration(name).typeSignature
(q"$decoded → t.$name", q"map($decoded).asInstanceOf[$returnType]")
}.unzip
c.Expr[Mappable[T]] { q"""
new Mappable[$tpe] {
def toMap(t: $tpe): Map[String, Any] = Map(..$toMapParams)
def fromMap(map: Map[String, Any]): $tpe = $companion(..$fromMapParams)
}
""" }
}
}
【讨论】：
这是一种替代的非样板方法，它使用 Scala 反射（Scala 2.10 及更高版本）并且不需要单独编译的模块：
import org.specs2.mutable.Specification
import scala.reflect._
import scala.reflect.runtime.universe._
case class Test(t: String, ot: Option[String])
package object ccFromMap {
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]
}
}
class CaseClassFromMapSpec extends Specification {
"case class" should {
"be constructable from a Map" in {
import ccFromMap._
fromMap[Test](Map("t" -> "test", "ot" -> "test2")) === Test("test", Some("test2"))
fromMap[Test](Map("t" -> "test")) === Test("test", None)
}
}
}
【讨论】：
commons.mapper.Mappers.mapToBean[CaseClassBean](map)
【讨论】：
这对我很有效，如果你使用jackson for scala：
def from[T](map: Map[String, Any])(implicit m: Manifest[T]): T = {
val mapper = new ObjectMapper() with ScalaObjectMapper
mapper.convertValue(map)
}
【讨论】：