java – 反射&注解

^迷藏^

已于 2022-12-11 16:57:04 修改

阅读量523

点赞数 1

分类专栏： javase 文章标签： java 开发语言

于 2022-11-18 20:19:40 首次发布

本文链接：https://blog.youkuaiyun.com/qq_56056920/article/details/127928998

版权

javase 专栏收录该内容

36 篇文章

订阅专栏

java – 反射

反射

是一门Java提供的专门技术，该技术主要用来通过字节码对象，可以实现对相关Java类进行各种操作
反射是一门非常强大的Java技术，被广泛使用在各种框架中（spring , SpringMVC,Mybatis 等等）

如何获取Java中的字节码

现在我们有一个简单的类

/**
 * @author : YWJ
 * @date : 2022/11/18 : 15:14
 */
public class User {
    private String name ;
    private int age ;
    private char gender;

    public User(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    public User(){

    }

    private void test01(){
        System.out.println("这是一个私有方法");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }
}

方法一：通过类名称.class 获取

@Test
void test01(){
    Class<User> clazz = User.class;
    User user = null;
    try {
        user = clazz.newInstance();
        user.setAge(10);
        user.setGender('男');
        user.setName("张三");
        System.out.println(user);
    } catch (InstantiationException | IllegalAccessException e) {
        e.printStackTrace();
    }
}
/*
执行结果
User{name='张三', age=10, gender=男}
*/

方法二：通过对象.getClass()获取

@Test
void test02(){
    User user = new User();
    Class<User> clazz = (Class<User>) user.getClass();
    Constructor<User> constructor = null;
    try {
        //获取有参数的构造函数
        constructor = clazz.getConstructor(String.class, int.class, char.class);
        //构造对象
        User user1 = constructor.newInstance("张三",10,'男');
        System.out.println(user1);
    } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
        e.printStackTrace();
    }
}

方法三、通过Class.forName()获取

@Test
void test03(){
    //类的类路经
    try {
        Class<?> clazz = Class.forName("User");
        Constructor<User> constructor = (Constructor<User>) clazz.getConstructor();
        User user = constructor.newInstance();
        System.out.println(user);
    } catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException | InstantiationException | IllegalAccessException e) {
        e.printStackTrace();
    }
}

类路径：一般情况下：域名+项目名称+包名+java文件名称

通过反射技术操作字节码对象，实现各种功能

通过反射创建对象

字节码对象.newInstance()方法

通过反射获取构造器

字节码对象.getDeclaredConstructor
字节码对象.getDeclaredConstructors
字节码对象.getConstructor
字节码对象.getConstructors

其中有Declared…表示获取该类自定义的成员(包括私有的)

没有Delclared的，表示获取所有的能够访问到的成员，包括父类

@Test
void test04(){
    try {
        Class<?> clazz = Class.forName("User");
        Constructor<?>[] constructors = clazz.getConstructors();
        for (int i = 0; i < constructors.length; i++) {
            System.out.println(constructors[i]);
            System.out.println(constructors[i].getName());//获取类路径
            System.out.println(constructors[i].getParameterTypes());//返回参数列表的类型数组
            System.out.println(constructors[i].getParameterCount());//参数列表的长度
            System.out.println(constructors[i].getModifiers());//函数权限对应的int值
            if(constructors[i].getParameterCount() == 3){
                Constructor<?> constructor = clazz.getConstructor(String.class, int.class, char.class);
                User user1 = (User) constructor.newInstance("张三",10,'男');
                System.out.println(user1);
            }
        }
    } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
        e.printStackTrace();
    }
}
/*
执行结果
public User(java.lang.String,int,char)
User
[Ljava.lang.Class;@128d2484
3
1
User{name='张三', age=10, gender=男}
public User()
User
[Ljava.lang.Class;@411f53a0
0
1
*/

通过反射获取各种类方法

类对象.getMethod
类对象.getMethods
类对象.getDeclaredMethod
类对象.getDeclaredMethods

其中有Declared…表示获取该类自定义的成员(包括私有的)

没有Delclared的，表示获取所有的能够访问到的成员，包括父类

@Test
void test01(){
    try {
        Class<?> clazz = Class.forName("User");
        //拿到私有方法test01
        Method method = clazz.getDeclaredMethod("test01");
        //构造一个对象
        User user = (User) clazz.getConstructor().newInstance();
        //解除封装
        method.setAccessible(true);
        //调用方法
        method.invoke(user);
    } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
        e.printStackTrace();
    }
}
/*
执行结果
这是一个私有方法
*/

