java 反射机制sample

qfljg

于 2023-03-18 00:19:25 发布

阅读量427

点赞数

文章标签： java junit 开发语言

本文链接：https://blog.csdn.net/qfljg/article/details/129630704

版权

Java 反射（Reflection）是指在程序运行时，动态地获取和操作类的属性、方法、构造器等信息的机制。通过反射机制，可以在运行时获取类的信息，并且在不知道类名的情况下，可以创建对象、调用方法等。

除了对象序列化、动态代理以及常规的通过反射获取类信息、构造函数、方法和字段等，反射机制还有一些其他的应用场景。以下是其中的一些示例：

注解处理器

在 Java 中，可以通过反射机制来处理注解，即在运行时获取并处理注解信息。注解处理器可以用来实现一些自定义的框架和库，例如 Spring 框架中的注解处理器就使用了反射机制。

动态生成代码

反射机制可以用来在运行时动态生成代码。例如，可以通过反射机制创建一个新的类，然后动态添加方法和字段，并在运行时动态编译和加载该类。

测试工具

反射机制可以用来实现测试工具，例如 JUnit 就使用了反射机制来调用测试方法。

框架开发

在一些大型的框架和库中，反射机制可以用来实现扩展性和灵活性。例如，在 ORM 框架中，可以使用反射机制来获取实体类的字段和属性信息，然后将实体对象映射到数据库中。

总之，反射机制在 Java 中具有广泛的应用，可以用来实现一些高级的功能和技术。然而，反射机制也存在一些

局限性，例如效率较低、安全问题等，因此需要谨慎使用。

下面是一个利用 Java 反射机制，调用一个类的静态方法的示例：

import java.lang.reflect.Method;

public class ReflectUtil {

    public static void main(String[] args) throws Exception {
        // 获取类名为 "Sample" 的类
        Class<?> clazz = Class.forName("Sample");

        // 获取类中名为 "print" 的静态方法
        Method method = clazz.getDeclaredMethod("print");

        // 调用该方法
        method.invoke(null);
    }
}

class Sample {
    public static void print() {
        System.out.println("Hello, World!");
    }
}

在上面的示例中，首先通过 Class.forName 方法获取了类名为 "Sample" 的类的 Class 对象。然后，通过 clazz.getDeclaredMethod 方法获取了该类中名为 "print" 的静态方法。最后，通过 method.invoke 方法调用该方法，由于该方法是静态方法，因此传入的对象为 null。执行上述程序，输出结果为 "Hello, World!"。

除了调用静态方法之外，还可以利用反射机制获取和操作类的字段、构造器、实例方法等。下面是一个示例代码，演示如何通过反射获取类的构造器，并使用构造器创建一个新的对象：

import java.lang.reflect.Constructor;

public class ReflectUtil {

    public static void main(String[] args) throws Exception {
        // 获取类名为 "Person" 的类
        Class<?> clazz = Class.forName("Person");

        // 获取类的无参构造器
        Constructor<?> constructor = clazz.getDeclaredConstructor();

        // 使用构造器创建一个新的对象
        Object obj = constructor.newInstance();

        // 调用对象的 setName 方法
        Method setNameMethod = clazz.getDeclaredMethod("setName", String.class);
        setNameMethod.invoke(obj, "Tom");

        // 调用对象的 setAge 方法
        Method setAgeMethod = clazz.getDeclaredMethod("setAge", int.class);
        setAgeMethod.invoke(obj, 20);

        // 调用对象的 getInfo 方法
        Method getInfoMethod = clazz.getDeclaredMethod("getInfo");
        String info = (String) getInfoMethod.invoke(obj);

        System.out.println(info);
    }
}

class Person {
    private String name;
    private int age;

    public Person() {}

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

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

    public String getInfo() {
        return "Name: " + name + ", Age: " + age;
    }
}

在上面的示例中，通过 clazz.getDeclaredConstructor() 方法获取了类的无参构造器。然后，通过 constructor.newInstance() 方法创建了一个新的对象。接着，分别使用 setNameMethod.invoke 和 setAgeMethod.invoke 方法调用了对象的 setName 和 setAge 方法，设置了对象的属性值。最后，使用 getInfoMethod.invoke 方法调用了对象的 getInfo 方法，获取了对象的信息。执行上述程序，输出结果为 "Name: Tom, Age: 20"。

