反射-灵析社区

一、什么是反射

Java 反射是指在运行时动态地获取类的信息并对类进行操作的机制。通过反射，我们可以在运行时获取一个类的信息，包括类名、方法、属性、注解等，并且可以动态地调用它们。

绝大部分的框架都使用了反射技术。

如何使用 Java 反射？

要使用 Java 反射，我们需要使用 java.lang.reflect 包中的类和接口。以下是一些常用的反射类：

下面是一个使用 Java 反射的示例程序，它将创建一个 Person 类的实例，并使用反射获取和设置其属性和方法：

package cn.leetcode.reflectdemo.entity;

public class Person {

    private String name;

    public void sayHello() {
        System.out.println("Hello, my name is " + name + "!");
    }

}

package cn.leetcode.reflectdemo.entity;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectExample {
  
    public static void main(String[] args) throws Exception {
        // 获取 Person 类的 Class 对象
        Class<?> personClass = Class.forName("cn.leetcode.reflectdemo.entity.Person");
        
        // 创建一个 Person 实例
        Object personObj = personClass.newInstance();
        
        // 获取 Person 类的 name 属性
        Field nameField = personClass.getDeclaredField("name");
        nameField.setAccessible(true);
        
        // 设置 Person 实例的 name 属性为 "Alice"
        nameField.set(personObj, "Alice");
        
        // 获取 Person 类的 sayHello() 方法
        Method sayHelloMethod = personClass.getDeclaredMethod("sayHello");
        sayHelloMethod.setAccessible(true);
        
        // 调用 Person 实例的 sayHello() 方法
        sayHelloMethod.invoke(personObj);
    }
  
}

在这个示例中，我们首先使用 Class.forName 方法获取 Person 类的 Class 对象。然后，我们使用 newInstance 方法创建一个 Person 实例。接着，我们使用 getDeclaredField 方法获取 Person 类的 name 属性，并将其设置为可访问状态。然后，我们使用 set 方法将 Person 实例的 name 属性设置为 "Alice"。接着，我们使用 getDeclaredMethod 方法获取 Person 类的 sayHello 方法，并将其设置为可访问状态。最后，我们使用 invoke 方法调用 Person 实例的 sayHello 方法，从而输出 "Hello, my name is Alice!"。

总结

Java 反射是一种强大的机制，它允许我们在运行时获取类的信息并对对象进行操作。

反射的作用：

在运行的时候获得类的全部信息
类编译完成以后得到 Class 文件，可以通过反射得到所有的信息；
Java 的反射机制，为每一个类里的元素设计了「类」来描述「类」的信息，例如：方法、属性、注解、泛型、构造方法。

通过反射，我们可以动态地获取和设置类的属性、调用类的方法等。然而，反射也具有一些缺点，例如它的性能相对较低，因此我们应该谨慎使用反射，并尽量避免过度使用。

常见面试、笔试问题

除了使用关键字 new 创建对象之外，还可以用什么方法创建对象？

在 Java 中，除了使用 new 关键字创建对象之外，还可以使用以下几种方法：

通过反射机制创建对象：使用 Java 反射机制可以在运行时动态地创建对象，通过 Class 类的 newInstance() 方法可以创建一个对象的实例，例如：

Class myClass = MyClass.class;
Object myObject = myClass.newInstance();

使用对象克隆：Java 中的所有类都继承了 Object 类，Object 类提供了一个 clone() 方法，可以使用该方法创建一个对象的克隆对象，例如：

MyClass obj1 = new MyClass();
MyClass obj2 = (MyClass) obj1.clone();

使用反序列化创建对象：将一个对象转换为字节流进行传输或存储，可以使用反序列化机制将其重新转换为对象，例如：

ObjectInputStream in = new ObjectInputStream(new FileInputStream("object.ser"));
MyClass myObject = (MyClass) in.readObject();

需要注意的是，以上方法可能会涉及到异常处理和安全性问题，需要谨慎使用。

反射创建对象效率高还是通过 new 创建对象的效率高？

