Java & Groovy & Scala & Kotlin -

2017-12-09 本文已影响0人 bookislife

Overview

本章主要介绍在实际编程中非常重要的反射和注解两大特性。

Java

注解

注解主要用于标示元数据。Java 中声明一个注解使用符号 @interface。

创建一个注解

例：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Bean {
    String name();
}

以上创建了一个名为 Bean 的注解。该注解上使用了标示此自定义注解的两个 JVM 的内置注解：Retention 和 Target。

Rentention 表示应该将该注解信息保存在哪里，有 RUNTIME，CLASS，SOURCE 三种。其中 CLASS 为默认值，只有标示为 RUNTIME 的注解才可以被反射。

Target 表示应该将注解放在哪里，有 TYPE，FIELD，METHOD，PARAMETER 等几种。即声明为 TYPE 时可以将注解放在类或接口上，声明为 FIELD 则只能方法属性上。

以上创建的注解中还包含有一个属性 name，在使用该注解时必须同时定义此属性。如果使用 String name() default ""; 替代的话则可以不定义此属性而使用默认值。

使用注解

创建三个注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Bean {
    String name();
}

@Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD)
public @interface BeanField {
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface BeanMethod {
    String alias() default "";
}

以上创建的注解 Bean 使用时必须定义 name 属性，而 BeanMethod 的 alias 属性由于有默认值空字符串，所以定义时可以省略 alias 属性。

定义一个使用以上注解的类

@Bean(name = "t_person")
class Person {

    public Person() {
    }

    public Person(int age) {
        this.age = age;
    }

    @BeanField
    private int age;

    @BeanMethod(alias = "trueAge")
    public int getAge() {
        return age;
    }

    public void setAge(final int age) {
        this.age = age;
    }

    @BeanMethod(alias = "hello")
    public void sayHello(String message) {
        System.out.println("hello " + message);
    }
}

反射

所谓的反射即是在运行时获得类的各种元数据（类本身，类中的方法，类中的属性等）的一种手段。实际开发中反射主要用于编写各种工具，我们需要自己编写反射的情况实际非常少。

类的引用

为了对一个类进行反射需要先获得类的信息，即获得类的引用，Java 中需要使用以下方法

Class<?> clazz = Person.class;

方法的引用

方法存在于类中，所以获得方法的引用前需要先获得类的引用。

Method setAgeMethod = clazz.getMethod("setAge", int.class);

以上使用了 getMethod() 方法获得了 Person 类中的 setAge(int) 方法的引用。getMethod() 方法的第一个参数为方法名，之后接着的为表示方法的参数列表的变参。

与 getMethod() 类型还有一个名为 getDeclaredMethod() 的方法，两者最显著的区别是前者只能获得公开成员，而后者可以获得私有成员。基本上方法，属性，注解等的引用都有这两种方法。

获得方法的引用后，可以通过 invoke() 执行该方法。invoke() 的第一个参数为需要执行该方法的对象，之后接着的为传入该方法的参数列表。

Method setAgeMethod = clazz.getMethod("setAge", int.class);
setAgeMethod.invoke(person, 100);
Method getAgeMethod = clazz.getMethod("getAge");
int age = (int) getAgeMethod.invoke(person);
System.out.println("Age is " + age);    //  100

属性的引用

属性的引用基本同方法的引用。

Field ageField = clazz.getDeclaredField("age");

通过属性的引用来获得属性的值只需要通过 getXXX() 之类的方法就可以了，该方法参数为持有该属性的对象。

ageField.setAccessible(true);
System.out.println("Age is " + ageField.getInt(person));

以上由于 age 在声明时为私有变量，所以需要先使用 setAccessible() 才能进行访问。

构造方法的引用

构造方法的引用也和其它引用差不多，直接看例子就可以了。

Constructor<Person> constructor = (Constructor<Person>) clazz.getConstructor(int.class);
Person person1 = constructor.newInstance(18);
System.out.println("Age is " + person1.getAge());

注解的引用

Bean bean = clazz.getAnnotation(Bean.class);
String name = bean.name();
System.out.println("Name is " + name);  //  t_person

遍历类的成员

实际开发中由于反射主要用于编写工具，所以大部分情况下我们都不知道反射的类的结构，所以通常都需要对类的成员进行遍历并结合以上的所有方法。下面是一个简单的例子。

Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
    Annotation[] annotations = field.getDeclaredAnnotations();
    if (annotations == null || annotations.length == 0) continue;
    System.out.println("Find field annotation " + annotations[0].annotationType().getSimpleName());
}

Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
    Annotation[] annotations = method.getDeclaredAnnotations();
    if (annotations == null || annotations.length == 0) continue;
    System.out.println("Find method annotation " + annotations[0].annotationType().getSimpleName());  //  BeanMethod

    BeanMethod beanMethod = (BeanMethod) annotations[0];
    String alias = beanMethod.alias();
    System.out.println("Alias is " + alias);    //  trueAge

    if (method.getName().equals("sayHello")) {
        method.invoke(person, "world");
    }
    System.out.println("====================");
}

