本文目录一览：
原来高手是这么回答和使用反射的，又觉得涨了不少知识
反射是Java语言中非常重要的一个基础知识点，它的应用往往在于代码的封装上和框架的设计上，对于一般的码农和初级工程师来说，在日常的编码工作中很少直接使用反射，所以不少Java小伙伴对反射是既熟悉又陌生。
熟悉是都听说过，听说是一个很牛掰的技术，是封装框架，走向架构的必修课，陌生在于日常开发很少直接使用，反正不影响哥们施展CV大法。
如果企业没有编程规范要求和来自领导的review，优化程序是不可能的，重构，向上封装？想都不要想。如果想要让自己的编程功力提高，提升自己的架构思维，那么在日常编码过程中，一定要多去思考，我的代码能否再精简？能否再通用？能否变成一个团队插件？想要实现这个目的，反射就可能派上用场了。
本文会从以下几点为小伙伴解密反射，保障看完神清气爽，直呼哇塞：
反射的概念和相关API反射语法，如何获取和操作反射类，构造器，方法，属性反射的应用场景，从框架和个人项目经验分享面试中高手都怎么回答反射的优缺点拿到高薪什么是反射Reflection(反射)是Java程序开发语言的重要特性之一，通过反射机制允许在程序运行期间，可以根据任意一个.class【字节码文件】文件获取到这个类的所有信息，包括（成员变量，成员方法，构造器等），并可以通过相应的方式操纵类的字段、方法、构造器
基于反射机制，Java实现在程序运行期间，动态获取信息和动态调用对象的方法，提高了程序的扩展性
使用反射的前提是必须有字节码文件，也就是.class文件，.class文件就是通过.java文件编译而来的。Java作为面向对象的编程语言，提供了为反射准备的字节码文件对象javang.Class<T>
反射相关API反射机制相关的包都在
javang.reflect.*;
一些反射中的常用类：
类 | 作用 |
javang.Class | 代表整个字节码。代表一个类型，代表整个类 |
javang.reflect.Method | 代表字节码中的方法字节码。代表类中的方法 |
javang.reflect.Constructor | 代表字节码中的构造方法字节码。代表类中的构造方法 |
javang.reflect.Field | 代表字节码中的属性字节码。代表类中的成员变量（静态变量+实例变量） |
还可以通过字节码对象【Class对象】获取注解以下信息，这些信息不在javang.reflect包中，所以单独列出来
类 | 作用 |
javang.annotation.Annotation | 可以获取类，字段，方法等地方的注解 |
javang.Package | 获取所在包 |
javang.ClassLoader | 获取类加载器 |
反射是将运行中的class文件读取到并封装进反射类【Class<T>】中，并且可以根据反射类获取类中的构造方法，普通方法和属性，接下来根据案例依次演示
获取反射类咱们写的代码是存储在后缀名是 .java的文件里的，但是它会被编译，最终真正去执行的是编译后的 .class文件。Java是面向对象的语言，一切皆对象，所以java认为这些编译后的 class文件也是一种对象，给抽象成了一种类，这个类就是Class，获取反射类有三种方式：
通过Object类的 getClass方法来获取，所有的类都直接或者间接继承Object类，所有的对象都可以使用该方法使用 类名.class 的方式使用Class.forName方法需求：有以下Student类，我们通过三种方式获取该类的Class对象，并根据Class对象的getName方法，输出类的全路径
student类：
package com.stt.reflect;public class Student { private Long id; private String name; private String ; private Integer age;}
获取反射类：
public class StudentMain { public static void main(String[] args) { // 1、通过 getClass 方法获取 Class类， // 1) 创建Student类对象 Student student = new Student(); // 2) 所有的类都直接或者间接继承Object类，每个对象都有getClass方法 Class studentClazz1 = student.getClass(); System.out.println("studentClazz1===>" + studentClazz1.getName()); // 2、通过.class获取 Class studentClazz2 = Student.class; System.out.println("studentClazz2===>" + studentClazz2.getName()); // 3、通过Class类的forName方法获取，传入类的全路径 try { // 此方法抛出 ClassNotFoundException 异常，因为填写的类全路径可能错误，该类可能不存在 Class studentClazz3 = Class.forName("com.stt.reflect.Student"); System.out.println("studentClazz3===>" + studentClazz3.getName()); } catch (ClassNotFoundException e) { throw new RuntimeException(e); } }}
输出结果：
反射获取构造方法方法 | 作用 |
Constructor<T> getConstructor(Class<?>... parameterTypes) | 根据参数列表，获取指定数据类型的构造方法，抛出 NoSuchMethodException, SecurityException |
Constructor<?>[] getConstructors() | 获取所有的构造方法，抛出 SecurityException |
改造Student类，增加四个构造方法，默认有一个无参的构造方法
package com.stt.reflect;public class Student { private Long id; private String name; private String ; private Integer age; // 无参构造 public Student() { System.out.println("=======无参构造方法======="); } // 单参构造 public Student(String name) { this = name; System.out.println("=======单参构造方法=======name：" + name); } // 两参构造 public Student(Long id, String name) { this.id = id; this = name; System.out.println("========两参构造方法=======id：" + id + ", name: " + name); } // 三参构造 public Student(Long id, String name, String ) { this.id = id; this = name; this = ; System.out.println("========三参构造方法=======id：" + id + ", name: " + name + ", : " +); } // 四参构造 public Student(Long id, String name, String , Integer age) { this.id = id; this = name; this = ; this.age = age; System.out.println("========三参构造方法=======id：" + id + ", name: " + name + ", : " + + ", age: " +age); }}获取指定参数构造方法根据getConstructor()方法获取构造方法通过 Constructor 类的 newInstance()方法可以调用对应的构造方法创建对象
package com.stt.reflect;import javang.reflect.Constructor;public class StudentMain { public static void main(String[] args) throws Exception { // 1、获取Class类，这里将异常向上抛出 Class clazz = Class.forName("com.stt.reflect.Student"); // 2、获取无参的构造方法 Constructor<Student> noParamConstructor = clazz.getConstructor(); // 通过Constructor创建对象 Student student1 = noParamConstructor.newInstance(); // 3、获取单灿构造方法，单参是String类型的name，所以参数写为String.class Constructor<Student> oneStringParamConstructor = clazz.getConstructor(String.class); Student student2 = oneStringParamConstructor.newInstance("添甄"); // 4、获取两参构造方法，类型分别为Long和String Constructor<Student> twoStringParamConstructor = clazz.getConstructor(Long.class,String.class); Student student3 = twoStringParamConstructor.newInstance(1L,"添甄"); }}
运行结果：
获取所有构造方法将无参的构造方法设置为私有
private Student() { System.out.println("=======无参构造方法=======");}
获取所有构造方法：
package com.stt.reflect;import javang.reflect.Constructor;public class StudentMain { public static void main(String[] args) throws Exception { // 1、获取Class类，这里将异常向上抛出 Class clazz = Class.forName("com.stt.reflect.Student"); // 2、获取所有构造方法 Constructor<Student>[] constructors = clazz.getConstructors(); // 3、遍历构造方法 for (Constructor<Student> constructor : constructors) { System.out.println(constructor); } }}
输出结果：
可以获取所有的公开构造方法，私有构造获取不到
获取私有构造小贴士：通过反射获取私有的构造函数时，用普通的getConstructor()会报错，因为它是私有的，所以提供了专门反射私有构造函数的方法 getDeclaredConstructor(int.class);
如果要调用这个方法还需要设置一下暴力反射才可以，即调用构造器对象的setAccessible(true);方法
获取所有私有方法:
package com.stt.reflect;import javang.reflect.Constructor;public class StudentMain { public static void main(String[] args) throws Exception { // 1、获取Class类，这里将异常向上抛出 Class clazz = Class.forName("com.stt.reflect.Student"); // 2、获取所有构造方法，包括私有 Constructor<Student>[] constructors = clazz.getDeclaredConstructors(); // 3、遍历构造方法 for (Constructor<Student> constructor : constructors) { System.out.println(constructor); } }}
运行结果：
获取私有构造方法并调用仅仅获取到调用会出现 IllegalAccessException 异常
package com.stt.reflect;import javang.reflect.Constructor;public class StudentMain { public static void main(String[] args) throws Exception { // 1、获取Class类，这里将异常向上抛出 Class clazz = Class.forName("com.stt.reflect.Student"); // 2、获取无参的构造方法，包括私有 Constructor<Student> constructor = clazz.getDeclaredConstructor(); // 3、此时直接调用会报错 Student student = constructor.newInstance(); }}
报错：
设置暴力破解即可访问：也就是调用一下 setAccessible(true)方法
package com.stt.reflect;import javang.reflect.Constructor;public class StudentMain { public static void main(String[] args) throws Exception { // 1、获取Class类，这里将异常向上抛出 Class clazz = Class.forName("com.stt.reflect.Student"); // 2、获取无参的构造方法，包括私有 Constructor<Student> constructor = clazz.getDeclaredConstructor(); // 3、暴力破解，允许调用私有方法 constructor.setAccessible(true); // 4、此时直接调用会报错 Student student = constructor.newInstance(); }}
运行结果：
反射获取方法在Student类中添加以下普通方法
package com.stt.reflect;public class Student { // ...... public void speak() { System.out.println("你好啊！" + name); } public Integer getAge() { System.out.println("getAge===》" + this.age); return this.age; } public void setName(String name) { this = name; System.out.println("设置名字为：" + name); } public static void skill() { System.out.println("======skill静态方法======"); } private void method1() { System.out.println("======私有方法======"); } private static void method2(String[] args) { System.out.println("======私有静态方法======" + args); }}获取所有非私有方法
获取方法，通过 Method 类型对象封装
package com.stt.reflect;import javang.reflect.Constructor;import javang.reflect.Method;public class StudentMain { public static void main(String[] args) throws Exception { // 1、获取Class类，这里将异常向上抛出 Class clazz = Class.forName("com.stt.reflect.Student"); // 2、获取所有非私有方法，包括父类中方法 Method[] methods = clazz.getMethods(); for (Method method : methods) { System.out.println(method); } }}
如下图：获取到了所有的非私有方法，包括父类中的方法
获取所有方法通过调用getDeclaredMethods方法获取所有方法，
package com.stt.reflect;import javang.reflect.Constructor;import javang.reflect.Method;public class StudentMain { public static void main(String[] args) throws Exception { // 1、获取Class类，这里将异常向上抛出 Class clazz = Class.forName("com.stt.reflect.Student"); // 2、获取所有非私有方法，包括父类中方法 Method[] methods = clazz.getDeclaredMethods(); for (Method method : methods) { System.out.println(method); } }}
如下，获取了包括私有方法，但是不包括父类中的方法
获取指定方法并调用我们可以通过 getMethod(String name, Class<?>... parameterTypes) 方法，根据方法名和参数获取方法，在通过Method对象的 invoke(Object obj, Object... args)方法调用方法，如果是私有方法，你懂的，需要暴力破解一下再调用，和构造器一样
调用四个参数构造方法创建student对象分别调用speak，getAge和setName方法，分别对应无返回值和有返回值和有参数等情况package com.stt.reflect;import javang.reflect.Constructor;import javang.reflect.Method;public class StudentMain { public static void main(String[] args) throws Exception { // 1、获取Class类，这里将异常向上抛出 Class clazz = Class.forName("com.stt.reflect.Student"); // 2、获取无参的 speak 方法 Method speakMethod = clazz.getMethod("speak"); // 3、创建Student对象 Constructor<Student> constructor = clazz.getConstructor(Long.class,String.class,String.class,Integer.class); Student student = constructor.newInstance(1L,"添甄","男",26); // 传入 student,意为要调用student对象的speak Object returnResult = speakMethodvoke(student); System.out.println("方法返回值==》" + returnResult); // 4、调用getAge方法，没有参数有返回值 Method ageMethod = clazz.getMethod("getAge"); Integer returnAge = (Integer)ageMethodvoke(student); System.out.println(returnAge); // 5、调用有参数的方法，getMethod参数2写为参数的类型 Method setNameMethod = clazz.getMethod("setName",String.class); setNameMethodvoke(student, "王小波"); }}
调用私有方法方式和调用私有构造器一致，首先通过 getDeclaredMethod 获取私有方法，其次调用 setAccessible(true) 设置可访问为true
package com.stt.reflect;import javang.reflect.Constructor;import javang.reflect.Method;public class StudentMain { public static void main(String[] args) throws Exception { // 1、获取Class类，这里将异常向上抛出 Class clazz = Class.forName("com.stt.reflect.Student"); // 2、创建Student对象 Constructor<Student> constructor = clazz.getConstructor(Long.class,String.class,String.class,Integer.class); Student student = constructor.newInstance(1L,"添甄","男",26); // 3、通过 getDeclaredMethod 获取私有方法 private void method1() Method method1 = clazz.getDeclaredMethod("method1"); // 设置为可访问 true method1.setAccessible(true); // 调用方法 Object invoke = method1voke(student); }}参数为数组
参数维数组有点特殊，这是因为 jdk1.4和jdk1.5处理invoke方法有区别
1.5：public Object invoke(Object obj,Object…args)：1.5参数为Object类型的可变参数
1.4：public Object invoke(Object obj,Object[] args)：1.4参数为一个Object类型数组
在反射方法时，如果方法的参数是一个数组，考虑到向下兼容问题，会按照JDK1.4的语法来对待（JVM会把传递的数组参数拆开，拆开就会报参数的个数不匹配的错误） 解决办法：防止JVM拆开你的数组 方式一：把数组看做是一个Object对象 方式二：重新构建一个Object数组，那个参数数组作为唯一的元素存在。
package com.stt.reflect;import javang.reflect.Constructor;import javang.reflect.Method;public class StudentMain { public static void main(String[] args) throws Exception { // 1、获取Class类，这里将异常向上抛出 Class clazz = Class.forName("com.stt.reflect.Student"); // 2、创建Student对象 Constructor<Student> constructor = clazz.getConstructor(Long.class,String.class,String.class,Integer.class); Student student = constructor.newInstance(1L,"添甄","男",26); // 3、通过 getDeclaredMethod 获取私有方法 private void method1() Method method1 = clazz.getDeclaredMethod("method2",String[].class); // 设置为可访问 true method1.setAccessible(true); // 调用方式1：将数组强转为Object对象 method1voke(student,(Object)new String[]{"a","b"}); // 调用方式2：将数组存储进Object数组中 method1voke(student,new Object[]{new String[]{"a","b"}}); }}
错误调用：如果直接传进数组，则会出现IllegalArgumentException【非法参数异常】报错
Method method1 = clazz.getDeclaredMethod("method2",String[].class);// 设置为可访问 truemethod1.setAccessible(true);// 错误调用：直接传递数组method1voke(student,new String[]{"a","b"});
反射获取属性设置name属性为public
private Long id;public String name;private String ;private Integer age;
相关方法：
方法 | 作用 |
Field getField(String name) | 获取指定非私有属性 |
Field[] getFields() | 获取所有非私有属性 |
Field getDeclaredField(String name) | 获取指定私有属性 |
Field[] getDeclaredFields() | 获取所有私有属性 |
获取属性并通过get方法获取属性值
package com.stt.reflect;import javang.reflect.Constructor;import javang.reflect.Field;import javang.reflect.Method;public class StudentMain { public static void main(String[] args) throws Exception { // 1、获取Class类，这里将异常向上抛出 Class clazz = Class.forName("com.stt.reflect.Student"); // 2、创建Student对象 Constructor<Student> constructor = clazz.getConstructor(Long.class,String.class,String.class,Integer.class); Student student = constructor.newInstance(1L,"添甄","男",26); // 3、获取name属性 Field nameField = clazz.getField("name"); // 4、获取所有费私有属性 Field[] fields = clazz.getFields(); for (Field field : fields) { System.out.println("field name====》" + field.getName()); System.out.println("字段值==》" + field.get(student)); } // 5、获取指定私有属性 Field Field = clazz.getDeclaredField(""); Field.setAccessible(true); System.out.println(Field.get(student)); }}
运行结果：
总结要使用反射首先通过上述三种方式获取Class对象，该对象有泛型可以根据相关get方法获取非私有的构造方法，普通方法和属性可以根据 相关getDeclaredXXX系列方法，获取私有的构造方法，普通方法和属性，如果是私有需要调用对应的 setAccessible(true)允许暴力访问进行操作调用方法和属性时，需要指定一个对象，即调用该对象的指定方法Class、Constructor、Method和Field的方法其实都比较简单，可以自己动手调用一下，印象会更深刻我们还可以根据获取Class、Method、Field、Constructor获取对应的注解，即 Annotation对象而且私有的方法和属性都可以被强制调用，反射破坏了封装性，带来一些安全隐患反射应用场景Tomcat加载文件使用Servlet编写web应用时，往往都有一个web.xml文件，
<!-- 配置方式一 --> <servlet> <servlet-name>my3</servlet-name> <servlet-class>com.servlet.MyServlet3</servlet-class></servlet> <servlet-mapping> <servlet-name>my3</servlet-name> <url-pattern>/my3</url-pattern></servlet-mapping>
该文件会交给Tomcat运行：
Tomcat服务器首先读取配置文件web.xml中配置好的Servlet的子类名称Tomcat根据读取到的客户端实现的Servlet子类的类名字符串去寻找对应的字节码文件，如果找到就将其加载到内存Tomcat通过预先设置好的Java反射处理机制解析字节码文件并创建相应的实例对象，之后调用所需要的方法Tomcat一启动，用户自定义的Servlet的子类通过Tomcat内部的反射框架也随之运行Spring框架的IOC就还比如spring框架的xml文件的bean配置，都是通过读取class属性值，通过反射创建对象
<bean class="com.tianzhen.spring.beans.User" name="user"/>动态代理
代理模式就是为某对象创建一个代理对象，然后通过代理对象代替原对象执行程序，已达到增强对象的作用
在程序运行之前，代理类.class文件就已经被创建了，Java中提供的动态代理就是通过反射实现，动态代理的重要实现接口 InvocationHandler就要求代理类重写 invoke 方法，我们这里可以实现一个PersonService类的代理对象
接口：
public interface IPersonService { void speak();}
PersonService类
public class PersonService implements IPersonService{ @Override public void speak() { System.out.println("君不见，高堂明镜悲白发，朝如青丝暮成雪。"); }}
PersonService代理对象
public class PersonServiceProxy implements InvocationHandler { //业务类对象 private Object target; public PersonServiceProxy(Object target){ this.target = target; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result = null; System.out.println("invoke开始"); result = methodvoke(target,args); System.out.println("invoke结束"); return result; }}
测试类
public class Test { public static void main(String[] args) { //被代理对象 PersonService personService = new PersonService(); //代理对象 PersonServiceProxy serviceProxy = new PersonServiceProxy(personService); // 通过反射，获取类加载器 ClassLoader classLoader = personService.getClass().getClassLoader(); // 通过反射，获取该类实现的接口 Class<?>[] interfaces = personService.getClass().getInterfaces(); IPersonService iPersonService = (IPersonService)Proxy.newProxyInstance(classLoader, interfaces, serviceProxy); iPersonService.speak(); }}
由此实现，在调用speak方法之前和之后都可以执行一些其他操作
反射项目案例之前做的项目中也应用到反射，来导出指定字段的数据，需求如下：
学生有部分字段，现需要根据用户选中的字段进行指定字段的导出并且导出的excel表中的表头需要和系统中一致此时我的实现方式就是在字段上添加自定义注解 @Excel，注解的name属性就是该字段在excel表中的名字
@Excel(name = "年级(必填)")private String stuGrade;@Excel(name = "学号(必填)")private String stuNo;@Excel(name = "姓名(必填)")private String stuName;@Excel(name = "性别(必填)")private String stuSex;@Excel(name = "出生年月")private String stuBirth;@Excel(name = "年龄")private Integer stuAge;@Excel(name = "民族(必填)")private String stuNation;@Excel(name = "手机号码")private String stuMobile;@Excel(name = "政治面貌")private String stuAff;
其次，在接口中获取前端传过来的字段名字，后端通过反射匹配，在获取到字段上的 @Excel注解的name属性去生成excel表格
// 获取用户需要导出的字段名，如stuGrade，stuNoString[] columns = stuVo.getColumns();// 通过反射获取学生字节码对象Class<StuVo> stuVoClass = StuVo.class;// 存储字段名List<String> fieldsName = new ArrayList<>();if(StringUtils.isNotNull(columns) && columns.length > 0) { // 获取用户需要的所有的列名 for (String column : columns) { Field field = null; try { // 获取对应的字段，因为字段都是private所以使用 getDeclaredField 方法 field = stuVoClass.getDeclaredField(column); } catch (NoSuchFieldException e) { throw new CustomException("找不到对应的列"); } // 根据字段 获取字段上的 Excel 注解 Excel annotation = field.getAnnotation(Excel.class); if(StringUtils.isNotNull(annotation)) { // 获取注解的name属性值 String name = annotation(); // 将name属性值存储到集合中 fieldsName.add(name); } }}else { throw new CustomException("请选择要导出的列！");}
以次来实现，生成excel表时的列名，这就是反射在我的项目中的一个应用
反射创建对象我们这里分别通过反射和new分别创建 10000000 个对象，查看耗时两者差异
package com.stt.reflect;import javang.reflect.Constructor;import javang.reflect.Field;import javang.reflect.Method;public class StudentMain { public static void main(String[] args) throws Exception { // 1、获取Class类，这里将异常向上抛出 Class clazz = Class.forName("com.stt.reflect.Student"); // 2、通过反射 创建 10000000 个Student对象 Constructor<Student> constructor = clazz.getConstructor(); long startTime = System.currentTimeMillis(); for (int i = 0; i < 10000000; i++) { Student student = constructor.newInstance(); } long endTime = System.currentTimeMillis(); System.out.println("通过反射创建10000000个对象耗时：" + (endTime - startTime) + "毫秒"); // 3、通过new 创建 10000000 个Student对象 startTime = System.currentTimeMillis(); for (int i = 0; i < 10000000; i++) { Student student = new Student(); } endTime = System.currentTimeMillis(); System.out.println("通过new创建10000000个对象耗时：" + (endTime - startTime) + "毫秒"); }}
运行结果：发现调用空参构造，反射耗时147毫秒，new仅仅需要2毫秒，调用有参的构造方法耗时几乎一致，仅仅是赋值，并没有复杂的构造，由此发现反射的性能其实是比较低的
高手回答反射优缺点优点增加程序的灵活性，可以在运行的过程中动态对类进行修改和操作提高代码的复用率，比如动态代理，就是用到了反射来实现可以在运行时轻松获取任意一个类的方法、属性并且还能通过反射进行动态调用缺点反射会涉及到动态类型的解析，所以JVM无法对这些代码进行优化，导致性能要比非反射调用更低。使用反射以后，代码的可读性会下降反射可以绕过一些限制访问的属性或者方法，可能会导致破坏了代码本身的抽象性