在 Java 中，使用反射机制创建对象的效率相对于直接使用 new 关键字创建对象而言是较低的。这是因为使用反射机制需要在运行时动态地获取类的信息，包括类的构造方法、字段和方法等，这些操作会增加额外的开销。

相比之下，直接使用 new 关键字创建对象，编译器可以在编译时确定类的构造方法和字段，因此不需要在运行时进行额外的操作，创建对象的效率较高。

然而，使用反射机制创建对象的优势在于其灵活性和动态性，能够在运行时根据需要动态地获取类的信息并创建对象。因此，如果需要在运行时动态地创建对象并且程序的性能要求不是非常高，则可以使用反射机制创建对象。但是，如果对性能有较高的要求，则应该尽可能避免使用反射机制来创建对象。

二、反射的应用·

Java 反射是一种强大的机制，可以在运行时动态地获取和操作 Java 对象的信息，包括类的名称、方法、属性等。Java 反射广泛应用于以下领域。

框架和库的开发

Java 反射是很多框架和库的基础，例如 Spring 框架就广泛使用了Java 反射机制，用于实现依赖注入、AOP 等功能。

序列化和反序列化

以下是一个简单的示例代码，演示如何使用 Java 反射 API 来实现对象的序列化和反序列化：

import java.lang.reflect.Field;

public class SerializationExample {
    
    public static void main(String[] args) {
        // 创建一个对象
        Person person = new Person("LeetCoder", 22);

        // 序列化对象
        String serialized = serialize(person);
        System.out.println("序列化结果：" + serialized);

        // 反序列化对象
        Person deserialized = deserialize(serialized, Person.class);
        System.out.println("反序列化结果：" + deserialized);
    }

