码代码的冰果果

个人在线笔记

0%

反射

发表于 更新于 分类于 ， 阅读次数： Valine：
本文字数： 16k 阅读时长 ≈ 29 分钟

反射机制，让Java获得类似动态语言的特性。

动态语言：

  • 是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
  • 主要动态语言：Object-C、C#、JavaScript、PHP、Python等等。

静态语言：

  • 与动态语言相对应的，运行时结构不可改变的语言就是静态语言。如java、C、C++。
  • java不是动态语言，但java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。java的动态性让编程的时候更加灵活！

JAVA反射机制概述

概述

  • Reflection（反射）是java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。Class c = Class.forName("java.lang.String")
  • 加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以我们形象的称之为：反射

正常方式：引入需要的“包类”名称 –> 透过new实例化 –> 取得实例化对象

反射方式：实例化对象 –> getClass()方法 –> 得到完整的“包名”名称

反射机制提供的功能

  • 在运行时判断任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时判断任意一个类所具有的成员变量和方法
  • 在运行时获取泛型信息
  • 在运行时调用任意一个对象的成员变量和方法
  • 在运行时处理注解
  • 生成动态代理
  • … …

优点和缺点

  • 优点：可以实现动态创建对象和编译，体现了很大的灵活性
  • 缺点：对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。

反射相关的主要API

java.lang.Class：代表一个类

Java.lang.reflect.Method：代表类的方法

Java.lang.reflect.Field：代表类的成员变量

Java.lang.reflect.Constructor：代表类的构造器（构造方法）

… …

理解Class类并获取Class实例

Class类

在Object类中定义了以下方法，此方法被所有子类继承：public final Class getClass()。以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE（java runtime environment，Java运行环境）都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结果（类class、接口interface、枚举enum、注解annotation、原始类型primitive type、空类型void、数组[]）的有关信息。

  • Class本身也是一个类
  • Class对象只能由系统建立对象
  • 一个加载的类在JVM中只会有一个Class实例
  • 一个Class对象对应的是一个加载到JVM中的一个.class文件
  • 每个类的实例都会记得自己是由哪个Class实例所生成
  • 通过Class可以完整地得到一个类中的所有被加载的结构
  • Class类是Reflection的根源，针对任何你想动态加载、运行的类、唯有先获得相应的Class对象

Class类的常用方法：

方法名 功能说明
static Class forName（String name） 放回指定类名name的Class对象
Object newInstance() 调用缺省（默认）构造函数，返回Class对象的一个实例（通过Class对象创建对象）
getName() 放回此Class对象所表示的实体（类、接口、数组类或void）的名称
Class getSuperClass() 返回当前Class对象的父类的Class对象，见下边的方法四
Class[] getinterfaces() 获取当前Class对象的接口
ClassLoader getClassLoader() 返回该类的类加载器
Constructor[] getConstructors() 返回一个包含某些Constructor对象的数组（构造器）
Method getMethod(String name, Class<?>... T) 返回一个Method对象，此对象的形参类型为parameterTypes
Field[] getDeclaredFields() 返回Field对象的一个数组（DeclaredField：声明字段/变量）

Class实例

哪些类型可以有Class实例（对象）？

  • class：外部类，成员（成员内部类，静态内部类），局部内部类、匿名内部类
  • interface ：接口
  • []：数组
  • enum：枚举（一个特殊的类，一般表示一组常量）
  • annotation：注解（@interface）
  • primitive type：基本数据类型（八种基本数据类型）
  • void

获取Class类实例的几个方法：

  1. 若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高。

    Class c = 类名.class;

  2. 已知某个类的实例，调用该实例的getClass()方法获取Class对象

    Class c = 实例.getClass();

  3. 已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException。

    Class c = Class.forName("全类名");

    例如：com.qsdbl.Test；类名为Test，全类名为com.qsdbl.Test。要获取Class类实例,可以通过方法一：Test.class或本方法即方法三：Class.forname(“com.qsdbl.Test”)

  4. 内置基本数据类型可以直接用类名.Type

  5. 还可以利用ClassLoader

