Spring AOP的底层实现原理
Spring的两大核心之一就是AOP，AOP：面向切面编程。在说原理之前，得先知道一些AOP的专业术语。
AOP的专业术语
连接点（JoinPoint）：增强执行的位置（增加代码的位置），Spring只支持方法；
切点（PointCut）：具体的连接点；一般可能通过一个表达式来描述；
增强（Advice）：也称为消息，指的是增加的额外的代码，Spring中，增强除了包含代码外，还包含位置信息；
Spring中一共有四种增强：
MethodBeforeAdvice:前置增强
MethodInterceptor：环绕增强
ThrowsAdvice：异常增强
AfterReturingAdvice：返回值增强
引介（Introduction）：特殊的增强，动态为类增加方法
织入（Weaving）：将增强加入到目标类的过程，织入分为三种时期
编译器:AspectJ
类加载
运行期：jdk动态代理（实现接口），CGlib（子类，不能用final）
目标对象（Target）：原始对象
代理对象（Proxy）：加入了增强的对象，是生成的；
切面（Aspect）：切点+增强
接下来我要说的就是在运行期间织入的两种实现方式
JDK动态代理（实现接口）
什么是代理模式呢？
代理模式有三个角色，分别是
抽象角色：接口
目标角色：实现类
代理角色：实现接口（InvocationHandler），并引用目标角色
代理模式与装饰者模式的区别
类图（结构）基本一样，但目的不同，装饰模式的前提是已经所有的类，并进行组装；而
使用代理模式时，我们不能直接访问目标角色或没有权限访问时，可以使用代理模式
代理模式分为两种
静态代理：需要为每个目标角色，创建一个对应的代理角色；类的数量会急剧膨胀
动态代理：自动为每个目标角色生成对应的代理角色
接下来就是jdk动态代理的代码：
实现jdk动态代理的前提是所有的目标类都必须要基于一个统一的接口
创建统一的接口
package com.dao;
/**
* 为目标类定义统一的接口SleepDao
* @author XuXQ
*
*/
public interface SleepDao {
public void sleep();
}定义目标对象
package com.daoImpl;
import com.dao.SleepDao;
/**
* 目标类
* @author XuXQ
*
*/
public class SleepDaoImpl implements SleepDao {
@Override
public void sleep() {
System.out.println("本大人要睡觉了");
}
}创建代理角色
package com.handler;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* 创建的类得需要实现InvocationHandler,并重写invoke()方法
* InvocationHandler 是代理实例的调用处理程序 实现的接口
* 即：MyInvocationHandler 是代理实例的调用处理程序
* @author XuXQ
*
*/
public class MyInvoctionHandler implements InvocationHandler {
Object object=null;//目标对象
public MyInvoctionHandler(Object object) {
super();
this.object = object;
}
/**
* proxy=代理对象
* method=被调用方法的方法名
* args=被调用方法的参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("睡觉前要脱衣服啊");
Object obj=method.invoke(object, args);//obj为目标对象调用方法的返回值
System.out.println("睡着了当然得做个美梦啊");
return obj;
}
}编写测试用例package com.handler;
import static org.junit.Assert.*;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.dao.SleepDao;
import com.daoImpl.SleepDaoImpl;
public class Test1 {
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@Test
public void test() {
//目标类必须基于统一的接口
SleepDao s=new SleepDaoImpl();
ClassLoader classLoader=s.getClass().getClassLoader();
MyInvoctionHandler myInvoctionHandler=new MyInvoctionHandler(s);
//Proxy为InvocationHandler实现类动态创建一个符合某一接口的代理实例
SleepDao sd=(SleepDao) Proxy.newProxyInstance(classLoader, s.getClass().getInterfaces(), myInvoctionHandler);
//相当于调用代理角色的Invoke()
sd.sleep();
}
}
结果：
由结果可以看到成功的将增强织入到了目标对象中了
CGlib代理
package com.cglibproxy;
/**
* 和JDK动态代理不同，不需要创建统一的接口
* @author XuXQ
*
*/
public class Base {
public void sleep(){
System.out.println("本大少要睡觉啦");
}
}
创建cglib的代理对象
package com.cglibproxy;
import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
//用来生成代理对象
public class CglibProxy implements MethodInterceptor {
public Object getProxy(Object object){
Enhancer e=new Enhancer();//创建代理对象类
e.setSuperclass(object.getClass());//声明代理对象的父类是谁（是目标对象）
e.setCallback(this);//设置回调函数，即调用intercept()
return e.create();//返回创建的代理对象
}
/**
* proxy=代理对象，也是目标对象的子类
* args=方法参数
*/
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy arg3) throws Throwable {
System.out.println("你个大懒猪，竟然睡觉前不脱衣服，嫌弃o");
Object object=arg3.invokeSuper(proxy, args);
System.out.println("起床啦，要不然得迟到了哦");
return null;
}
}
编写测试用例
package com.cglibproxy;
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
public class Test {
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@org.junit.Test
public void test() {
CglibProxy proxy=new CglibProxy();
Base base=(Base) proxy.getProxy(new Base());
base.sleep();
}
}
结果：
由结果同样可以看到成功的将增强织入到了目标对象中了
总结
当然我们以后写代码都是基于Aspect，直接写注解的，当然这并不代表这我们不需要知道AOP
底层的实现原理，至于注解用的是哪种实现方式，使用配置来解决的，这里就不详解了。