反射（Reflection）是程序的自我分析能力，通过反射可以确定类有哪些方法、有哪些构造方法以及有哪些成员变量。Java语言提供了反射机制，通过反射机制能够动态读取一个类的信息；能够在运行时动态加载类，而不是在编译期。反射可以应用于框架开发，它能够从配置文件中读取配置信息动态加载类、创建对象，以及调用方法和成员变量。
Java反射机制API
Java反射机制API主要是 java.lang.Class 类和 java.lang.reflect 包。
java.lang.Class类
java.lang.Class类是实现反射的关键所在，Class类的一个实例表示Java的一种数据类型，包括类、接口、枚举、注解（Annotation）、数组、基本数据类型和void，void是“无类型”，主要用于方法返回值类型声明，表示不需要返回值。Class没有公有的构造方法，Class实例是由JVM在类加载时自动创建的。
方法1：调用Object类的getClass()方法。
方法2：使用Class类的forName()方法。
方法3：如果T是一个Java类型，那么T.class就代表了与该类型匹配的Class对象。
public static void main( String[] args ) throws ClassNotFoundException { // 1.通过类型class静态变量 Class clazz; clazz = int.class; print(clazz); String[] array = new String[1]; // 2.通过对象的getClass()方法 clazz = array.getClass(); print(clazz); clazz = Class.forName("java.lang.Override"); print(clazz); } private static void print(Class clazz) { System.out.println("ClassName = " + clazz.getName()); System.out.println("isAnnotation = " + clazz.isAnnotation()); System.out.println("isArray = " + clazz.isArray()); System.out.println("isPrimitive = " + clazz.isPrimitive()); System.out.println("isEnum = " + clazz.isEnum()); System.out.println("isInterface = " + clazz.isInterface()); System.out.println("---------------------"); }
每一种类型包括类和接口等，都有一个class静态变量可以获得Class实例。另外，每一个对象都有getClass()方法可以获得Class实例，该方法是由Object类提供的实例方法。
是否为接口: isInterface()
是否为数组对象: isArray()
是否是基本类型: isPrimitive()
获得父类: class: getSuperclass()
java.lang.reflect包
java.lang.reflect包提供了反射中用到类，主要的类说明如下：
- Constructor类：提供类的构造方法信息。
- Field类：提供类或接口中成员变量信息。
- Method类：提供类或接口成员方法信息。
- Array类：提供了动态创建和访问Java数组的方法。
- Modifier类：提供类和成员访问修饰符信息。
示例代码如下：
public static void main(String[] args) { try { // 动态加载xx类的运行时对象 Class c = Class.forName("java.lang.String"); // 获取成员方法集合 Method[] methods = c.getDeclaredMethods(); // 遍历成员方法集合 for (Method method : methods) { // 打印权限修饰符，如public、protected、private System.out.print(Modifier.toString(method.getModifiers())); // 打印返回值类型名称 System.out.print(" " + method.getReturnType().getName() + " "); // 打印方法名称 System.out.println(method.getName() + "();"); } } catch (ClassNotFoundException e) { System.out.println("找不到指定类"); } }
- 通过Class的静态方法forName(String)创建某个类的运行时对象，其中的参数是类全名字符串，如果在类路径中找不到这个类则抛出ClassNotFoundException异常。
- 通过Class的实例方法getDeclaredMethods()返回某个类的成员方法对象数组。
- method.getModifiers()方法返回访问权限修饰符常量代码，是int类型，例如1代表public，这些数字代表的含义可以通过Modifier.toString(int)方法转换为字符串。
- 通过Method的getReturnType()方法获得方法返回值类型，然后再调用getName()方法返回该类型的名称。
- method.getName()返回方法名称。
创建对象
反射机制提供了另外一种创建对象方法，Class类提供了一个实例方法newInstance()，通过该方法可以创建对象。
下面两条语句实现了创建字符串String对象。
Class clz = Class.forName("java.lang.String"); String str = (String) clz.newInstance();
这两条语句相当于String str = new String()语句。另外，需要注意newInstance()方法有可以会抛出
- InstantiationException表示不能实例化异常
- IllegalAccessException是不能访问构造方法异常。
调用构造方法
调用方法newInstance()创建对象，这个过程中需要调用构造方法，上面的代码只是调用了String的默认构造方法。如果想要调用非默认构造方法，需要使用Constructor对象，它对应着一个构造方法，获得Constructor对象需要使用Class类的如下方法：
- Constructor[] getConstructors()：返回所有公有构造方法Constructor对象数组。
- Constructor[] getDeclaredConstructors()：返回所有构造方法Constructor对象数组。
- Constructor getConstructor(Class... parameterTypes)：根据参数列表返回一个公有Constructor对象。参数parameterTypes是Class数组，指定构造方法的参数列表。
- Constructor getDeclaredConstructor(Class... parameterTypes)：根据参数列表返回一个Constructor对象。参数parameterTypes同上。
private static void printConstructor() throws Exception { Class clazz = String.class; System.out.println(clazz.newInstance()); Class<?> [] parameterTypes = {String.class}; final Constructor constructor = clazz.getConstructor(parameterTypes); Object[] initArgs = {"666"}; String str = (String) constructor.newInstance(initArgs); System.out.println(str); }
Java反射机制能够在运行时动态加载类，而不是在编译期。在一些框架开发中经常将要实例化的类名保存到配置文件中，在运行时从配置文件中读取类名字符串，然后动态创建对象，建立依赖关系。采用new创建对象依赖关系是在编译期建立的，反射机制能够将依赖关系推迟到运行时建立，这种依赖关系动态注入进来称为依赖注入。
调用方法
通过反射机制还可以调用方法，这与调用构造方法类似。调用方法需要使用Method对象，它对应着一个方法，获得Method对象需要使用Class类的如下方法：
- Method[] getMethods()：返回所有公有方法Method对象数组。
- Method[] getDeclaredMethods()：返回所有方法Method对象数组。
- Method getMethod(String name, Class... parameterTypes)：通过方法名和参数类型返回公有方法Method对象。参数parameterTypes是Class数组，指定方法的参数列表。
- Method getDeclaredMethod(String name, Class... parameterTypes)：通过方法名和参数类型返回方法Method对象。参数parameterTypes同上。
private static void testMethods() throws Exception { // 正常实现 final LocalDate now = LocalDate.now(); System.out.println(now); final LocalDate date = LocalDate.of(2020, 1, 2); System.out.println(date); System.out.println(date.getYear()); // 使用 method 方式 final Class<LocalDate> clazz = LocalDate.class; // 调用静态方法 Object obj = clazz.getMethod("now").invoke(null); LocalDate localDate = (LocalDate) obj; System.out.println(obj); // 调用静态方法的有参方法 Class<?> [] parameterTypes = {int.class, int.class, int.class}; Object[] args = {2002, 1, 2}; obj = clazz.getMethod("of", parameterTypes).invoke(null, args); System.out.println(obj); // 调用实例的无参方法 obj = clazz.getMethod("getYear").invoke(localDate); System.out.println(obj); }
调用成员变量
通过反射机制还可以调用成员变量，调用方法需要使用Field对象，它对应着一个方法，获得Field对象需要使用Class类的如下方法：
- Field[] getFields()：返回所有公有成员变量Field对象数组。
- Field[] getDeclaredFields()：返回所有成员变量Field对象数组。
- Field getField(String name)：通过指定公共成员变量名返回Field对象。
- Field getDeclaredField(String name)：通过指定成员变量名返回Field对象。
private static void testFiled() throws Exception { // 已知 Exception 有一个成员变量 private String detailMessage; Throwable exception = new Throwable("hello"); System.out.println(exception.getMessage()); final Class<? extends Throwable> aClass = exception.getClass(); // 获取非静态方法的字段 final Field detailMessageField = aClass.getDeclaredField("detailMessage"); detailMessageField.setAccessible(true); // 非静态的 get final Object obj = detailMessageField.get(exception); System.out.println(obj); // 非静态的 set detailMessageField.set(exception, "new value"); System.out.println(exception.getMessage()); // 获取静态字段的值 // private static final long serialVersionUID = -3042686055658047285L; final Field serialVersionUIDField = aClass.getDeclaredField("serialVersionUID"); serialVersionUIDField.setAccessible(true); System.out.println(serialVersionUIDField.get(null)); }
输出
hello hello new value -3042686055658047285
设置成员变量accessible标志为true，accessible是可访问性标志，值为 true 则指示反射的对象在使用时应该取消Java语言访问检查。值为false则指示反射的对象应该实施Java语言访问检查。不仅是成员变量，方法和构造方法也可以通过setAccessible(true)设置，实现对私有方法和构造方法的访问。
拓展
1.Type[] java.lang.Class.getGenericInterfaces()
2.Class<?>[] java.lang.Class.getInterfaces()
- 获取类的接口实现信息
1.返回实现接口信息的Type数组，包含泛型信息
2.返回实现接口信息的Class数组，不包含泛型信息
细看一下，就会发现其中端倪，当你的实现接口中不包含泛型时，同样调用1方法，其返回的接口信息必然不带泛型信息的，也就是1中包含2。
如何拿到接口中定义的泛型Person?
public static void main(String[] args) { Class clz = new MyInterface<Person>() { @Override public Person get() { return null; } }.getClass(); // 如何拿到接口中定义的泛型Person System.out.println(((ParameterizedType) clz.getGenericInterfaces()[0]).getActualTypeArguments()[0]); clz = new MyAbstractClass<Person>() { @Override public Person get() { return null; } }.getClass(); // 如何拿到抽象类中定义的泛型Person System.out.println(((ParameterizedType) clz.getGenericSuperclass()).getActualTypeArguments()[0]); } static interface MyInterface<T> { T get(); } static abstract class MyAbstractClass<T> { abstract T get(); }
内省技术
PropertyDescriptor类表示JavaBean类通过存储器导出一个属性。主要方法：
1、getPropertyType()，获得属性的Class对象。
2、getReadMethod()，获得用于读取属性值的方法；getWriteMethod()，获得用于写入属性值的方法。
3、hashCode()，获取对象的哈希值。
4、setReadMethod(Method readMethod)，设置用于读取属性值的方法；
setWriteMethod(Method writeMethod)，设置用于写入属性值的方法；
将JavaBean中的属性封装起来进行操作。在程序把一个类当做JavaBean来看，就是调用Introspector.getBeanInfo()方法，得到的BeanInfo对象封装了把这个类当做JavaBean看的结果信息，即属性的信息。需要导包java.beans.*。
private static void testPropertyDescriptor() throws Exception { // 使用内省 final Class<App> appClass = App.class; App app = appClass.newInstance(); PropertyDescriptor propertyDescriptor = new PropertyDescriptor("sss", appClass); Method writeMethod = propertyDescriptor.getWriteMethod(); writeMethod.invoke(app, "11111"); System.out.println(propertyDescriptor.getReadMethod().invoke(app)); BeanInfo beanInfo = Introspector.getBeanInfo(appClass); PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors(); for (PropertyDescriptor pd : pds) { System.out.println(pd); } }