    // 序列化方法
    public static <T> String serialize(T obj) {
        StringBuilder stringBuilder = new StringBuilder();
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            try {
                stringBuilder.append(field.getName()).append("=").append(field.get(obj)).append(",");
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        stringBuilder.deleteCharAt(stringBuilder.length() - 1);
        return stringBuilder.toString();
    }

    // 反序列化方法
    public static <T> T deserialize(String str, Class<T> cls) {
        try {
            String[] parts = str.split(",");
            T obj = cls.newInstance();
            for (String part : parts) {
                String[] kv = part.split("=");
                Field field = cls.getDeclaredField(kv[0]);
                field.setAccessible(true);
                setValue(field, obj, kv[1]);
            }
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    // 根据属性类型设置属性值
    private static void setValue(Field field, Object obj, String value) throws Exception {
        if (field.getType() == int.class) {
            field.setInt(obj, Integer.parseInt(value));
        } else if (field.getType() == String.class) {
            field.set(obj, value);
        }
        // 其他类型同理，可以根据实际情况进行扩展
    }
}

class Person {

    private String name;

    private int age;

    public Person() {

    }

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

    public String toString() {
        return "Person{name=" + name + ", age=" + age + "}";
    }

}

Java 反射可以用于序列化和反序列化 Java 对象，例如 Java 的 ORM 框架 Hibernate 就使用了 Java 反射机制。

动态代理

Java 反射可以用于实现动态代理，例如 Java 的 RMI 机制底层使用了反射技术来实现远程方法调用。

单元测试

Java 反射可以用于单元测试框架中，例如 JUnit，JUnit 就利用 Java 反射机制来自动执行测试用例。以下是一个简单的使用 Java 反射实现JUnit 功能的代码示例：

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

public class JUnitRunner {

    public static void run(Class<?> testClass) throws Exception {
        Object testObject = testClass.newInstance();
        for (Method method : testClass.getMethods()) {
            if (method.isAnnotationPresent(Test.class)) {
                method.invoke(testObject);
            }
        }
    }

    public static void main(String[] args) throws Exception {
        run(MyTestClass.class);
    }

}

class MyTestClass {

    @Test
    public void testMethod() {
        System.out.println("Test method called");
    }

}

@Retention(RetentionPolicy.RUNTIME)
@interface Test {

}

当我们运行这个程序时，它将自动执行 MyTestClass 类中的被我们自定义的注解 @Test 修饰的 testMethod() 方法，并输出测试结果。

调试工具

Java 反射可以用于调试工具，例如 Java 反射 API 可以用于分析 Java 类的结构、方法、属性等信息，帮助程序员调试代码。例如：测试私有方法和字段：

MyClass obj = new MyClass();
Method method = obj.getClass().getDeclaredMethod("myPrivateMethod");
method.setAccessible(true);
method.invoke(obj);

这个代码片段使用反射机制调用了 MyClass 类中的 myPrivateMethod() 私有方法。您可以使用这种方法来检查您的代码中的私有方法和字段是否按预期运行，以及在需要时修改它们。

总结

Java 反射虽然有很多用途，但是反射的使用也有一些限制，例如反射的性能比直接调用 Java 对象的方法要低，而且反射也可能会导致代码可读性降低，因此在实际编程中应该谨慎使用 Java 反射API。

常见面试、笔试问题

举例 Java 框架中用到的反射机制

在 Java 框架中，反射机制被广泛地应用于各种场景中，使得 Java 程序具有更高的灵活性和可扩展性，以下是一些常见的应用场景：

Spring 框架中的依赖注入（DI）和控制反转（IOC）：Spring 框架在初始化 Bean 的时候，会通过反射机制来获取 Bean 的信息，例如Bean 的类名、属性名和方法名等，然后动态地创建 Bean 对象并注入相关的依赖；
Hibernate 框架中的 ORM 映射：Hibernate 框架通过反射机制来获取实体类的属性和对应的数据库字段，从而实现 Java 对象和关系型数据库之间的映射；
JUnit 框架中的单元测试：JUnit 框架使用反射机制来获取测试类的信息，并执行其中被标记为测试方法的方法；
Java 反射 API 本身的实现：Java 反射 API 本身就是通过反射机制来实现的，它提供了许多用于获取类的信息、调用对象方法、访问对象属性等功能的方法；
Java 的动态代理机制：Java 动态代理机制通过反射机制来生成代理类，实现动态地创建代理对象的功能。

三、动态代理

动态代理是 Java 反射的一个重要应用，它是一种实现 AOP（面向切面编程）的技术，通过在运行时动态地生成代理对象，来实现对原始对象的代理控制和扩展。

Java 中代理模式有两种实现方式：静态代理和动态代理。在讲解动态代理之前，我们先看看静态代理。

静态代理

静态代理是指代理类和被代理类在编译期间就已经确定了，代理类持有被代理类的引用，通过调用被代理类的方法来实现代理功能。以下是一个简单的使用静态代理的示例代码：

package cn.leetcode;

interface Subject {
  
    void request();
  
}

class RealSubject implements Subject {

    public void request() {
        System.out.println("RealSubject executes request.");
    }

}

class ProxySubject implements Subject {

    private Subject realSubject;

    public ProxySubject(Subject realSubject) {
        this.realSubject = realSubject;
    }

    public void request() {
        System.out.println("Before executing request.");
        realSubject.request();
        System.out.println("After executing request.");
    }

}

public class StaticProxyExample {

    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        Subject proxySubject = new ProxySubject(realSubject);
        proxySubject.request();
    }

}

输出：

Before executing request.
RealSubject executes request.
After executing request.

我们看到：静态代理实现简单，但是对于每个被代理类，都需要写一个对应的代理类，代码复杂度高。

动态代理

动态代理是指在程序运行时根据需要动态创建代理对象的技术。代理类是在运行时动态生成的，不需要手动编写。动态代理可以减少代码量，提高代码的复用性，代理类可以在不修改被代理类的情况下对其进行简单的扩展和重构。

动态代理解决了静态代理需要手动编写代理类的问题，可以减少代码量和提高代码复用性。

在 Java中，可以使用 JDK 动态代理或者 CGlib 动态代理来实现在运行时动态地改变代理对象的功能。下面是一个使用 JDK 动态代理来动态改变代理对象的示例代码：

package cn.leetcode;

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

interface Subject {

    void request();

}

class RealSubject implements Subject {

    public void request() {
        System.out.println("RealSubject executes request.");
    }

}

class DynamicProxy implements InvocationHandler {

    private Object subject;

    public DynamicProxy(Object subject) {
        this.subject = subject;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before executing request.");
        Object result = method.invoke(subject, args);
        System.out.println("After executing request.");
        return result;
    }

}

public class DynamicProxyExample {

    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        InvocationHandler dynamicProxy = new DynamicProxy(realSubject);
        Subject proxySubject = (Subject) Proxy.newProxyInstance(realSubject.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), dynamicProxy);
        proxySubject.request();
    }

}