Groovy

注解

Groovy 用法同 Java。

创建一个注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Bean {
    String name()
}

使用注解

创建三个注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Bean {
    String name()
}

@Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD)
@interface BeanField {
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface BeanMethod {
    String alias() default ""
}

定义一个使用以上注解的类

@Bean(name = "t_person")
class Person {

    @BeanField
    def int age

    @BeanMethod(alias = "trueAge")
    def int getAge() {
        age
    }

    def void setAge(int age) {
        this.age = age
    }

    @BeanMethod(alias = "hello")
    def void sayHello(String message) {
        println("hello $message")
    }
}

反射

Groovy 中的反射与 Java 一样，不过 Groovy 中拥有更强大的元编程，在以后会提起。

类的引用

def clazz = Person.class

方法的引用

def setAgeMethod = clazz.getMethod("setAge", int.class)

执行该方法

def setAgeMethod = clazz.getMethod("setAge", int.class)
setAgeMethod.invoke(person, 100)
def getAgeMethod = clazz.getMethod("getAge")
int age = (int) getAgeMethod.invoke(person)
println("Age is " + age)    //  100

除了使用 invoke()，Groovy 还有另一种方式来执行方法，使用时看起来有些像 JavaScript 的 eval() 函数。

person."${setAgeMethod.name}"(20)

属性的引用

def ageField = clazz.getDeclaredField("age")

获得属性的值

ageField.setAccessible(true)
println("Age is " + ageField.getInt(person))

构造方法的引用

如果使用构造方法的引用则必须先定义需要的构造方法，但这样会丧失了 Groovy 构造方法的带名参数的功能。

def constructor = clazz.getConstructor(int.class)
def person1 = constructor.newInstance(18)
println("Age is " + person1.getAge())

注解的引用

Bean bean = clazz.getAnnotation(Bean.class)
def name = bean.name()
println("name is " + name)

遍历类的成员

clazz.declaredFields.findAll {
    it.declaredAnnotations != null && it.declaredAnnotations.size() > 0
}.each {
    println("Find field annotation ${it.annotations[0].annotationType().simpleName}")
}

clazz.declaredMethods.findAll {
    it.declaredAnnotations != null && it.declaredAnnotations.size() > 0
}.each {
    println("Find method annotation ${it.annotations[0].annotationType().simpleName}")

    def alias = (it.annotations[0] as BeanMethod).alias()
    println("Alias is $alias")

    if (it.name == "sayHello") {
        it.invoke(person, "world")
    }
    println("====================")
}

Scala

注解

Scala 大多情况下直接使用 Java 的注解即可。Scala 本身虽然也提供了Scala 风格的注解功能，但功能很弱，完全可以使用 Java 的进行替代。

创建一个注解

Scala 创建注解需要继承 ClassfileAnnotation 或 StaticAnnotation。前者类似 Java 中的 Runtime，可以被反射，后者则无法被反射。

class Bean(val name: String) extends ClassfileAnnotation

使用注解

创建三个注解

class Bean(val name: String) extends ClassfileAnnotation
class BeanField extends StaticAnnotation
class BeanMethod(val alias: String = "") extends StaticAnnotation

定义一个使用以上注解的类

@Bean(name = "t_person")
class Person {
    @BeanField
    private var privateAge: Int = 0

    @BeanMethod(alias = "trueAge")
    def age_=(pAge: Int) {
      privateAge = pAge
    }

    def age = privateAge

