Как получить имя ученика?

Question

Я хочу быть в состоянии сделать что-то вроде этого:

подготовить форму:

val formDescription = formBuilder(_.textField[User](_.firstName)
             .textField[User](_.lastName)
             ).build

showForm(formDescription)

извлечь данные из формы, заполненной пользователем, используя User:

//contains data of a form submitted by a user:
val formData: Map[String, String] = getFormData 

val newUser  = User(id = randomUuid, firstName = formData.extract[User](_.firstName))

Одно решение, которое я вижу, состоит в том, чтобы использовать динамический прокси, который расширяет предоставленный класс и запоминает, что было вызвано для него:

def getFieldName[T:Manifest](foo: T => Any) = {
  val clazz = implicitly[Manifest[T]].erasure
  val proxy = createDynamicProxy(clazz)
  foo(proxy)
  proxy.lastInvokedMethodName   
}

Есть ли лучший способ сделать это? Есть ли библиотека, которая уже реализует это?

Answer 1

Этот рефлексивный подход использует класс case и вызывает его сопутствующее приложение, вызывая getField и выбирая аргументы по умолчанию, если поле отсутствует в данных.

import scala.reflect.runtime.{currentMirror => cm, universe => uni}
import uni._

def fromXML(xml: Node): Option[PluginDescription] = {
  def extract[A]()(implicit tt: TypeTag[A]): Option[A] = {
    // extract one field
    def getField(field: String): Option[String] = {
      val text = (xml \\ field).text.trim
      if (text == "") None else Some(text)
    }

    val apply = uni.newTermName("apply")
    val module = uni.typeOf[A].typeSymbol.companionSymbol.asModule
    val ts = module.moduleClass.typeSignature
    val m = (ts member apply).asMethod
    val im = cm reflect (cm reflectModule module).instance
    val mm = im reflectMethod m

    def getDefault(i: Int): Option[Any] = {
      val n = uni.newTermName("apply$default$" + (i+1))
      val m = ts member n
      if (m == NoSymbol) None
      else Some((im reflectMethod m.asMethod)())
    }
    def extractArgs(pss: List[List[Symbol]]): List[Option[Any]] =
      pss.flatten.zipWithIndex map (p => getField(p._1.name.encoded) orElse getDefault(p._2))
    val args = extractArgs(m.paramss)
    if (args exists (!_.isDefined)) None
    else Some(mm(args.flatten: _*).asInstanceOf[A])
  }
  // check the top-level tag
  xml match {
    case <plugin>{_*}</plugin>  => extract[PluginDescription]()
    case _                      => None
  }
}

Идея заключалась в том, чтобы сделать что-то вроде:

case class User(id: Int = randomUuid, firstName: String, lastName: String)

val user = extract[User]()

Answer 2

Это мое собственное решение:

    package utils

    import javassist.util.proxy.{MethodHandler, MethodFilter, ProxyFactory}
    import org.specs2.mutable._


    import javassist.util.proxy.Proxy

    import java.lang.reflect.{Constructor, Method}

    class DynamicProxyTest extends Specification with MemberNameGetter {

        "Dynamic proxy" should {
            "extract field name" in {
                memberName[TestClass](_.a) must ===("a")
                memberName[TestClass](_.i) must ===("i")
                memberName[TestClass](_.b) must ===("b")
                memberName[TestClass](_.variable) must ===("variable")
                memberName[TestClass](_.value) must ===("value")
                memberName[TestClass](_.method) must ===("method")  
            }

        }
    }

    trait MemberNameGetter {
        def memberName[T: Manifest](foo: T => Any) = {
            val mf = manifest[T]
            val clazz = mf.erasure
            val proxyFactory = new ProxyFactory
            proxyFactory.setSuperclass(clazz)
            proxyFactory.setFilter(new MethodFilter {
                def isHandled(p1: Method) = true
            })
            val newClass = proxyFactory.createClass()
            var lastInvokedMethod: String = null
            val mh = new MethodHandler {
                def invoke(p1: Any, p2: Method, p3: Method, p4: Array[AnyRef]) = {
                    lastInvokedMethod = p2.getName
                    p3.invoke(p1, p4: _*)
                }
            }
            val constructor = defaultConstructor(newClass)
            val parameters = defaultConstructorParameters(constructor)
            // val proxy = constructor.newInstance("dsf", new Integer(0))
            val proxy2 = constructor.newInstance(parameters: _*)
            proxy2.asInstanceOf[Proxy].setHandler(mh)
            foo(proxy2.asInstanceOf[T])
            lastInvokedMethod
        }

        private def defaultConstructor(c: Class[_])  =   c.getConstructors.head
        private def defaultConstructorParameters(constructor: Constructor[_]) = {
            val parameterTypes = constructor.getParameterTypes
            parameterTypes.map{
                case Integer.TYPE => Integer.valueOf(0)                  
                case _ => null
            }

        }
    }


    case class TestClass(a: String, i: Int, b: Boolean) {
        var variable = "asdf"
        val value = "asdfasdfasd"

        def method = "method"
    }

    val mh = new MethodHandler {
        def invoke(p1: Any, p2: Method, p3: Method, p4: Array[AnyRef]) = {
            lastInvokedMethod = p2.getName
            p3.invoke(p1, p4: _*)
        }
    }
    val constructor = defaultConstructor(newClass)
    val parameters = defaultConstructorParameters(constructor)
    // val proxy = constructor.newInstance("dsf", new Integer(0))
    val proxy2 = constructor.newInstance(parameters: _*)
    proxy2.asInstanceOf[Proxy].setHandler(mh)
    foo(proxy2.asInstanceOf[T])
    lastInvokedMethod
}

private def defaultConstructor(c: Class[_])  =   c.getConstructors.head
private def defaultConstructorParameters(constructor: Constructor[_]) = {
    val parameterTypes = constructor.getParameterTypes
    parameterTypes.map{
        case Integer.TYPE => Integer.valueOf(0)
        case java.lang.Double.TYPE => java.lang.Double.valueOf(0)
        case java.lang.Long.TYPE => java.lang.Long.valueOf(0)
        case java.lang.Boolean.TYPE => java.lang.Boolean.FALSE
        case _ => null
    }

}
}


case class TestClass(a: String, i: Int, b: Boolean) {
   var variable = "asdf"
   val value = "asdfasdfasd"

   def method = "method"
}