注意：一个加载的类在JVM中只会有一个Class实例。

代码演示：

为了便于演示，创建一个类Person，和它的一个子类Student。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
class Person{
    public String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}
//Person的子类
class Student extends Person{
    public Student() {
        this.name = "学生";
    }
}

方法一：类名

与方法三一样使用类名，使用的是继承自父类Object的class属性。方法三全类名使用的是Class类的forName()方法。 

1
2
3
4
5
6
7
8
 
//测试Class类的创建方式
public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        //方法一：类名
        Class c1 = Person.class;
        System.out.println("c1："+c1.hashCode());
    }
}

方法二：类的实例

通过类的实例获取Class实例，使用的是继承自父类Object的getClass方法。

1
2
3
4
5
6
7
8
9
 
//测试Class类的创建方式
public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        //方法二：类的实例
        Person person = new Person();
        Class c2 = person.getClass();
        System.out.println("c2："+c2.hashCode());
    }
}

方法三：全类名

全类名，com.study.注解与反射.demo02.Person。与方法一一样使用类名，全类名使用的是Class类的forName()方法。方法一使用的是继承自父类Object的class属性。 

1
2
3
4
5
6
7
8
 
//测试Class类的创建方式
public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        //方法三：全类名
        Class c3 = Class.forName("com.study.注解与反射.demo02.Person");
        System.out.println("c3："+c3.hashCode());
    }
}

方法四：子类的Class实例

该方法是通过子类的Class实例，调用Class类的getSuperclass()方法获取Class实例。

1
2
3
4
5
6
7
8
9
 
//测试Class类的创建方式
public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        //方法四：通过子类的Class对象
        Class c4 = Student.class;
        Class c5 = c4.getSuperclass();
        System.out.println("c5："+c5.hashCode());
    }
}

方法五：Type属性

注意是基本数据类型，只有基本数据类型才可以这样获取Class实例

1
2
3
4
5
6
7
8
 
//测试Class类的创建方式
public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        //方法五：Type属性（基本类型的包装类，例如：Integer）
         Class c6 = Integer.TYPE;
        System.out.println("c6："+c6);
    }
}

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
//测试Class类的创建方式
public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        //方法一：类名
        Class c1 = Person.class;
        System.out.println("c1："+c1.hashCode());

        //方法二：类的实例
        Person person = new Person();
        Class c2 = person.getClass();
        System.out.println("c2："+c2.hashCode());

        //方法三：全类名
        Class c3 = Class.forName("com.study.注解与反射.demo02.Person");
        System.out.println("c3："+c3.hashCode());

        //方法四：通过子类的Class对象
        Class c4 = Student.class;
        Class c5 = c4.getSuperclass();
        System.out.println("c5："+c5.hashCode());

        //方法五：Type属性（基本类型的包装类，例如：Integer）
         Class c6 = Integer.TYPE;
        System.out.println("c6："+c6);
    }
}

运行结果：

1
2
3
4
5
6
7
 
c1：1627674070
c2：1627674070
c3：1627674070
c5：1627674070
c6：int

Process finished with exit code 0

获取运行时类的完整结构

通过反射获取运行时类的完整结构：Field、Method、Constructor、Superclass、Interface、Annotation

  • 全部的Field（成员变量）
  • 全部的方法
  • 全部的构造器
  • 所继承的父类
  • 实现的全部接口
  • 注解
  • 。。。

以下例子都是在已获取Class对象的基础之上，如何获取Class实例见前边。

获取类名

Class对象的getName或getSimpleName方法。

获取属性

  • 获取public属性getFields（多个），获取指定的public属性getField（一个）

  • 获取全部（包括私有的）的属性getDeclaredFields（多个），获取指定的任意属性getDeclaredField（一个）

    • 返回的是Field类型的数组或对象

    • 形式参数为属性名（name）

获取方法

  • 获取public方法getMethods（多个），获取指定的public方法getMethod（一个）

  • 获取全部（包括私有的）的方法getDeclaredMethods（多个），获取指定的任意方法getDeclaredMethod（一个）

    • 返回的是Method类型的数组或对象

    • 形式参数为方法名（name）+ 方法的形参类型的类对象（类.class）。（因为存在方法重载的情况）

