Java 基础篇之反射

反射

使用反射获取程序运行时的对象和类的真实信息。

获取 Class 对象

每个类被加载之后，系统会为该类生成一个对应的 Class 对象，通过该 Class 对象可以访问到 JVM 中的这个类。

• 使用 Class 类的 forName(String clazzName) 静态方法。字符串参数的值是某个类的全限定类名，必须包含完整的包名

• 调用某个类的 class 属性

• 调用某个对象的 getClass() 方法。该方法是 java.lang.Object 类中的一个方法，所有的 Java 对象都可以调用，返回该对象所属类对应的 Class 对象

获取 Class 对象中信息

Class 类提供了大量的实例方法来获取该 class 对象所对应的类的详细信息。更多请参考 API。

import java.lang.reflect.*;
import java.lang.annotation.*;

public class ClassTest {
    private ClassTest() {
    }

    public ClassTest(String name) {
        System.out.println("执行有参数的构造器");
    }

    public void info() {
        System.out.println("执行无参数的info方法");
    }

    public void info(String str) {
        System.out.println("执行有参数的info方法" + ",其 str 参数值: " + str);
    }

    class Inner {
    }

    public static void main(String[] args) throws Exception {
        Class<ClassTest> clazz = ClassTest.class;

        // 获取 clazz 对象所对应类的全部构造器
        Constructor<?>[] ctros = clazz.getDeclaredConstructors();
        System.out.println("ClassTest 的全部构造器如下: ");
        for (Constructor c : ctros) {
            System.out.println(c);
        }

        // 获取 clazz 对象所对应类的全部 public 构造器
        Constructor<?>[] publicCtors = clazz.getConstructors();
        System.out.println("ClassTest的全部public构造器如下：");
        for (Constructor c : publicCtors) {
            System.out.println(c);
        }

        // 获取 clazz 对象所对应类的全部 public 方法
        Method[] mtds = clazz.getMethods();
        System.out.println("ClassTest 的全部 public 方法如下： ");
        for (Method md : mtds) {
            System.out.println(md);
        }

        // 获取 clazz 对象所对应类的指定方法
        System.out.println("ClassTest 里带一个字符串参数的 info 方法为:" + clazz.getMethod("info", String.class));

        // 获取 clazz 对象所对应类的全部注解
        Annotation[] anns = clazz.getAnnotations();
        System.out.println("ClassTest 的全部 Annotation 如下： ");
        for (Annotation an : anns) {
            System.out.println(an);
        }

        // 获取 clazz 对象所对应类的全部内部类
        Class<?>[] inners = clazz.getDeclaredClasses();
        System.out.println("ClassTest 的全部内部类如下： ");
        for (Class c : inners) {
            System.out.println(c);
        }

        // 使用 Class.forName() 方法加载 ClassTest 的 Inner 内部类
        Class inClazz = Class.forName("ClassTest$Inner");

        // 访问该类所在的外部类
        System.out.println("inClazz 对应类的外部类为: " + inClazz.getDeclaringClass());

        System.out.println("ClassTest 的包为：" + clazz.getPackage());
        System.out.println("ClassTest 的父类为：" + clazz.getSuperclass());

    }
}

应用

Class 对象可以获得对应类的方法（由 Method 表示）、构造器（由 Constructor 表示）、成员变量（由 Field 对象表示），且这个三个类都实现了 java.lang.reflect.Member 接口。程序可以通过 Method 对象来执行对应的方法，通过 Constructor 对象来调用对应的构造器创建实例，通过 Field 对象直接访问并修改对象的成员变量值。

创建对象

• 使用 Class 对象的 newInstance() 方法来创建 Class 对象对应类的实例。要求该 Class 对象的对应类有默认构造器

• 先使用 Class 对象获取指定的 Constructor 对象，再调用 Constructor 对象的 newInstance() 方法来创建该 Class 对象对应类的实例。这种方式可以选择使用指定的构造器来创建实例

方式一

实现了一个简单的对象池，该对象池会根据配置文件读取 key-value 对，然后创建这些对象并放入 HashMap 中

import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class ObjectPoolFactory {
    private Map<String, Object> objectPool = new HashMap<>();

    private Object createObject(String clazzName) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        Class<?> clazz = Class.forName(clazzName);
        // 使用 Class 对象对应的类的默认构造器
        return clazz.newInstance();
    }

    public void initPool(String fileName) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        try (
                FileInputStream fis = new FileInputStream(fileName)
        ) {
            Properties props = new Properties();
            props.load(fis);
            for ( String name: props.stringPropertyNames()) {
                objectPool.put(name, createObject(props.getProperty(name)));
            }
        } catch (IOException ex) {
            System.out.println("读取" + fileName + "异常");
        }
    }

    public Object getObject(String name) {
        return objectPool.get(name);
    }

    public static void main(String[] args) throws Exception{
        ObjectPoolFactory pf = new ObjectPoolFactory();
        pf.initPool("obj.txt");
        System.out.println(pf.getObject("a"));
        System.out.println(pf.getObject("b"));
    }
}
/*
obj.txt 内容：

a=java.util.Date
b=javax.swing.JFrame
*/