私有方法调用之前应该解除封装： setAccessible(true)
执行方法使用：invoke方法

利用反射操作属性和注解

类对象.getField
类对象.getFields
类对象.getDeclareField
类对象.getDeclareFields

@Test
void test02(){
    try {
        Class<?> clazz = Class.forName("User");
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field filed : declaredFields){
            System.out.println(filed);
        }
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}
/*
执行结果
@Test
    void test02(){
        try {
            Class<?> clazz = Class.forName("User");
            Field[] declaredFields = clazz.getDeclaredFields();
            for(Field filed : declaredFields){
                System.out.println(filed);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
*/

利用反射完成对象的拷贝

@Test
void test03(){
    User user = new User("张三",10,'男');
    User user1 = new User();
    System.out.println(user);
    System.out.println(user1);
    copyObject(user,user1);
    System.out.println(user1);
}

private void copyObject(User user, User user1) {
    Class< User> clazz = (Class<User>) user.getClass();
    Field[] declaredFields = clazz.getDeclaredFields();
    for (Field field: declaredFields) {
        try {
            field.setAccessible(true);
            Object o = field.get(user);
            field.set(user1,o);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}
/*
执行结果
User{name='张三', age=10, gender=男}
User{name='null', age=0, gender= }
User{name='张三', age=10, gender=男}
*/

注解（Annotation）

jdk1.5之后官方提供了大量的注解：例如重写的@Override @NotNull等等
配合反射，可以实现多的功能，非常简洁方便
减轻项目的大量复杂的配置，通过简单的注解实现对应的功能

@Documented – 注解是否将包含在JavaDoc中

一个简单的Annotations 标记注解，表示是否将注解信息添加在java 文档中。

@Retention – 定义该注解的生命周期

RetentionPolicy.SOURCE : 在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义，所以它们不会写入字节码。@Override, @SuppressWarnings都属于这类注解。
RetentionPolicy.CLASS : 在类加载的时候丢弃。在字节码文件的处理中有用。注解默认使用这种方式
RetentionPolicy.RUNTIME : 始终不会丢弃，运行期也保留该注解，因此可以使用反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。

@Target – 表示该注解用于什么地方。默认值为任何元素，表示该注解用于什么地方。

ElementType.CONSTRUCTOR: 用于描述构造器
ElementType.CONSTRUCTOR: 用于描述构造器
ElementType.FIELD: 成员变量、对象、属性（包括enum实例）
ElementType.LOCAL_VARIABLE: 用于描述局部变量
ElementType.METHOD: 用于描述方法
ElementType.PACKAGE: 用于描述包
ElementType.PARAMETER: 用于描述参数
ElementType.TYPE: 用于描述类、接口(包括注解类型) 或enum声明

@Inherited – 定义该注释和子类的关系

@Inherited 元注解是一个标记注解，@Inherited 阐述了某个被标注的类型是被继承的。

如果一个使用了@Inherited 修饰的annotation 类型被用于一个class，则这个annotation 将被用于该class 的子类。

自定义注解

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/**
 * @author : YWJ
 * @date : 2022/11/18 : 19:45
 */
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    public String value() default "自定义注解";
    int version();
}

可以看到语法： public @interface + 注解名称
同时只能有属性，没有方法
默认修饰符public，可以省略
定义方式为，类型变量名（）
使用default 设置默认值
也可以不设置默认值

这里定义一个类，使用我们自定义的注解

/**
 * @author : YWJ
 * @date : 2022/11/18 : 20:04
 */
@MyAnnotation(version =1)
public class Demo {
    @MyAnnotation(version = 1)
    String str ;

    @MyAnnotation(version = 1)
    public Demo() {
    }

    public Demo(String str) {
        this.str = str;
    }
    
    @MyAnnotation(version = 1)
    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }
}

利用反射获取注解

@Test
void test01(){
    try {
        Class<?> clazz = Class.forName("Demo");
        Annotation[] annotations = clazz.getAnnotations();
        for(Annotation annotation : annotations){
            System.out.println(annotation);
        }

    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}
/*
执行结果
@MyAnnotation(value="自定义注解", version=1)
*/