陆敏技说Spring
前些天更新的《陆敏技说Spring》一文，小伙伴们的反映非常好，有很多找我们的老师索要配套视频的，时隔好几天，小编今天接着上次的未完待续，给大家送干货了哦~~ 结尾处有我们老师的联系方式，可以索要配套视频哦。
此文为原创，禁止非法转载。
正文：
1.3.反射的原理
我们讲完了IOC和DI了，但是其实对反射还是接触到了一点皮毛。现在，让我们深入的了解下反射。不过，要了解反射的原理，还得首先了解一些关于类型加载的基础知识。
我们知道运行java代码的是虚拟机jvm。那么java代码本身是怎么进入到jvm并且被jvm所识别的呢。 代码本身本身编译之后变成class文件，class文件进入jvm会被一种叫做类加载器的组件先处理一遍。被类加载器处理过后的类型，会变成一些被jvm认识的元数据，它们包括：构造函数、属性和方法等。 负责反射的那些类型也认识这些元数据，并可以动态修改或者操作这些元数据。即，对于java中的任意一个类，反射类都能知道和调用这个类的所有属性和方法，包括私有属性和方法（这就厉害了，说好的封装呢，说好的private不能被访问，在反射类这里统统无效！）
除此之外，反射甚至允许我们动态生成类型，也即我们压根在原来的代码中没有一个叫做User的类型，但是利用反射基础，却能动态生成一个User类型，再通过类加载器加载到jvm中。
1.3.1. 类加载器
既然说到类加载器，那我们就先来看看类加载器。类装载器具体来说就是解析类的节码文件并构造出类在JVM内部表现形式（元数据）的组件。类装载器加载一个类型，经历了如下步骤：
1：装载：查找和导入Class文件；
2：链接：执行校验、准备和解析步骤，其中解析步骤是可以选择的：
校验：检查载入Class文件数据的正确性；
准备：给类的静态变量分配存储空间；
解析：将符号引用转成直接引用；
3：初始化：对类的静态变量、静态代码块执行初始化工作。
类加载器默认有三个，它们分别负责不同类型的java类的加载：
（1）Bootstrap ClassLoader 根类加载器
也被称为引导类加载器，负责Java核心类的加载比如System,String等在JDK中JRE的lib目录下rt.jar文件中的那些类型。
（2）Extension ClassLoader 扩展类加载器
负责JRE的扩展目录中jar包的加载。这些类型在JDK中JRE的lib目录下ext目录下。
（3）System ClassLoader 系统类加载器
负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定jar包和类路径下那些类型。
这三个类装载器之间存在父子层级关系，即根装载器是ExtClassLoader的父装载器，ExtClassLoader是AppClassLoader的父装载器。
我们可以通过代码得到类加载器的原型，如下：
public class ClassLoaderTest {
public static void main(String[] args) {
ClassLoader loader = ClassLoaderTest.class.getClassLoader();
System.out.println("current loader:"+loader);
System.out.println("parent loader:"+loader.getParent());
System.out.println("top loader:"+loader.getParent(). getParent()); }
}
结果：
current loader:sun.misc.Launcher$AppClassLoader@4e0e2f2a
parent loader:sun.misc.Launcher$ExtClassLoader@2a139a55
top loader:null
注意，根加载器在java中无法访问，所以是null。
1.3.2. 反射能做什么
利用反射，我们主要可以做这些事情，
在运行时构造任意一个类的对象；
在运行时获得任意一个类的信息，包括所具有的成员变量和方法；
在运行时调用任意一个对象的方法；
生成动态代理。
构造任意一个对象：
Class class1 = null;
Class class2 = null;
Class class3 = null;
// 获取类型的三种方式，有了类型后就可以newInstance()了
class1 = Class.forName("com.zuikc.dao.mysql.UserDaoImpl");
class2 = new UserDaoImpl().getClass();
class3 = UserDaoImpl.class;
System.out.println("类名称 " + class1.getName() + "类对象：" + class1.newInstance());
System.out.println("类名称 " + class2.getName() + "类对象：" + class2.newInstance());
System.out.println("类名称 " + class3.getName() + "类对象：" + class3.newInstance());
注意，如果类有构造方法，则可以这样调用（这里，我们使用User类）：
Class class1 = Class.forName("com.zuikc.bean.User");
// 第一种方法，不调用有参构造器，所以直接newInstance
User user = (User) class1.newInstance();
user.setAge(20);
user.setName("baobao");
System.out.println(user);
// 第二种方法，先获取全部的构造器，看看它们有什么参数
Constructor cons[] = class1.getConstructors();
// 查看每个构造方法需要的参数
for (int i = 0; i < cons.length; i++) {
Class clazzs[] = cons[i].getParameterTypes();
System.out.print("cons[" + i + "] (");
for (int j = 0; j < clazzs.length; j++) {
if (j == clazzs.length - 1)
System.out.print(clazzs[j].getName());
else
System.out.print(clazzs[j].getName() + ",");
}
System.out.println(")");
}
// 调用有参构造器来创造对象
user = (User) cons[0].newInstance(20, "Rollen");
System.out.println(user);
user = (User) cons[1].newInstance("Rollen");
System.out.println(user);
为保证代码的完整性，同时给出Bean，
package com.zuikc.bean;
public class User {
public User() {
super();
}
public User(String name) {
super();
this.name = name;
}
public User(int age, String name) {
super();
this.age = age;
this.name = name;
}
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + "]";
}
}
获取类的信息，包括所具有的成员变量和方法：
Class clazz = Class.forName("com.zuikc.dao.mysql.UserDaoImpl");
System.out.println("===============本类的field===============");
Field[] field = clazz.getDeclaredFields();
for (int i = 0; i < field.length; i++) {
int mo = field[i].getModifiers();
String priv = Modifier.toString(mo);
Class type = field[i].getType();
System.out.println(priv + " " + type.getName() + " " + field[i].getName() + ";");
}
System.out.println("==========实现的接口或者父类的public field==========");
Field[] filed1 = clazz.getFields();
for (int j = 0; j < filed1.length; j++) {
int mo = filed1[j].getModifiers();
String priv = Modifier.toString(mo);
Class type = filed1[j].getType();
System.out.println(priv + " " + type.getName() + " " + filed1[j].getName() + ";");
}
System.out.println("==========实现的接口或者父类的方法==========");
Method method[] = clazz.getMethods();
for (int i = 0; i < method.length; ++i) {
Class returnType = method[i].getReturnType();
Class para[] = method[i].getParameterTypes();
int temp = method[i].getModifiers();
System.out.print(Modifier.toString(temp) + " ");
System.out.print(returnType.getName() + " ");
System.out.print(method[i].getName() + " ");
System.out.print("(");
for (int j = 0; j < para.length; ++j) {
System.out.print(para[j].getName() + " " + "arg" + j);
if (j < para.length - 1) {
System.out.print(",");
}
}
Class exce[] = method[i].getExceptionTypes();
if (exce.length > 0) {
System.out.print(") throws ");
for (int k = 0; k < exce.length; ++k) {
System.out.print(exce[k].getName() + " ");
if (k < exce.length - 1) {
System.out.print(",");
}
}
} else {
System.out.print(")");
}
System.out.println();
}
}
调用任意方法，
Class clazz = Class.forName("com.zuikc.dao.mysql.UserDaoImpl");
// 调用方法，第二个参数指参数的类型
Method method = method = clazz.getMethod("getUserByName", String.class);
Object o = method.invoke(clazz.newInstance(), "baobao");
User user = (User)o;
System.out.println(user.getName());
调用任意属性：
Class clazz = Class.forName("com.zuikc.dao.mysql.UserDaoImpl");
Object obj = clazz.newInstance();
// 可以直接对 private 的属性赋值
Field field = clazz.getDeclaredField("propretyname");
field.setAccessible(true);
field.set(obj, "some value");
System.out.println(field.get(obj));
实现动态代理。注意，关于动态代理，是下一小节我们将要重点介绍的内容。在此处先略过。
1.4.动态代理的现实意义
我们说反射可以被用于动态代理，现在我们先不管动态代理是什么，按照我们最课程（zuikc.com）授课模式，我们先来看该技术产生的现实意义。
1.4.1. 为什么需要动态代理
首先，我们的程序已经撰写完毕了。现在，我们的产品经理跑过来说，最近发生了一些安全上的事故，所以我们要加入一个功能，记录某些关键的操作是谁在什么时候操作的。
简单来说，比如，任何人访问getUserByName，我们都需要记录是谁，在什么时候访问，甚至如果是在一个web程序的话，我们还要记录访问者的远程ip地址。
一种做法是，我们进入getUserByName中去修改代码，把记录日志这个事情完成一下。但是技术总监说，不行，既有的服务层以下的代码都已经经过严格测试，不能再侵入代码，我们必须在既有代码的外层来加入这些新功能。
于是，思路来了：我们还是按照原有流程执行代码，但是执行到UserDao的getUserByName时候，我们通过技术手段替换掉UserDao这个对象，转而调用UserDaoProxy对象，在这个proxy中，也有一个getUserByName方法，在这个方法里面我们添加新代码，同时还调用老方法，这样就完美解决了即不修改老方法，也增加了新功能。
当然，这里面的关键点，就是“通过技术手段替换掉UserDao这个对象，转而调用UserDaoProxy对象”。这个技术手段，就叫做：动态代理。
1.4.2. 代理的最简单实现
那怎么来生成代理对象，它的形式可以如：
UserDao proxy= 根据UserDaoImpl来生成代理对象;
proxy.getUserByName("baobao");
好，现在的关键就是让我们来解决“根据UserDaoImpl来生成代理对象”。
其实在JDK中的反射包中，正好有一个类java.lang.reflect.Proxy有一个newProxyInstance方法是用来专门生成代理对象的：
static object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)
第一个参数，是要被代理的那个类的ClassLoader，那怎么得到这个ClassLoader？好办，直接调用 被代理的类型.getClass().getClassLoader()；
第二个参数，接受的是一个类型的参数，即我们的UserDaolIml这个类型一共实现了几个接口。那怎么得到这个接口数组呢，也好办，Class类型有一个方法getInterfaces()就是用来得到类型所实现的接口数组的。
第三个参数，是要传入一个InvocationHandler的类型。我们发现InvocationHandler是一个接口，所以我们得首先实现一个InvocationHandler的实现类。这个实现类实现InvocationHandler中声明好的一个方法，叫做：
Object invoke（Object proxy, Method method, Object[] args）
看好了，可以说这就很关键了，Proxy被设计为，我们看上去是在执行proxy的getUserByName方法，其实是执行了proxy的invoke方法，那这是怎么做到的呢：
1：首先，proxy能够执行另外一个类（InvocationHandler实现类）的方法，那proxy首先得持有这个类不是吗，所以我们才发现Porxy.newProxyInstance的第三个参数就是InvocationHandler类型。即创建代理类的时候，就会把InvocationHandler实现类作为方法参数传递给代理类；
2：其次，执行任何代理类方法，jvm都会首先引导到执行invoke方法，比如执行getUserByName，其实已经被强制为执行invoke方法了，我们可以在invoke方法，通过反射对原方法为所欲为！ 让我们看看最简单的invoke方法吧：
package com.zuikc.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class InvocationHandlerImpl implements InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("被代理的方法要开始执行了……");
Object temp = method.invoke(被代理的类的实例, args);
System.out.println("被代理的方法执行完毕了……");
return temp;
}
} invoke自带了参数，被代理的类的原方法的元数据信息作为Method参数被传递起来的。我们可以对它为所欲为意味着：我们想怎么执行它就怎么执行它，甚至还可以选择不执行它。
注意，被代理的方法是获取到了，但是为了运行它，可不还得有被代理的类的对象本身吗（上文中，红色的部分）？既然需要它，我们就在InvocationHandlerImpl的构造器中传给它就行了，于是，上面的代码变成了：
package com.zuikc.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class InvocationHandlerImpl implements InvocationHandler {
private Object obj = null;
public InvocationHandlerImpl(Object obj) {
this.obj = obj;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("方法开始执行了~~");
System.out.print(" 被截获的方法为：" + method.getName() + "\t参数为：");
for (Object arg : args) {
System.out.print(arg + "\t");
}
System.out.println();
Object temp = method.invoke(this.obj, args);
System.out.println("方法执行完毕，返回~~");
return temp;
}
}
经过本次改造，客户端调用原来的代码，由：
UserDaoImpl userDaoImpl = new UserDaoImpl();
userDaoImpl.getUserByName("baobao");
变成了被动态代理的：
UserDaoImpl userDao = new UserDaoImpl();
InvocationHandlerImpl handler = new InvocationHandlerImpl(userDao);
UserDao proxy= (UserDao)Proxy.newProxyInstance(
userDao.getClass().getClassLoader(),
userDao.getClass().getInterfaces(),
handler);
proxy.getUserByName("baobao");
其输出为：
方法开始执行了~~
被截获的方法为：getUserByName 参数为：baobao
方法执行完毕，返回~~
1.4.3. 面向切面编程
“代理的最简单实现”这一小节中所表现出现的开发思想就被定义为：面向切面编程（AOP）。 代理是实现AOP的技术手段。
未完待续……