获取构造器

获取类的构造方法（构造器），getConstructor()，与获取类的方法相似。不同点是获取指定的构造方法时不需要填写方法名（构造方法名跟类名相同）。

  • 获取public构造方法getConstructors，获取指定的构造方法getConstructor（一个）

  • 获取全部的方法getDeclaredConstructors，获取指定的任意构造方法getDeclaredConstructor（一个）

    • 返回的是Constructor类型的数组或对象

    • 形式参数为方法的形参类型的类对象（类.class）。（因为存在方法重载的情况）

规律

类名：getName与getSimpleName，类名与全类名

属性、方法、构造器等等：

  • get+Field、Method、Constructor：指定获取某一个，只能是public的，中间加Declared可以获取到私有的（所有）
  • 后边加s，获取到的是多个（返回的是数组）

获取注解

注解，Annotation

获取接口

接口，Interface（getInterfaces，返回的是所实现的全部接口）

获取父类

父类，superclass

小结

  • 在实际的操作中，取得类的信息的操作代码，并不会经常开发
  • 一定要熟悉java.lang.reflect包的作用，反射机制
  • 如何取得属性、方法、构造器的名称、修饰符等等。

有了Class对象，能做什么？

有了Class对象，能做什么？能创建运行时（在程序运行时动态创建）类的对象（使用Class对象创建实例）。调用运行时类的指定结构（调用类中的成员属性、成员方法等）。

需要注意的地方

与反射效率有关的一个“开关”–setAccessible：

  • Method和Field、Constructor对象都有setAccessible()方法
  • setAccessible作用是启动和禁用访问安全检查的开关
  • 参数值为true则指示反射的对象在使用时应该取消java语言访问检查
    • 提高反射的效率。如果代码中必须使用反射，而该句代码需要频繁的被调用，那么请设置为true
    • 使得原本无法访问的私有成员也可以访问
  • 参数值为false则指示反射的对象应该实施java语言访问检查
  • 可以理解为一个开关，是否允许访问私有的成员

关闭检测（setAccessible(true)）可以提高反射的效率：

创建类的对象

  • 调用Class对象的newInstance()方法

    • 使用无参构造器创建对象

    • 类必须有一个无参数的构造器（在编写类时不写构造器，则IDE会主动创建无参的构造器。若写类时只写有参构造器，则IDE不会主动创建无参的构造器）

    • 类的构造器的访问权限需要足够

      1
      		 
      User user = (User)c1.newInstance();

  • 调用Class对象的getDeclaredConstructor(Class ... parameterTypes)方法和Constructor对象的newInstance方法(Constructor，构造器)

    • 使用有参构造器创建对象

    • 通过形式参数来区分有参构造器，形式参数为方法的形参类型的类对象（类.class）。（因为存在方法重载的情况）（找到构造器） 

      1
      		 
      Constructor constructor = c1.getDeclaredConstructor(String.class,int.class,int.class);

    • 通过Constructor实例化对象（创建对象，需要填写实参）

      1
      		 
      User user = (User)constructor.newInstance("小明",01,18);

调用方法

即通过反射调用（使用）类的方法。获取类的方法，点这里回顾一下。（获取、调用，不要混淆了）

  • 通过Class对象获取类的方法（返回的是Method对象）

  • 通过invoke方法使用获取到的类方法，invoke方法的参数为要使用该方法的对象（调用的是静态方法，这里可以是null）和方法的实参（invoke，激活）

  • 若是私有方法，还需要设置setAccessible(true)才能正常使用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    		 
    //通过反射调用普通方法

    //通过反射获取一个方法（该方法用于设置用户名）
    Method setName = c1.getDeclaredMethod("setName", String.class);

    setName.invoke(user2,"小红");//参数为要使用该方法的对象，和方法的实参

    Method test02 = c1.getDeclaredMethod("test02");//调用静态方法（无参）
    test02.invoke(null);//要使用该方法的对象可以是null

    第一次看到这里的人可能会有以下疑惑：可以通过Class对象创建对象了，为什么不直接调用某个方法呢，而要这么麻烦？
    那是因为这样子做程序的灵活性比较差，而使用invoke灵活性更大（比如写成一个方法，方法、对象、实参可以作为参数传递进来）