除了获取和操作类的信息之外，反射机制还可以动态地创建代理对象，用于实现某些特殊的功能，如动态代理、AOP（面向切面编程）等。下面是一个使用 Java 动态代理的示例代码：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ReflectUtil {

    public static void main(String[] args) {
        // 创建一个实现了 Calculator 接口的对象
        CalculatorImpl calculator = new CalculatorImpl();

        // 创建一个 InvocationHandler 对象
        InvocationHandler handler = new CalculatorInvocationHandler(calculator);

        // 创建一个代理对象
        Calculator proxy = (Calculator) Proxy.newProxyInstance(
                Calculator.class.getClassLoader(),
                new Class<?>[] {Calculator.class},
                handler);

        // 调用代理对象的方法
        int result = proxy.add(2, 3);
        System.out.println("Result: " + result);
    }
}

interface Calculator {
    int add(int a, int b);
}

class CalculatorImpl implements Calculator {
    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

class CalculatorInvocationHandler implements InvocationHandler {
    private Object target;

    public CalculatorInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before invoking method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After invoking method: " + method.getName());
        return result;
    }
}

在上面的示例中，首先创建了一个实现了 Calculator 接口的对象 calculator。然后，创建了一个 CalculatorInvocationHandler 对象，将 calculator 对象传入该对象的构造函数。接着，通过 Proxy.newProxyInstance 方法创建了一个代理对象 proxy，该代理对象实现了 Calculator 接口，并使用 handler 作为其 InvocationHandler。最后，调用了代理对象的 add 方法，输出结果为 "Before invoking method: add"、"After invoking method: add" 和 "Result: 5"。从输出结果可以看出，代理对象的方法调用被动态地拦截，并执行了一些额外的逻辑。

除了上述示例中的用法，反射机制还可以用于实现其他功能，如读取和操作注解、操作泛型、序列化和反序列化对象等。下面是一个读取和操作注解的示例代码：

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

@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String value();
}

public class ReflectUtil {

    public static void main(String[] args) throws Exception {
        // 获取 Person 类中的 getInfo 方法
        Method getInfoMethod = Person.class.getDeclaredMethod("getInfo");

        // 获取 getInfo 方法上的 MyAnnotation 注解
        MyAnnotation annotation = getInfoMethod.getAnnotation(MyAnnotation.class);

        // 输出注解的值
        System.out.println(annotation.value());
    }
}

class Person {
    @MyAnnotation("This is a person.")
    public String getInfo() {
        return "This is a person.";
    }
}

在上面的示例中，首先定义了一个注解 MyAnnotation，它有一个属性 value。然后，在 Person 类中的 getInfo 方法上标注了该注解，注解的 value 属性值为 "This is a person."。接着，通过 getDeclaredMethod 方法获取了 getInfo 方法的反射对象，并使用 getAnnotation 方法获取了该方法上的 MyAnnotation 注解。最后，输出注解的值 "This is a person."。

除了上述示例中的用法，反射机制还可以用于操作泛型。Java 泛型是在编译时实现的，这意味着在运行时无法获取泛型类型的具体信息。但是，在使用反射机制时，可以通过 Type 和 ParameterizedType 等类型获取泛型类型的信息。下面是一个操作泛型的示例代码：

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

public class ReflectUtil {

    public static void main(String[] args) throws Exception {
        List<String> list = new ArrayList<String>();

        // 获取 list 的类型信息
        Type type = list.getClass().getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            Type[] typeArguments = parameterizedType.getActualTypeArguments();
            for (Type typeArgument : typeArguments) {
                System.out.println(typeArgument);
            }
        }
    }
}

在上面的示例中，首先创建了一个泛型类型为 String 的 ArrayList 对象 list。然后，通过 getClass().getGenericSuperclass() 方法获取了 list 的类型信息，该信息是一个 ParameterizedType 对象。接着，通过 getActualTypeArguments() 方法获取了 list 的泛型类型信息，该信息是一个 Type 数组，数组中只有一个元素，即 String 类型。最后，输出了泛型类型信息 "class java.lang.String"。