    @BeanMethod
    def sayHello(message: String) = println(s"hello $message")
}

反射

Scala 有自己的反射 Api，功能比 Java 要更丰富，但是个人感觉非常难用，还是直接使用 Java 的更加方便。对 Scala 的 Api 有兴趣的可以直接去官网查看文档。

下面列一个简单的根据类生成对象的 Scala 原生 Api 的例子，体验一下有多难用

val classLoaderMirror = runtimeMirror(getClass.getClassLoader)
val typePerson = typeOf[Person]
val classPerson = typePerson.typeSymbol.asClass
val classMirror = classLoaderMirror.reflectClass(classPerson)
val methodSymbol = typePerson.decl(termNames.CONSTRUCTOR).asMethod
val methodMirror = classMirror.reflectConstructor(methodSymbol)
val p: Person = methodMirror(10).asInstanceOf[Person]
p.age = 16
println(p.age)

Kotlin

注解

Kotlin 用法类似 Java，但还是有很大区别。

创建一个注解

AnnotationRetention 类似 Java 的 RetentionPolicy。AnnotationTarget 类似 Java 的 ElementType，但是由于 Kotlin 的特性，其值有 FIELD，PROPERTY_GETTER 等种类。

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.CLASS)
@Repeatable
@MustBeDocumented
annotation class Bean(val name: String)

使用注解

创建三个注解

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.CLASS)
@Repeatable
@MustBeDocumented
annotation class Bean(val name: String)

@Retention(AnnotationRetention.BINARY)
@Target(AnnotationTarget.FIELD)
annotation class BeanField

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.FUNCTION)
annotation class BeanMethod(val alias: String = "")

定义一个使用以上注解的类

@Bean(name = "t_person")
class Person {
    @BeanField var age: Int = 0
        @BeanMethod(alias = "trueAge") get() = field

    @BeanMethod(alias = "hello") fun sayHello(message: String) {
        println("hello $message")
    }
}

反射

Kotlin 中的反射可以通过符号 :: 直接对各种类和成员进行引用，但是如果想通过字符串进行引用的话就非常麻烦。

类的引用

val clazz = Person::class

函数的引用

val sayHello = Person::sayHello

执行该函数

println(sayHello.invoke(person, "world"))

就像类中的函数一样也可以直接对定义在类外的函数进行引用，并将该引用作为参数进行传递

fun isOdd(x: Int) = x % 2 != 0
val numbers = listOf(1, 2, 3)
println(numbers.filter(::isOdd))

属性的引用

var name = Person::age

获得属性的值

name.get(person)

同样也可以对类外的属性进行引用

var x = 2
println(::x.get())
::x.set(3)
println(x)

构造方法的引用

::Person

使用该引用

fun factory(f: () -> Person) {
    val p = f()
}
factory(::Person)

遍历类的成员

val bean = clazz.annotations.first {
    it.annotationType().typeName == Bean::class.qualifiedName
} as Bean
println("name is ${bean.name}") //  t_person

val properties = clazz.declaredMemberProperties
properties.filter {
    it.annotations.isNotEmpty()
}.forEach {
    println(it.annotations[0].annotationClass.simpleName)
}

val functions = clazz.declaredMemberFunctions
functions.filter {
    it.annotations.isNotEmpty()
}.forEach {
    println(it.name)
    println(it.annotations[0].annotationClass.simpleName)    //  BeanMethod

    val beanMethod = it.annotations[0] as BeanMethod
    println("alias is ${beanMethod.alias}") //  hello
}

Summary

注解使用场景很多，但是一般只要理解内置注解的作用，很少需要自己定义注解
反射 Api 大都比较难用，但是实际使用场景并不多

文章源码见 https://github.com/SidneyXu/JGSK 仓库的 _33_reflect_annotation 小节

Java & Groovy & Scala & Kotlin -

Overview

Java

注解

创建一个注解

使用注解

反射

类的引用

方法的引用

属性的引用

构造方法的引用

注解的引用

遍历类的成员

Groovy

注解

创建一个注解

使用注解

反射

类的引用

方法的引用

属性的引用

构造方法的引用

注解的引用

遍历类的成员

Scala

注解

创建一个注解

使用注解

反射

Kotlin

注解

创建一个注解

使用注解

反射

类的引用

函数的引用

属性的引用

构造方法的引用

遍历类的成员

Summary

猜你喜欢

热点阅读