首先，来了解下类的加载过程：
类加载的完整过程如下：
- 在编译时，Java 编译器编译好
.java文件之后，在磁盘中产生.class文件。.class文件是二进制文件，内容是只有 JVM 能够识别的机器码。 - JVM 中的类加载器读取字节码文件，取出二进制数据，加载到内存中，解析.class 文件内的信息。类加载器会根据类的全限定名来获取此类的二进制字节流；然后，将字节流所代表的静态存储结构转化为方法区的运行时数据结构；接着，在内存中生成代表这个类的
java.lang.Class对象。 - 加载结束后，JVM 开始进行连接阶段（包含验证、准备、初始化）。经过这一系列操作，类的变量会被初始化。
一、反射的介绍
Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。
要想解剖一个类，必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法。所以先要获取到每一个字节码文件对应的Class类型的对象.。
二、反射的「反」
反射之中包含了一个「反」字，所以想要解释反射就必须先从「正」开始解释。
一般情况下，我们使用某个类时必定知道它是什么类，是用来做什么的。于是我们直接对这个类进行实例化，之后使用这个类对象进行操作。
如：
Phone phone = new Phone(); //直接初始化，「正射」 phone.setPrice(4);
上面这样子进行类对象的初始化，我们可以理解为「正」。
而反射则是一开始并不知道我要初始化的类对象是什么，自然也无法使用 new 关键字来创建对象了。
这时候，我们使用 JDK 提供的反射 API 进行反射调用：
Class clz = Class.forName("com.xxp.reflect.Phone");
Method method = clz.getMethod("setPrice", int.class);
Constructor constructor = clz.getConstructor();
Object object = constructor.newInstance();
method.invoke(object, 4);
上面两段代码的执行结果，其实是完全一样的。但是其思路完全不一样，第一段代码在未运行时就已经确定了要运行的类（Phone），而第二段代码则是在运行时通过字符串值才得知要运行的类（com.xxp.reflect.Phone）。
所以说什么是反射？反射就是在运行时才知道要操作的类是什么，并且可以在运行时获取类的完整构造，并调用对应的方法。
上面提到的示例程序，其完整的程序代码如下：
public class Phone { private int price; public int getPrice() { return price; } public void setPrice(int price) { this.price = price; } public static void main(String[] args) throws Exception{ //正常的调用 Phone phone = new Phone(); phone.setPrice(5000); System.out.println("Phone Price:" + phone.getPrice()); //使用反射调用 Class clz = Class.forName("com.xxp.api.Phone"); Method setPriceMethod = clz.getMethod("setPrice", int.class); Constructor phoneConstructor = clz.getConstructor(); Object phoneObj = phoneConstructor.newInstance(); setPriceMethod.invoke(phoneObj, 6000); Method getPriceMethod = clz.getMethod("getPrice"); System.out.println("Phone Price:" + getPriceMethod.invoke(phoneObj)); } }
从这个简单的例子可以看出，一般情况下我们使用反射获取一个对象的步骤：
//获取类的 Class 对象实例 Class clz = Class.forName("com.xxp.api.Phone"); //根据 Class 对象实例获取 Constructor 对象 Constructor phoneConstructor = clz.getConstructor(); //使用 Constructor 对象的 newInstance 方法获取反射类对象 Object phoneObj = phoneConstructor.newInstance();
而如果要调用某一个方法，则需要经过下面的步骤：
//获取方法的 Method 对象 Method setPriceMethod = clz.getMethod("setPrice", int.class); //利用 invoke 方法调用方法 setPriceMethod.invoke(phoneObj, 6000);
到这里，我们已经能够掌握反射的基本使用。但如果要进一步掌握反射，还需要对反射的常用 API 有更深入的理解。
三、反射的API
与Java反射相关的类如下：
① Class： 代表类的实体，在运行的Java应用程序中表示类和接口。(1) 获得类相关方法
| 方法 | 用途 |
| asSubclass(Class<U> clazz) | 把传递的类的对象转换成代表其子类的对象 |
| Cast | 把对象转换成代表类或是接口的对象 |
| getClassLoader() | 获得类的加载器 |
| getClasses() | 返回一个数组，数组中包含该类中所有公共类和接口类的对象 |
| getDeclaredClasses() | 返回一个数组，数组中包含该类中所有类和接口类的对象 |
| forName(String className) | 根据类名返回类的对象 |
| getName() | 获得类的完整路径名字 |
| newInstance() | 创建类的实例 |
| getPackage() | 获得类的包 |
| getSimpleName() | 获得类的名字 |
| getSuperclass() | 获得当前类继承的父类的名字 |
| getInterfaces() | 获得当前类实现的类或是接口 |
(2) 获得类中属性相关的方法
| 方法 | 用途 |
| getField(String name) | 获得某个公有的属性对象 |
| getFields() | 获得所有公有的属性对象 |
| getDeclaredField(String name) | 获得某个属性对象 |
| getDeclaredFields() | 获得所有属性对象 |
(3) 获得类中注解相关的方法
| 方法 | 用途 |
| getConstructor(Class...<?> parameterTypes) | 获得该类中与参数类型匹配的公有构造方法 |
| getConstructors() | 获得该类的所有公有构造方法 |
| getDeclaredConstructor(Class...<?> parameterTypes) | 获得该类中与参数类型匹配的构造方法 |
| getDeclaredConstructors() | 获得该类所有构造方法 |
(4) 类中其他重要的方法
| 方法 | 用途 |
| isAnnotation() | 如果是注解类型则返回true |
| isAnnotationPresent(Class<? extends Annotation> annotationClass) | 如果是指定类型注解类型则返回true |
| isAnonymousClass() | 如果是匿名类则返回true |
| isArray() | 如果是一个数组类则返回true |
| isEnum() | 如果是枚举类则返回true |
| isInstance(Object obj) | 如果obj是该类的实例则返回true |
| isInterface() | 如果是接口类则返回true |
| isLocalClass() | 如果是局部类则返回true |
| isMemberClass() | 如果是内部类则返回true |
| getAnnotation(Class<A> annotationClass) | 获取修饰类的指定注解 |
② Field：表类的成员变量（成员变量也称为类的属性）
| 方法 | 用途 |
| equals(Object obj) | 属性与obj相等则返回true |
| get(Object obj) | 获得obj中对应的属性值 |
| set(Object obj, Object value) | 设置obj中对应属性值 |
③ Method：代表类的方法
| 方法 | 用途 |
| invoke(Object obj, Object... args) | 传递object对象及参数调用该对象对应的方法 |
④ Constructor：代表类的构造方法
| 方法 | 用途 |
| newInstance(Object... initargs) | 根据传递的参数创建类的对象 |
1. 获得反射中的Class对象
在反射中，要获取一个类或调用一个类的方法，我们首先需要获取到该类的 Class 对象。
在 Java API 中，获取 Class 类对象有三种方法：
(1) 使用 Class.forName 静态方法。当知道某类的全路径名时，可以使用此方法获取 Class 类对象。用的最多，但可能抛出 ClassNotFoundException 异常。
Class c1 = Class.forName(“java.lang.String”);
(2) 直接通过 类名.class 的方式得到，该方法最为安全可靠，程序性能更高。这说明任何一个类都有一个隐含的静态成员变量 class。这种方法只适合在编译前就知道操作的 Class。
Class c2 = String.class;
(3) 通过对象调用 getClass() 方法来获取，通常应用在：比如你传过来一个 Object类型的对象，而我不知道你具体是什么类，用这种方法。
String str = new String("Hello"); Class c3 = str.getClass();
需要注意的是：一个类在 JVM 中只会有一个 Class 实例，即我们对上面获取的 c1、c2和c3进行 equals 比较，发现都是true。
2. 通过反射创建类对象
通过反射创建类对象主要有两种方式：通过 Class 对象的 newInstance() 方法、通过 Constructor 对象的 newInstance() 方法。
(1) 通过 Class 对象的 newInstance() 方法。
Class clz = Phone.class; Phone phone = (Phone)clz.newInstance();
(2) 通过 Constructor 对象的 newInstance() 方法
Class clz = Phone.class; Constructor constructor = clz.getConstructor(); Phone phone= (Phone)constructor.newInstance();
通过 Constructor 对象创建类对象可以选择特定构造方法，而通过 Class 对象则只能使用默认的无参数构造方法。下面的代码就调用了一个有参数的构造方法进行了类对象的初始化。
Class clz = Phone.class; Constructor constructor = clz.getConstructor(String.class, int.class); Phone phone = (Phone)constructor.newInstance("华为",6666);
3. 通过反射获取类属性、方法、构造器
我们通过 Class 对象的 getFields() 方法可以获取 Class 类的属性，但无法获取私有属性。
Class clz = Phone.class; Field[] fields = clz.getFields(); for (Field field : fields) { System.out.println(field.getName()); }
而如果使用 Class 对象的 getDeclaredFields() 方法则可以获取包括私有属性在内的所有属性：
Class clz = Phone.class; Field[] fields = clz.getDeclaredFields(); for (Field field : fields) { System.out.println(field.getName()); }
与获取类属性一样，当我们去获取类方法、类构造器时，如果要获取私有方法或私有构造器，则必须使用有 declared 关键字的方法。
四、反射源码讨论
当我们懂得了如何使用反射后，今天我们就来看看 JDK 源码中是如何实现反射的。或许大家平时没有使用过反射，但是在开发 Web 项目的时候会遇到过下面的异常：
java.lang.NullPointerException ... sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:369)
可以看到异常堆栈指出了异常在 Method 的第 369 的 invoke 方法中，其实这里指的 invoke 方法就是我们反射调用方法中的 invoke。
Method method = clz.getMethod("setPrice", int.class);
method.invoke(object, 6); //就是这里的invoke方法
例如我们经常使用的 Spring 配置中，经常会有相关 Bean 的配置
<bean class="com.xxp.Phone">
</bean>
五、反射框架-Reflections
Reflections通过扫描classpath，索引元数据，并且允许在运行时查询这些元数据。
使用Reflections可以很轻松的获取以下元数据信息：
- 获取某个类型的全部子类
- 只要类型、构造器、方法，字段上带有特定注解，便能获取带有这个注解的全部信息（类型、构造器、方法，字段）
- 获取所有能匹配某个正则表达式的资源
- 获取所有带有特定签名的方法，包括参数，参数注解，返回类型
- 获取所有方法的名字
- 获取代码里所有字段、方法名、构造器的使用
1. 添加依赖
因Reflections框架依赖com.google.guava，所以也需导入。
<dependency> <groupId>org.reflections</groupId> <artifactId>reflections</artifactId> <version>0.9.11</version> </dependency>
2. 常用API使用
// 实例化Reflections，并指定要扫描的包名 Reflections reflections = new Reflections("my.project"); // 获取某个类的所有子类 Set<Class<? extends SomeType>> subTypes = reflections.getSubTypesOf(SomeType.class); // 获取包含某个注解的所有类 Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(SomeAnnotation.class);
(1) 创建Reflections
//scan urls that contain 'my.package', include inputs starting with 'my.package', use the default scanners Reflections reflections = new Reflections("my.package"); //or using ConfigurationBuilder Reflections reflections = new Reflections(new ConfigurationBuilder() .forPackages("com.boothsun.reflections") // 指定路径URL .addScanners(new SubTypesScanner()) // 添加子类扫描工具 .addScanners(new FieldAnnotationsScanner()) // 添加 属性注解扫描工具 .addScanners(new MethodAnnotationsScanner() ) // 添加 方法注解扫描工具 .addScanners(new MethodParameterScanner() ) // 添加方法参数扫描工具 );
(2) 扫描子类
Set<Class<? extends Module>> modules = reflections.getSubTypesOf(com.google.inject.Module.class);
(3) 扫描注解
//TypeAnnotationsScanner Set<Class<?>> singletons = reflections.getTypesAnnotatedWith(javax.inject.Singleton.class);
(4) 扫描资源
//ResourcesScanner Set<String> properties = reflections.getResources(Pattern.compile(".*\.properties"));
(5) 扫描方法注解
//MethodAnnotationsScanner Set<Method> resources = reflections.getMethodsAnnotatedWith(javax.ws.rs.Path.class); Set<Constructor> injectables = reflections.getConstructorsAnnotatedWith(javax.inject.Inject.class);
(6) 扫描字段注解
//FieldAnnotationsScanner Set<Field> ids = reflections.getFieldsAnnotatedWith(javax.persistence.Id.class);
(7) 扫描方法参数
//MethodParameterScanner Set<Method> someMethods = reflections.getMethodsMatchParams(long.class, int.class); Set<Method> voidMethods = reflections.getMethodsReturn(void.class); Set<Method> pathParamMethods = reflections.getMethodsWithAnyParamAnnotated(PathParam.class);
(8) 扫描方法参数名
//MethodParameterNamesScanner List<String> parameterNames = reflections.getMethodParamNames(Method.class)
(9) 扫描方法调用情况
//MemberUsageScanner Set<Member> usages = reflections.getMethodUsages(Method.class)
六、反射应用场景
- 开发通用框架 - 反射最重要的用途就是开发各种通用框架。很多框架（比如 Spring）都是配置化的（比如通过 XML 文件配置 JavaBean、Filter 等），为了保证框架的通用性，它们可能需要根据配置文件加载不同的对象或类，调用不同的方法，这个时候就必须用到反射——运行时动态加载需要加载的对象。
- 动态代理 - 在切面编程（AOP）中，需要拦截特定的方法，通常，会选择动态代理方式。这时，就需要反射技术来实现了。
- 注解 - 注解本身仅仅是起到标记作用，它需要利用反射机制，根据注解标记去调用注解解释器，执行行为。如果没有反射机制，注解并不比注释更有用。
- 可扩展性功能 - 应用程序可以通过使用完全限定名称创建可扩展性对象实例来使用外部的用户定义类。
七、反射的缺点
- 性能开销 - 由于反射涉及动态解析的类型，因此无法执行某些 Java 虚拟机优化。因此，反射操作的性能要比非反射操作的性能要差，应该在性能敏感的应用程序中频繁调用的代码段中避免。
- 破坏封装性 - 反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题。
- 内部曝光 - 由于反射允许代码执行在非反射代码中非法的操作，例如访问私有字段和方法，所以反射的使用可能会导致意想不到的副作用，这可能会导致代码功能失常并可能破坏可移植性。反射代码打破了抽象，因此可能会随着平台的升级而改变行为。
八、new对象和反射得到对象的区别
- 在使用反射的时候，必须确保这个类已经加载并已经连接了。使用new的时候，这个类可以没有被加载，也可以已经被加载。
- new关键字可以调用任何public构造方法，而反射只能调用无参构造方法。
- new关键字是强类型的，效率相对较高。 反射是弱类型的，效率低。
- 反射提供了一种更加灵活的方式创建对象，得到对象的信息。如Spring 中AOP等的使用，动态代理的使用，都是基于反射的。解耦。
九、总结