方式二

import java.lang.reflect.Constructor;

public class CreateJFrame {
    public static void main(String[] args) throws Exception {
        Class<?> jframeClazz = Class.forName("javax.swing.JFrame");
        // 选择使用指定的构造器
        Constructor ctor = jframeClazz.getConstructor(String.class);
        Object obj = ctor.newInstance("测试窗口");
        System.out.println(obj);
    }
}

调用方法

每个 Method 对象对应一个方法，获得 Method 对象后，就可以通过该 Method 来调用它对应的方法。

Method 包含一个 invoke() 方法，该方法的签名如下：

• Object invoke(Object obj, Object... args)：该方法中的 obj 是执行方法的主调（即类的实例对象），后面的 args 是执行该方法的实参

下面是对之前的对象工厂池进行增强，允许在配置文件中增加配置对象的成员变量值，对象池工厂会读取该对象配置的成员变量值，并利用该对象对应的 setter 方法设置成员变量的值：

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class ExtendedObjectPoolFactory {
    // 定义一个对象池，前面是对象名，后面是实际的对象
    private Map<String, Object> objectPool = new HashMap<>();
    private Properties config = new Properties();
    // 从指定文件中初始化 Properties 对象
    public void init(String fileName) {
        try (
                FileInputStream fis = new FileInputStream(fileName);
        ) {
            config.load(fis);
        } catch (IOException ex) {
            System.out.println("读取" + fileName + "异常");
        }
    }
    // 定义创建对象的方法
    private Object createObject(String clazzName) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        // 根据字符串来获取对应的 Class 对象
        Class<?> clazz = Class.forName(clazzName);
        // 使用 clazz 对应类的默认构造器创建实例
        return clazz.newInstance();
    }

    // 初始化对象池
    public void initPool() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        for (String name : config.stringPropertyNames()) {
            if (!name.contains("%")) {
                objectPool.put(name, createObject(config.getProperty(name)));
            }
        }
    }

    // 根据属性文件来调用指定对象的 setter 方法
    public void initProperty() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        for (String name : config.stringPropertyNames()) {
            if (name.contains("%")) {
                String[] objAndProp = name.split("%");
                Object target = getObject(objAndProp[0]);
                String mtdName = "set" + objAndProp[1].substring(1);
                // 通过 target 的 getClass() 获取它的实现类所对应的 Class 对象
                Class<?> targetClass = target.getClass();
                // 获取希望调用的 setter 方法
                Method mtd = targetClass.getMethod(mtdName, String.class);
                // 通过 Method 的 invoke 方法执行 setter 方法
                mtd.invoke(target, config.getProperty(name));
            }
        }
    }

    public Object getObject(String name) {
        // 从 objectPool 中取出指定 name 对应的对象
        return objectPool.get(name);
    }

    public static void main(String[] args) throws Exception {
        ExtendedObjectPoolFactory epf = new ExtendedObjectPoolFactory();
        epf.init("extObj.txt");
        epf.initPool();
        epf.initProperty();
        System.out.println(epf.getObject("a"));
    }
}

/* extObj.txt 内容

a=java.util.Date
b=javax.swing.JFrame
# set the title of a
a%title=Test Title
*/

PS：当通过 Method 的 invoke() 方法来调用对应的方法时，Java 会要求程序必须有调用该方法的权限。如果需要调用某个对象的 private 方法，则可以先调用 Method 对象的如下方法：

• setAccessible(boolean flag)：值为 true，表示该 Method 在使用时取消访问权限检查

访问成员变量值

Filed 提供如下两组方法来读取或设置成员变量值：

• getXxx(Object obj)：获取 obj 对象的该成员变量的值。此处的 Xxx 对应 8 中基本类型。如果成员变量的类型是引用类型，则直接使用 get

• setXxx(Object obj, Xxx val)：将 obj 对象的成员变量值设为 val 值。此处的 Xxx 对应 8 中基本类型。如果成员变量的类型是引用类型，则直接使用 set

public class Person {
    private String name;
    private int age;

    public String toString() {
        return "Person[name:" + name + ", age:" + age + "]";
    }
}

import java.lang.reflect.Field;

public class FieldTest {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        Class<Person> personClazz = Person.class;
        Field nameField = personClazz.getDeclaredField("name");
        nameField.setAccessible(true);
        nameField.set(p, "crazy");
        Field ageField = personClazz.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.setInt(p, 30);
        System.out.println(p);
    }
}

泛型在反射中的应用

在反射中使用泛型，反射生成的对象就不需要进行强制类型转换。

import java.util.Date;

public class CrazyitObjectFactory {
    public static <T> T getinstance(Class<T> cls) {
        try {
            return cls.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        // 获取实例后无需进行类型转换
        Date d = CrazyitObjectFactory.getinstance(Date.class);
    }
}

欢迎关注我的公众号