反射初识
在网上看java反射讲的是很模糊，今天通过我的理解细细讲下，相信通过这篇文章让你重拾对学习的信心。
一句话概括： 反射是可以绕过 jvm 编译阶段。可以动态加入代码。比如一个对象没有确定，可以在运行过程中动态去确定。一个对象的方法未完全实现，也可以调用该方法（部分）。
很抽象？等下面我们通过实例讲完之后，再看这个概念，觉得醍醐灌顶！！！
有反射，那就有正射，正射就是我们提前在代码中new 对象（）
假如我需要实例化一个学生对象，代码就会是这样子。
Students user = new Students();
某一天忽然来了一个这样的场景需求，就是需要实例化老师和学校这两个对象，在代码编译阶段是不确定创建对象，那么就需要动态创建了，代码即是这样的：
//动态创建实体
public <T> T get Class (String param) {
Object T = null;
if (param.equals("student")) {
T = new Students();
} else if (param.equals("teacher")) {
T = new Teacher();
} else if (param.equals("school")) {
T = new School();
}
return (T) T;
}
通过传入参数param决定使用哪一种实体，可以在项目运行时，通过动态传入参数决定使用哪一个实体，看到这里是不是有点像设计模式当中的工厂模式，是的，这个也算是应用场景之一。
那么通过这个例子简单总结下
简单总结
在代码运行之前，我们 不确定 将来会使用哪一种数据结构，只有在程序 运行时才决定 使用哪一个数据类，而反射可以在 程序运行过程 中动态 获取类信息 和 调用类方法 。通过反射构造类实例，代码最终会演变成下面这样。
public <T> T getPoJo(String className) throws Exception {
Class clazz = Class.forName(className);
return (T) clazz.newInstance();
}
- 反射的思想：在程序运行过程中确定和解析数据类的类型 。
- 反射的作用：对于在编译期无法确定使用哪个数据类的场景，通过反射可以在程序运行时构造出不同的数据类实例。
接下来我们再进行深入理解，看看如何使用！
反射的基本使用
Java 反射的主要组成部分有4个：
- Class：任何运行在内存中的所有类都是该 Class 类的实例对象，每个 Class 类 对象内部都包含了本来的所有信息。记着一句话，通过反射干任何事，先找 Class 准没错！
- Field：描述一个类的属性，内部包含了该属性的所有信息，例如数据类型，属性名，访问修饰符······
- Constructor ：描述一个类的 构造方法 ，内部包含了构造方法的所有信息，例如参数类型，参数名字，访问修饰符······
- Method：描述一个类的所有方法（包括抽象方法），内部包含了该方法的所有信息，与Constructor类似，不同之处是 Method 拥有返回值类型信息，因为构造方法是没有返回值的。
在网上找到一张图，放在了下面，如果用到了反射，离不开这核心的4个类，只有去了解它们内部提供了哪些信息，有什么作用，运用它们的时候才能易如反掌。
我们在学习反射的基本使用时，我会用一个Students类作为模板进行说明，首先我们先来熟悉这个类的基本组成：属性，构造函数和方法
public class Students {
public String name;
public int age;
private double weight; // 体重只有自己知道
public Students() {}
public Students(String name, int age) {
this.name = name;
this.age = age;
}
public void getInfo() {
System.out.print("["+ name + " 的年龄是：" + age + "]");
}
}
反射中的用法有非常非常多，常见的功能有以下这几个：
- 在运行时获取一个类的 Class 对象
- 在运行时构造一个类的实例化对象
- 在运行时获取一个类的所有信息：变量、方法、构造器、注解
获取类的 Class 对象
在 Java 中，每一个类都会有专属于自己的 Class 对象，当我们编写完.java文件后，使用 javac 编译后，就会产生一个 字节码 文件.class，在字节码文件中包含类的所有信息，如属性，构造方法，方法······当字节码文件被装载进 虚拟机 执行时，会在内存中生成 Class 对象，它包含了该类内部的所有信息，在程序运行时可以获取这些信息。
获取 Class 对象的方法有3种：
- 类名.class：这种获取方式只有在编译前已经声明了该类的类型才能获取到 Class 对象
Class clazz = Students.class;
- 实例.getClass()：通过实例化对象获取该实例的 Class 对象
Students sp = new Students();
Class clazz = sp.getClass();
- Class.forName(className)：通过类的 全限定名 获取该类的 Class 对象
Class clazz = Class.forName("com.bean.Students");
构造类的实例化对象
通过反射构造一个类的实例方式有2种：
- Class 对象调用newInstance()方法
Class clazz = Class.forName("com.bean.Students");
Students stu = (Students) clazz.newInstance();
stu.getInfo();
// [null 的年龄是：]
即使 Students 已经显式定义了构造方法，通过 newInstance() 创建的实例中，所有属性值都是对应类型的初始值，因为 newInstance() 构造实例会调用默认无参构造器。
- Constructor 构造器调用newInstance()方法
Class clazz = Class.forName("com.bean.Students");
Constructor constructor = clazz.getConstructor(String.class, int.class);
constructor.setAccessible(true);
Students stu = (SmallPineapple) constructor.newInstance("苏世",);
stu.getInfo();
// [苏世 的年龄是：]
通过Class对象调用 newInstance() 会走默认无参构造方法，如果想通过显式构造方法构造实例，需要提前从Class中调用getConstructor()方法获取对应的构造器，通过 构造器 去实例化对象。
获取一个类的所有信息
这里就不展开细讲了，大家用到的时候 可以根据该图查询即可，因为我们主要是讲面试，面试不会问这么细的。
通过反射调用方法
通过反射获取到某个 Method 类对象后，可以通过调用invoke方法执行。
- invoke(Oject obj, Object… args)：参数“1指定调用该方法的 对象 ，参数2`是方法的参数列表值。
- 如果调用的方法是 静态方法 ，参数1只需要传入null，因为静态方法不与某个对象有关，只与某个类有关。
可以像下面这种做法，通过反射实例化一个对象，然后获取Method方法对象，调用invoke()指定Students的getInfo()方法。
Class clazz = Class.forName("com.bean.Students");
Constructor constructor = clazz.getConstructor(String.class, int.class);
constructor.setAccessible(true);
Students st = (Students) constructor.newInstance("苏世",);
Method method = clazz.getMethod("getInfo");
if (method != null) {
method.invoke(st, null);
}
// [苏世的年龄是：]
反射的应用场景
通过上面的讲解，我们可以回味总结下：
反射常见的应用场景这里介绍3个：
- Spring 实例化对象：当程序启动时，Spring 会读取配置文件applicationContext.xml并解析出里面所有的标签实例化到IOC容器中。
- 反射 + 工厂模式：通过反射消除工厂中的多个分支，如果需要生产新的类，无需关注工厂类，工厂类可以应对各种新增的类，反射可以使得程序更加健壮。
- JDBC 连接数据库：使用JDBC连接数据库时，指定连接数据库的驱动类时用到反射加载驱动类
我们再对上述场景进行一一讲解
Spring 的 IOC 容器
在 Spring 中，经常会编写一个上下文配置文件applicationContext.xml，里面就是关于bean的配置，程序启动时会读取该 xml 文件，解析出所有的 <bean>标签，并实例化对象放入IOC容器中。
<?xml version=".0" encoding="UTF-8"?>
<beans xmlns="#;
xmlns:xsi="#;
xsi:schemaLocation=" #;>
<bean id="stu" class="com.bean.Students">
<constructor-arg type="java.lang.String" value="苏世"/>
<constructor-arg type="int" value=""/>
</bean>
</beans>
在定义好上面的文件后，通过 ClassPath XmlApplicationContext加载该配置文件，程序启动时，Spring 会将该配置文件中的所有bean都实例化，放入 IOC 容器中，IOC 容器本质上就是一个工厂，通过该工厂传入 < bean > 标签的id属性获取到对应的实例。
public class Main {
public static void main(String[] args) {
ApplicationContext ac =
new ClassPathXmlApplicationContext("applicationContext.xml");
Students stud = (Students) ac.getBean("stu");
stud.getInfo(); // [苏世年龄是：]
}
}
Spring 在实例化对象的过程经过简化之后，可以理解为反射实例化对象的步骤：
- 获取Class对象的构造器
- 通过构造器调用 newInstance() 实例化对象
反射 + 抽象工厂模式
代码实例上述已经讲过 可以回去看下增加下印象
反射 + 抽象工厂的核心思想是：
在运行时通过参数传入不同子类的全限定名获取到不同的 Class 对象，调用 newInstance() 方法返回不同的子类。细心的读者会发现提到了子类这个概念，所以反射 + 抽象工厂模式，一般会用于有继承或者接口实现关系。
JDBC 加载数据库驱动类
在导入第三方库时，JVM不会主动去加载外部导入的类，而是等到真正使用时，才去加载需要的类，正是如此，我们可以在获取数据库连接时传入驱动类的全限定名，交给 JVM 加载该类。
public class DBConnectionUtil {
/** 指定数据库的驱动类 */ private static final String DRIVER_CLASS_NAME = "com.mysql.jdbc.Driver";
public static Connection getConnection() {
Connection conn = null;
// 加载驱动类
Class.forName(DRIVER_CLASS_NAME);
// 获取数据库连接对象
conn = DriverManager.getConnection("jdbc:mysql://···", " root ", "root");
return conn;
}
}
在我们开发 SpringBoot 项目时，会经常遇到这个类，但是可能习惯成自然了，就没多大在乎，我在这里给你们看看常见的application.yml中的数据库配置，我想你应该会恍然大悟吧。
这里的 driver-class-name ，和我们一开始加载的类是不是觉得很相似，这是因为 MySQL 版本不同引起的 驱动类不同 ，这体现使用反射的好处：不需要修改源码， 仅加载配置文件就可以完成驱动类的替换 。
优缺点
- 增加程序的灵活性 ：面对需求变更时，可以灵活地实例化不同对象
但是，有得必有失，一项技术不可能只有优点没有缺点，反射也有 两个比较隐晦的缺点 ：
- 破坏类的封装性 ：可以强制访问 private 修饰的信息
- 性能损耗 ：反射相比直接实例化对象、调用方法、访问变量，中间需要非常多的 检查步骤和解析步骤 ，JVM无法对它们优化。
反射总结
- 反射的思想：反射就像是一面镜子一样，在运行时才看到自己是谁，可获取到自己的信息，甚至实例化对象。
- 反射的作用：在运行时才确定实例化对象，使程序更加健壮，面对需求变更时，可以最大程度地做到不修改程序源码应对不同的场景，实例化不同类型的对象。
- 反射的应用场景常见的有3个：Spring的 IOC 容器，反射+工厂模式 使工厂类更稳定，JDBC连接数据库时加载驱动类
- 反射的3个特点：增加程序的灵活性、破坏类的封装性以及性能损耗