【Java菜鸟学习进阶路线】Java进阶知识篇之Java反射机制

Java反射机制是指在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性。这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。

为什么要用反射？

1. 动态性：反射机制可以在程序运行时动态地获取类的信息并调用类的方法或操作类的属性，从而具有很好的灵活性和扩展性。这种特性使得程序能够自我检查并在运行时对内部成员进行操作。

2. 通用性：反射机制适用于所有的Java类，因此在编写代码时不需要针对每个类都进行特殊处理。

3. 解耦性：通过反射机制，可以在不修改代码的情况下获得新增的类的对象，这降低了模块之间的耦合性，提高了程序的适应能力。

4. 提高代码复用性：反射机制可以让程序在运行时创建和控制任何类的对象，这样就无需提前硬编码目标类。

Java反射机制的原理

Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。其本质是Java虚拟机（JVM）在得到class对象之后再通过class对象进行反编译，进而获取对象的各种信息。这种在运行状态中，对任意一个类，都能够知道这个类的所有属性和方法；对任意一个对象，都能够调用它的任意方法和属性的功能被称为Java语言的反射机制。

Java反射的应用场景

1. 动态加载类和创建对象：反射允许我们在运行时动态地加载类，并创建其实例。例如，我们可以依据配置文件或用户输入来决定要加载的类，从而实现代码的灵活扩展性。此外，如果项目底层数据库有时使用MySQL，有时使用Oracle，需要根据实际情况动态地加载驱动类，反射机制就能派上用场。

2. 调用对象的方法：通过反射，我们可以在运行时动态地调用对象的方法。这使得程序能够根据不同的条件选择执行不同的方法，实现更为复杂的业务逻辑。另一个典型的应用场景是服务任务工作流，其中的每个服务任务都对应一个类的一个方法。服务任务B执行哪个类的哪个方法，以及服务任务C执行哪个类的哪个方法，都是由之前服务任务的执行结果所决定的。

3. 获取和修改类的属性：通过反射，我们可以在运行时动态地获取和修改类的属性值。这为某些需要在运行时改变属性值的场景提供了便利。

4. 实现框架：反射机制被视为Java框架的基石。许多知名的开源框架如Hibernate和Spring在内部大量使用了反射机制来提高代码的灵活性和扩展性。

Spring中的反射

在Spring框架中，反射主要被用于实现AOP（面向切面编程）和动态代理。以下是一些使用反射的示例

1. 使用反射创建Bean实例

import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;

public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        // 创建一个Bean工厂
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();

        // 创建一个XML读取器
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);

        // 加载XML配置文件
        reader.loadBeanDefinitions("classpath:applicationContext.xml");

        // 通过反射获取Bean实例
        Object bean = factory.getBean("myBeanName");
    }
}

2. 使用反射调用方法

import java.lang.reflect.Method;

public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        // 获取目标类的Class对象
        Class<?> clazz = Class.forName("com.example.MyClass");

        // 创建目标类的对象
        Object obj = clazz.newInstance();

        // 获取目标方法的Method对象
        Method method = clazz.getDeclaredMethod("myMethod", null); // 第二个参数为参数类型数组，因为此方法是无参方法，所以为null

        // 调用目标方法
        method.invoke(obj, null); // 第二个参数为方法的参数值，因为此方法是无参方法，所以为null
    }
}

3. 使用反射实现动态代理

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

public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        // 获取目标接口的Class对象
        Class<?> targetInterface = Class.forName("com.example.MyInterface");

        // 创建InvocationHandler对象
        InvocationHandler handler = new MyInvocationHandler();

        // 使用Proxy.newProxyInstance()方法创建代理对象
        Object proxy = Proxy.newProxyInstance(targetInterface.getClassLoader(), new Class[]{targetInterface}, handler);

        // 调用代理对象的方法
        ((MyInterface) proxy).myMethod();
    }
}

使用反射时的一些注意点

1. 性能开销：相比于直接的Java代码，反射涉及了类型检查、字段和方法解析等操作，因此会引入额外的性能开销。在对性能有严格要求的场景下，应尽量避免使用反射。

2. 安全问题：由于反射允许在运行时访问和修改类的属性和方法，因此可能会引发安全问题。例如，通过反射可以绕过访问权限限制，调用私有方法或修改私有变量的值。在使用反射时，需要确保代码的安全性。

• 反射破坏单例模式

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

	public static void main(String[] args) throws Exception {
	        // 获取Singleton类的Class对象
	        Class<?> singletonClass = Singleton.class;
	
	        // 获取Singleton类的私有构造方法
	        Constructor<?> constructor = singletonClass.getDeclaredConstructor();
	
	        // 设置构造方法可访问
	        constructor.setAccessible(true);
	
	        // 使用反射创建Singleton实例
	        Singleton instance1 = (Singleton) constructor.newInstance();
	        Singleton instance2 = (Singleton) constructor.newInstance();
	
	        // 输出两个实例是否相同
	        System.out.println(instance1 == instance2); // 输出false，说明反射破坏了单例模式
	    }
	}
	

4. 可读性和可维护性：反射代码通常比非反射代码更难阅读和理解，因为它依赖于字符串形式的类名和方法名。此外，反射代码可能难以调试和维护。为了提高代码的可读性和可维护性，应尽量减少反射的使用，或者将反射相关的代码封装在一个工具类中。

5. 泛型擦除：Java中的泛型信息在编译后会被擦除，因此在运行时无法获取到泛型参数的类型信息。这意味着在使用反射时，如果涉及到泛型类型，可能需要进行额外的处理。

6. 破坏封装性：反射允许在运行时访问和修改类的私有属性和方法，这破坏了类的封装性。为了遵循面向对象编程的原则，应尽量降低反射的使用频率，并确保在使用时遵循良好的编码规范。

7. 版本兼容性问题：不同版本的Java可能存在不同的反射实现和API。在使用反射时，需要确保代码在不同版本的Java环境中具有兼容性。

总结

反射给我们编码带来方便的同时也在破坏着编码规范，使代码隐含一些未知风险，需要考虑完全的情况下慎重使用。

下一章将讲解Java泛型