10分钟带你理解Java中的反射

什么是反射？

先从字面意思来理解，反射（Reflection）就是“映射回去”的意思。在Java中，反射就是运行时动态地获取一个类的信息，并可以对其进行操作的能力。

反射机制在运行时确定一个类的方法、字段等信息，而不需要在编译时确定。这样就可以在运行时通过一个字符串来获取相应的类、方法、属性等，增加了代码的灵活性。

反射基础

Java反射主要通过以下三个类来实现：

• Class：表示一个类或接口，在运行时可以动态获取和操作它的信息；
• Method：表示类的方法；
• Field：表示类的属性。

获取Class对象

在Java中，Class类是用来描述类信息的，每个类在虚拟机中都有一个对应的Class对象，我们可以通过以下三种方式来获取Class对象：

1. 调用对象的getClass()方法；
2. 调用类的静态变量class；
3. 使用Class.forName()方法。

//获取Object类的Class对象
Class<Object> clazz1 = new Object().getClass();
Class<Object> clazz2 = Object.class;
Class<?> clazz3 = Class.forName("java.lang.Object");

获取类的信息

通过Class对象我们可以获取一个类的字段、方法、构造方法等信息。

//获取类的所有字段
Field[] fields = clazz.getFields();
for (Field field : fields) {
    System.out.println(field.getName());
}

//获取类的所有方法
Method[] methods = clazz.getMethods();
for (Method method : methods) {
    System.out.println(method.getName());
}

//获取类的所有构造方法
Constructor[] constructors = clazz.getConstructors();
for (Constructor constructor : constructors) {
    System.out.println(constructor.getName());
}

调用方法/属性

通过反射我们可以在运行时调用类的方法和属性。下面是一个示例，通过反射获取一个类的字段并设置其值：

public class MyClass {
    private int x;
    public MyClass(){
        this.x = 10;
    }
    public void print(){
        System.out.println(this.x);
    }
}

//获取MyClass类的对象
Class<MyClass> clazz = MyClass.class;
MyClass obj = clazz.newInstance();

//获取MyClass类的x属性
Field field = clazz.getDeclaredField("x");

//设置x属性的值
field.setAccessible(true);
field.set(obj, 20);

//调用print方法输出x的值
Method method = clazz.getMethod("print");
method.invoke(obj);

示例说明

示例一

假设我们在开发一个配置文件读取工具时需要对配置文件进行一个解析，但是具体的配置文件格式未知，为了解析不同的配置文件，我们可以通过反射来动态获取对象的属性。

public class AppConfig {
    private String name;
    private String version;
    //getters and setters
}

public class ConfigParser {
    public static AppConfig parse(String fileName){
        File configFile = new File(fileName);
        Properties props = new Properties();
        try {
            props.load(new FileInputStream(configFile));
            //通过反射来动态获取对象的属性
            AppConfig config = new AppConfig();
            Class clazz = AppConfig.class;
            Field[] fields = clazz.getDeclaredFields();
            for(Field field : fields){
                String name = field.getName();
                String value = props.getProperty(name);
                if(value != null){
                    field.setAccessible(true);
                    field.set(config, value);
                }
            }
            return config;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

示例二

在某些情况下，我们可能需要根据类的名称动态创建对象并调用其方法。

public class MessageService {
    public void sendMessage(String message){
        System.out.println("send message: " + message);
    }
}

public class MessageServiceFactory {
    public static Object create(String className){
        try {
            Class clazz = Class.forName(className);
            return clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

public class MessageClient {
    public static void main(String[] args) {
        String className = "demo.MessageService";
        Object obj = MessageServiceFactory.create(className);
        if(obj instanceof MessageService){
            MessageService messageService = (MessageService) obj;
            messageService.sendMessage("Hello World!");
        }
    }
}

总结

反射机制是Java强大的一个特性，可以让我们在运行时获取类的信息，并对其进行动态操作。但是反射也带来了额外的开销和泛滥使用的风险，因此在使用反射时需要小心谨慎。