反射机制还可以用于序列化和反序列化对象。Java 中提供了两种实现序列化和反序列化的方式：Java 序列化和 JSON 序列化。其中，Java 序列化是将对象转换为字节流，便于在网络上传输或保存到文件中；JSON 序列化是将对象转换为 JSON 格式的字符串，便于在 Web 应用中传输。在使用反射机制时，可以通过 Field 类获取对象的属性值，进而实现对象的序列化和反序列化。下面是一个使用反射机制实现 Java 序列化和反序列化的示例代码：

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Field;

public class ReflectUtil {

    public static void main(String[] args) throws Exception {
        // 创建一个 Person 对象
        Person person = new Person("Tom", 20);

        // 将 Person 对象序列化为字节数组
        byte[] bytes = serialize(person);

        // 将字节数组反序列化为 Person 对象
        Person newPerson = (Person) deserialize(bytes);

        // 输出新的 Person 对象的属性值
        System.out.println(newPerson.getName());
        System.out.println(newPerson.getAge());
    }

    public static byte[] serialize(Serializable object) throws Exception {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(object);
        return byteArrayOutputStream.toByteArray();
    }

    public static Object deserialize(byte[] bytes) throws Exception {
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
        ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
        Object object = objectInputStream.readObject();
        return object;
    }
}

class Person implements Serializable {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

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

    // 反射机制设置属性值
    public void setFieldValue(String fieldName, Object fieldValue) throws Exception {
        Field field = getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(this, fieldValue);
    }

    // 反射机制获取属性值
    public Object getFieldValue(String fieldName) throws Exception {
        Field field = getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        return field.get(this);
    }
}

在上面的示例中，首先创建了一个 Person 对象，并将其序列化为字节数组，然后将字节数组反序列化为新的 Person 对象 newPerson。接着，通过 getFieldValue 方法获取了 newPerson 的属性值，即 "Tom" 和 20。最后，输出了属性值。在 Person 类中，通过 setFieldValue 和 getFieldValue 方法实现了使用反射机制设置和获取属性值的功能。

除了对象序列化和反序列化，反射机制还可以用于动态代理。在 Java 中，动态代理是一种机制，它可以在运行时生成一个代理类对象，代理类对象可以代理一个或多个接口的实现类。动态代理机制常用于 AOP（面向切面编程），例如在 Spring 框架中，就使用了动态代理实现了 AOP 功能。下面是一个使用反射机制实现动态代理的示例代码：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ReflectUtil {

    public static void main(String[] args) {
        // 创建一个代理对象
        Subject subject = (Subject) Proxy.newProxyInstance(
                Subject.class.getClassLoader(),
                new Class[] {Subject.class},
                new MyInvocationHandler(new RealSubject()));

        // 调用代理对象的方法
        subject.request();
    }
}

interface Subject {
    void request();
}

class RealSubject implements Subject {
    public void request() {
        System.out.println("RealSubject: handling request.");
    }
}

class MyInvocationHandler implements InvocationHandler {
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("MyInvocationHandler: before handling request.");
        Object result = method.invoke(target, args);
        System.out.println("MyInvocationHandler: after handling request.");
        return result;
    }
}

在上面的示例中，首先定义了一个 Subject 接口和一个 RealSubject 实现类，然后通过 Proxy.newProxyInstance 方法创建了一个代理对象，并实现了 InvocationHandler 接口，通过实现 invoke 方法来实现对代理方法的增强。在 invoke 方法中，先输出 "MyInvocationHandler: before handling request."，然后通过反射机制调用实际的方法，最后输出 "MyInvocationHandler: after handling request."。这样，就可以实现对 RealSubject 的方法进行增强，从而达到 AOP 的效果。

以上是反射机制在 Java 中的一些基本应用。反射机制虽然灵活，但是由于它是在运行时进行的，所以效率比较低，而且使用反射机制容易出现类型安全问题，因此在使用反射机制时需要谨慎。