输出：

Before executing request.
RealSubject executes request.
After executing request.

使用动态代理可以方便地实现拦截器、AOP、事务管理等功能。例如，可以通过动态代理来实现方法执行前后的日志记录、权限校验、性能监控等功能，从而可以方便地对多个类的方法进行统一管理。

总结

动态代理的实现过程

在 Java 中，可以通过实现 InvocationHandler 接口和 Proxy 类来实现动态代理。具体实现过程如下：

定义一个 InvocationHandler 接口的实现类，实现 invoke() 方法，该方法将被代理对象的所有方法调用；
使用 Proxy 类的静态方法 newProxyInstance() 创建一个代理对象，该代理对象会调用 InvocationHandler 接口实现类的 invoke() 方法来处理所有方法调用；
将代理对象返回给调用方，调用方可以像调用原始对象一样来使用代理对象。

动态代理的主要优点在于它可以在运行时动态地生成代理对象，从而可以灵活地控制和扩展对象的行为，同时也可以实现对原始对象的保护，避免直接修改原始对象。动态代理在许多框架和库中都得到了广泛的应用，例如 Spring AOP、Hibernate 等。

常见的面试、笔试问题

动态代理、静态代理的区别，什么场景使用静态代理、什么场景使用动态代理？

Java 中的代理模式是一种常见的设计模式，它可以帮助我们在不修改原有代码的情况下实现额外的功能或控制。代理模式主要有两种实现方式：静态代理和动态代理。

静态代理是在编译期间就已经确定了代理类的代码，代理类和目标对象之间的关系在程序运行前就已经确定。在静态代理中，代理类需要手动编写，代理类和目标对象实现同样的接口或者继承同一个父类，代理类中调用目标对象的方法，并在方法前后添加额外的逻辑或者控制。静态代理的优点是可以在编译期间检查出代理类和目标对象是否实现了同样的接口或者继承了同一个父类，代理类的实现相对简单，容易理解和掌握。缺点是每一个目标对象都需要对应一个代理类，如果目标对象的方法发生变化，代理类的代码也需要进行相应的修改，工作量相对较大。

动态代理是在运行期间动态生成代理类的代码，代理类和目标对象之间的关系在程序运行时才能确定。在动态代理中，代理类可以不需要手动编写，通过 Java 的反射机制在运行时动态生成代理类的字节码，代理类中的方法会在运行时动态地调用目标对象的方法，并在方法前后添加额外的逻辑或者控制。动态代理的优点是可以在运行期间动态地生成代理类，不需要手动编写代理类，可以适应多种不同的目标对象，代码的维护和扩展性较好。缺点是动态代理的实现相对较为复杂，需要了解Java反射机制和动态代理的实现原理。

通常情况下，如果目标对象的数量不多，且每个目标对象需要不同的代理逻辑，可以使用静态代理；如果目标对象的数量较多，且每个目标对象需要相同的代理逻辑，可以使用动态代理。另外，动态代理还可以用于 AOP 编程，帮助我们在不修改原有代码的情况下实现切面编程。

反射-灵析社区

一、 什么是反射

二、反射的应用·

三、 动态代理

一、什么是反射

三、动态代理