操作属性

通过反射操作属性。

  • 通过Class对象获取类的属性（返回的是Field对象）
  • 通过set、get等方法操作属性
  • 若是私有属性，还需要设置setAccessible(true)才能正常操作属性
1
2
3
4
5
6
7
 
//通过反射操作属性
Field name = c1.getDeclaredField("name");//获取name属性
name.setAccessible(true);//可访问（因为User类中，name属性是private。不能直接操作私有属性，所以需要设置该属性为可访问（关闭安全检测）
name.set(user2,"黑黑");//修改name属性值为"黑黑"

System.out.println(user2);
System.out.println(name.get(user2));

操作泛型

Java泛型其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。摘自百度百科。

  • Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除。
  • 为了通过反射操作这些类型，Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型。
    • ParameterizedType：表示一种参数化类型（GenericType ，泛型），比如Collection<String>
    • GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型（泛型数组）
    • TypeVariable：是各种类型变量的公共接口
    • wildcardType：代表一种通配符类型表达式

代码演示

步骤

下边通过反射操作泛型。查看方法的形参类型或返回值类型是否是泛型，还可以查看泛型中具体有哪些类型。

  • 通过Class对象获取类的方法（返回的是Method对象）

  • Method对象可以使用的与泛型相关的方法有getGenericExceptionTypes、getGenericParameterTypes、getGenericReturnType

    • getGenericExceptionTypes：获取泛型异常类型（返回Type数组）

    • getGenericParameterTypes：获取泛型参数类型（方法的形参）(实际使用中也获取到非泛型的形参，所以说这个方法可以获取到全部的形参)（返回Type数组）

    • getGenericReturnType：获取泛型返回值类型（方法的返回值）（返回Type类型）

    • 获取到的类型还需要使用if (genericParameterType instanceof ParameterizedType)判断是否是泛型。（ParameterizedType：表示一种参数化类型（GenericType ，泛型），比如Collection<String>；见上边的介绍）

  • 若要查看泛型中具体的类型有哪些（得先将其强制转换为泛型ParameterizedType），可以使用getActualTypeArguments方法获取泛型中的具体类型（返回的是Type数组）

创建两个方法

创建两个方法用于演示。方法一test01，方法形参使用两个泛型和一个String类型，Map和List。Map中的具体类型有String和User。List中的具体类型有User。

1
2
3
 
public void test01(Map<String,User> map, List<User> list,String str){
    System.out.println("test01");
}

方法二test02，返回值类型使用泛型，Map。Map中的具体类型有User和String。

1
2
3
4
 
public Map<String,User> test02(){
    System.out.println("test02");
    return null;
}
测试方法一

通过Class对象获取类的方法（返回的是Method对象）

1
 
Method test01 = Test10.class.getMethod("test01", Map.class, List.class,String.class);

getParameterTypes方法，获取该方法的形参类型：

1
2
3
4
5
 
System.out.println("获取该方法的形参:");
Class<?>[] parameterTypes = test01.getParameterTypes();
for (Class<?> parameterType : parameterTypes) {//获取该方法的形参
    System.out.println(parameterType);
}

