Scala中反射的使用

参考: http://software.clapper.org/classutil/

测试类:

import com.project.dmp.utils.ClassUtils
import org.clapper.classutil.ClassInfo
import org.clapper.classutil.ScalaCompat.LazyList
import org.junit.Test
import spire.std.map

class ClassUtilTest {

  /**
   * 获取当前类路径中所有类的信息
   */
  @Test
  def getAllClassesInfo() {
    import org.clapper.classutil.ClassFinder
    val finder = ClassFinder()
    val classes = finder.getClasses // classes is an Iterator[ClassInfo]
    classes.foreach(println)
  }

  /**
   * 获取自定义类路径中的所有具体类
   */
  @Test
  def getAllClassesInfoFromCustomPath() {
    import org.clapper.classutil.ClassFinder
    import java.io.File

    //    val classpath = List("foo.jar", "bar.jar", "baz.zip").map(new File(_))
    val classpath = List("E:\\CDHProjectDemo\\spark-demo\\target\\original-spark-demo-0.0.1-SNAPSHOT.jar").map(new File(_))
    val finder = ClassFinder(classpath)
    val classes = finder.getClasses.filter(_.isConcrete)
    classes.foreach(println)
  }

  /**
   * 获取自定义类路径中的所有接口
   */
  @Test
  def getAllInterfacesFromCustomPath(): Unit = {
    val classes: Iterator[ClassInfo] = ClassUtils.getAllInterfacesFromCustomPath("com.project.dmp.etl.Processor")
    classes.foreach(println)
  }

  /**
   * 在自定义类路径中查找实现接口的所有类
   */
  @Test
  def getAllInterfacesFromCustomPaths() : Unit = {

    val maps: Map[String, Iterator[ClassInfo]] = ClassUtils.getAllInterfacesFromCustomPaths("com.project.dmp.etl.Processor", "com.project.dmp.report.ReportProcessor")
    for(map <- maps){
      map._2.foreach(println)
      println("==================================")
    }
  }

  @Test
  def mapToBean(): Unit = {
    val charList = List('a', 'b', 'c')
    val subMap = Map("sub1" -> 1, "sub2" -> 2)
    val map = Map("int" -> 1,
      "float" -> 2f,
      "someString" -> "three",
      "intClass" -> classOf[Int],
      "subMap" -> subMap,
      "list" -> charList)
    println()
    println("getSubMap returns " + ClassUtils.mapToBean(map, "getSubMap"))
  }

  @Test
  def scalaObjectToBean(): Unit = {
    case class Foo(name: String, value: Int)
    case class Bar(name: String, foo: Foo)
    val foo = Foo("foo100", 100)
    val bar = Bar("bar1", foo)
    println()
    println("beanFoo.getName returns: " + ClassUtils.scalaObjectToBean(foo, "getName"))
    println("beanFoo.getValue returns: " + ClassUtils.scalaObjectToBean(foo, "getValue"))
    println("beanBar.getName returns: " + ClassUtils.scalaObjectToBean(bar, "getName"))
    val beanFoo2 = ClassUtils.scalaObjectToBean(bar, "getFoo")
    println("beanBar.getFoo returns: " + beanFoo2)
  }
}

工具类:

import java.io.File

import org.clapper.classutil.ScalaCompat.LazyList
import org.clapper.classutil.{ClassFinder, ClassInfo, MapToBean, ScalaObjectToBean}
import org.junit.Test

import scala.collection.immutable

object ClassUtils {

  /**
   * 获取当前类路径中所有类的信息
   */
  def getAllClassesInfo() {

    val finder = ClassFinder()
    val classes = finder.getClasses // classes is an Iterator[ClassInfo]
    classes.foreach(println)
  }


  /**
   * 获取自定义类路径中的所有具体类
   */
  @Test
  def getAllClassesInfoFromCustomPath(jarPath: String*): immutable.Seq[ClassInfo] = {

    val classpath = jarPath.toList.map(new File(_))
    val finder = ClassFinder(classpath)
    val classes: immutable.Seq[ClassInfo] = finder.getClasses.filter(_.isConcrete)
    //    classes.foreach(println)
    classes
  }

  /**
   * 获取自定义类路径中的所有接口
   */
  def getAllInterfacesFromCustomPath(jarPath: String*): LazyList[ClassInfo] = {
    val classpath = jarPath.toList.map(new File(_))
    val finder = ClassFinder(classpath)
    val classes: LazyList[ClassInfo] = finder.getClasses.filter(_.isInterface)
    //    classes.foreach(println)
    classes
  }

  /**
   * 在当前路径中查找实现接口的所有类
   */
  def getAllInterfacesFromCustomPath(classpath: String): Iterator[ClassInfo] = {
    val finder: ClassFinder = ClassFinder()
    val classes: LazyList[ClassInfo] = finder.getClasses
    val plugins: Iterator[ClassInfo] = ClassFinder.concreteSubclasses(classpath, classes)
    plugins
  }

  /**
   * 在当前路径中查找实现接口的所有类
   */
  def getAllInterfacesFromCustomPaths(classpaths: String*): Map[String, Iterator[ClassInfo]] = {
    val finder: ClassFinder = ClassFinder()
    val classes: LazyList[ClassInfo] = finder.getClasses
    val classMap: Map[String, ClassInfo] = ClassFinder.classInfoMap(classes) // runs iterator out, once
    var map = immutable.Map[String, Iterator[ClassInfo]]()
    for (classpath <- classpaths) {
      val infoes: Iterator[ClassInfo] = ClassFinder.concreteSubclasses(classpath, classMap)
      map += (classpath -> infoes)
    }
    map
  }

  /**
   * MapToBean接受一个Map对象作为输入，并生成一个Java Bean，其中 get包含映射中每个键/值对的方法。
   */
  def mapToBean(map: Map[String, Any], methodName: String): Any = {
    val obj = MapToBean(map)
    //    obj.getClass.getMethods.filter(_.getName startsWith "get").foreach(println)
    val method = obj.getClass.getMethod(methodName)
    method.invoke(obj)
  }

  /**
   * ScalaObjectToBean以Scala对象作为输入，并get为每个Scala访问器生成一个带有方法的Java Bean
   */
  def scalaObjectToBean(obj: Any, methodName: String): Any = {
    val bean = ScalaObjectToBean(obj)
    //        bean.getClass.getMethods.filter(_.getName startsWith "get").foreach(println)
    val method = bean.getClass.getMethod(methodName)
    method.invoke(bean)
  }
}