getGenericParameterTypes方法，获取该方法的形参类型(可获取泛型信息）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
Type[] genericParameterTypes = test01.getGenericParameterTypes();//获取该方法的形参(可获取泛型信息）
System.out.println("\n获取该方法的形参(可获取泛型信息）：");
for (Type genericParameterType : genericParameterTypes) {
    System.out.println(genericParameterType);
}
for (Type genericParameterType : genericParameterTypes) {
    if (genericParameterType instanceof ParameterizedType){//查看该泛型参数是否是参数化类型可理解为泛型（ParameterizedType）
        //获取参数化类型（泛型）<>中的实际类型
        Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
        System.out.println("\n泛型"+genericParameterType+"中的具体类型有：");
        for (Type actualTypeArgument : actualTypeArguments) {
            System.out.println(actualTypeArgument);
        }
    }
}

运行结果对比：
getGenericParameterTypes方法返回的数据中可以看出方法test01的形参Map和List是泛型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
获取该方法的形参:
interface java.util.Map
interface java.util.List
class java.lang.String

获取该方法的形参(可获取泛型信息）：
java.util.Map<java.lang.String, com.study.注解与反射.demo02.User>
java.util.List<com.study.注解与反射.demo02.User>
class java.lang.String

泛型java.util.Map<java.lang.String, com.study.注解与反射.demo02.User>中的具体类型有：
class java.lang.String
class com.study.注解与反射.demo02.User

泛型java.util.List<com.study.注解与反射.demo02.User>中的具体类型有：
class com.study.注解与反射.demo02.User

测试方法二

通过Class对象获取类的方法（返回的是Method对象）
getGenericReturnType方法，获取该方法的返回值类型(可获取泛型信息）： 

1
2
3
4
5
6
7
8
9
 
Method test02 = Test10.class.getDeclaredMethod("test02",null);
Type genericReturnType = test02.getGenericReturnType();//获取该方法的返回值类型
if (genericReturnType instanceof ParameterizedType){//判断是否是泛型
    Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();//如果是泛型，则获取其中具体的类型是什么
    System.out.println("\n\n方法test02的泛型返回值"+genericReturnType+"具体类型有：");
    for (Type actualTypeArgument : actualTypeArguments) {//for循环打印出泛型中具体的类型
        System.out.println(actualTypeArgument);
    }
}

操作注解

利用反射操作注解。通过反射操作注解，查看类、方法、属性等使用的注解是什么，查看注解中参数值是什么。（更高级的应用例如通过获取到的这些数据在数据库中动态创建表）

代码演示

步骤
  • 获取到Class对象或通过Class对象获取类的方法、属性等
  • 使用方法getAnnotation或getAnnotations获取注解信息。（返回Annotation对象或数组）
  • 获取到注解后强转回原类型（具体看使用了什么注解），使用注解.参数名的方式获取注解中的各参数值。

使用ORM进行举例：

  • 什么是ORM？

    • ORM = Object Relationship Mapping –> 对象关系映射

    • 类和表结构对应

    • 属性和字段对应（一列）

    • 对象和记录对应（表中的一行数据）

使用注解和反射完成类和表结构的映射关系：

创建类

创建类StudentTable，与数据库中的student表对应。类中定义id、age、name等属性，对应表中的字段。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
class StudentTable{
    @MyField(columnName = "db_id",type = "int",length = 10)
    private int id;
    @MyField(columnName = "db_age",type = "int",length = 10)
    private int age;
    @MyField(columnName = "db_name",type = "varchar",length = 3)
    private String name;

    public StudentTable() {
    }

    public StudentTable(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
自定义注解

这里使用自定义注解进行演示。自定义注解MyTable、MyField，分别用在类StudentTable上和类StudentTable的各个属性上。用于描述类名对应的是数据库中具体的哪个表，类中属性即表中字段具体的描述信息（该列的列名、类型、长度等）。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
//自定义注解--类名的注解--使用在StudentTable类上，用于描述类对应的数据库中的表名（类和表结构对应
@Target(ElementType.TYPE)//作用范围是包、类、接口等等
@Retention(RetentionPolicy.RUNTIME)//保存级别（Runtime，最高）
@interface MyTable{
    String value();//数据库中的表名
}

//自定义注解--属性的注解--使用在StudentTable类上，用于描述类属性（属性和字段对应（列）
@Target(ElementType.FIELD)//作用范围是域（属性
@Retention(RetentionPolicy.RUNTIME)//保存级别（Runtime，最高）
@interface MyField{
    String columnName();//列名
    String type();//类型
    int length();//长度
}
使用注解

给类StudentTable添加注解，使用自定义注解MyTable

1
2
3
4
 
@MyTable("db_student")//数据库中的表名
class StudentTable{
...
}

给类StudentTable中的各个属性添加注解，使用自定义注解MyField

1
2
3
4
5
6
7
8
9
10
 
@MyTable("db_student")//数据库中的表名
class StudentTable{
    @MyField(columnName = "db_id",type = "int",length = 10)//属性（字段）的信息：列名、类型、长度
    private int id;
    @MyField(columnName = "db_age",type = "int",length = 10)
    private int age;
    @MyField(columnName = "db_name",type = "varchar",length = 3)
    private String name;
    ...
}

获取注解
  • 获取到Class对象或通过Class对象获取类的方法、属性等
  • 使用方法getAnnotation或getAnnotations获取注解信息。（返回Annotation对象或数组）
类注解

获取类注解。

1
2
3
4
5
6
7
8
 
Class c1 = Class.forName("com.study.注解与反射.demo02.StudentTable");

//通过反射获取注解
Annotation[] annotations = c1.getAnnotations();
System.out.printf("获取到的类注解为：");
for (Annotation annotation : annotations) {
    System.out.println(annotation);//获取注解
}

运行结果：

1
 
获取到的类注解为：@com.study.注解与反射.demo02.MyTable(value=db_student)
属性注解

获取属性注解。

1
2
3
4
5
 
//获取类中指定属性的注解
Field f = c1.getDeclaredField("name");//获取指定的属性（以name为例
MyField myFieldAnno = f.getAnnotation(MyField.class);//获取属性使用的注解（已经知道了这个属性使用注解@MyField
////获取注解
System.out.println("\n获取到的属性注解:"+myFieldAnno);

运行结果：

1
 
获取到的属性注解:@com.study.注解与反射.demo02.MyField(columnName=db_name, type=varchar, length=3)
获取注解中的参数值
  • 获取到Class对象或通过Class对象获取类的方法、属性等
  • 使用方法getAnnotation或getAnnotations获取注解信息。（返回Annotation对象或数组）
  • 获取到注解后强转回原类型（具体看使用了什么注解），使用注解.参数名的方式获取注解中的各参数值。（注解中只有一个参数时一般使用value，所以上边自定义类注解时使用value）
类注解

获取类注解中的参数值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
        //通过反射获取注解
        Annotation[] annotations = c1.getAnnotations();
        System.out.printf("获取到的类注解为：");
        for (Annotation annotation : annotations) {
            System.out.println(annotation);//获取注解
            System.out.println("注解"+annotation+"中的参数值："+((MyTable)annotation).value());//获取注解中的value值。已经知道了这个类使用注解@MyTable
        }

//或


//        //获取注解的value值
//        MyTable myTable = (MyTable)c1.getAnnotation(MyTable.class);//获取类使用的注解（已经知道了这个类使用注解@MyTable
//        String value = myTable.value();//获取注解中的value值
//        System.out.println(value);

运行结果：

1
2
 
获取到的类注解为：@com.study.注解与反射.demo02.MyTable(value=db_student)
注解@com.study.注解与反射.demo02.MyTable(value=db_student)中的参数值：db_student
属性注解

获取属性注解中的参数值

1
2
3
4
5
6
7
8
 
//获取类中指定属性的注解
Field f = c1.getDeclaredField("name");//获取指定的属性（以name为例
MyField myFieldAnno = f.getAnnotation(MyField.class);//获取属性使用的注解（已经知道了这个属性使用注解@MyField
////获取注解中的列名、类型、长度
System.out.println("\n获取到的属性注解"+myFieldAnno+"中的参数值：");
System.out.printf("列名："+myFieldAnno.columnName());//列名
System.out.printf("\t类型："+myFieldAnno.type());//类型
System.out.printf("\t长度："+myFieldAnno.length());//长度

运行结果：

1
2
 
获取到的属性注解@com.study.注解与反射.demo02.MyField(columnName=db_name, type=varchar, length=3)中的参数值：
列名：db_name	类型：varchar	长度：3
若图片不能正常显示，请在浏览器中打开

欢迎关注我的其它发布渠道