spring学习02---什么是AOP以及AOP的实现

一、什么是AOP(Aspect Oriented Programming)

在软件业，AOP（Aspect Oriented Programming的缩写）为：面向切面编程

AOP是一种通过预编译方式和运行期动态代理实现程序功能的统一维护的技术。

AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

------------百度百科

二、AOP相关术语

将AOP想象成一把能切开程序的刀，AOP将一个程序切开，在切开的位置又插入了一些功能。

术语	作用	理解
连接点（Joinpoint）	在程序运行过程中被拦截到的点，在spring中只支持方法类型的连接点，所以这里的连接点指的是被拦截到的方法	这个程序中可以下刀的位置，一般从方法处切开程序，可以切的地方
切入点（Pointcut）	指我们要对那些连接点（Joinpoint）进行拦截的定义	指定我们要下刀的位置，想要切的地方
切面（Aspect）	是指封装横向切到系统功能的类（例如事务处理），是切入点和通知的结合	切入点和通知的结合
通知（Advice）	通知就是指拦截到的连接点之后所要做的事情，因此通知是切面的具体实现；通知分为前置通知、后置通知、异常通知、最终通知、环绕通知	往程序切开的地方插入功能，这个功能叫做通知
引介（Introduction）	也被称为引入，允许在现有的实现类中添加自定义的方法和属性；	动态地往类中插入一个新的方法
目标对象（Target Object）	是指被通知的对象，即代理的目标对象	被切的对象
织入（Weaving）	是将切面代码插入到目标对象上，从而生成代理对象的过程	在切开的地方插入功能即为织入
代理（Proxy）	是通知应用到目标对象之后被动态创建的对象	一个对象被织入一些功能以后生成了一个新的对象，这个对象就是代理

三、AOP底层实现原理

AOP的底层是使用动态代理的方法实现的，在Java中有多种动态代理技术，如JDK、CGLIB、Javassist、ASM，其中最常用的动态代理技术是JDK和CGLIB。

1、JDK的动态代理

JDK动态代理是java.lang.reflect.*包提供的方法，必须要借助一个接口才能产生代理对象（可以对实现接口的类进行代理），对于使用业务接口的类，Spring默认使用JDK动态代理实现AOP。

JDK的动态代理主要是使用java.lang.reflect.Proxy生成代理。但是这样只能代理实现了接口的类。

StuDao接口

public interface StuDao {
	public void add();
	public void find();
	public void update();
	public void delete();
}

StuDaoImpl实现类

public class StuDaoImpl implements StuDao {
	@Override
    public void add() {
    	System.out.println("添加学生");
	}

	@Override
	public void find() {
    	System.out.println("查询学生");
	}

	@Override
	public void update() {
    	System.out.println("修改学生");
	}

	@Override
	public void delete() {
    	System.out.println("删除学生");
	}
}

创建aspect包，并创建切面类MyAspect，该类中可以定义多个通知，即增强处理的方法，示例代码如下：

public class MyAspect {
	public void check(){
	    System.out.println("模拟权限控制");
	}
	public void except(){
    	System.out.println("模拟异常处理");
	}
	public void log(){
    	System.out.println("模拟日志记录");
	}
	public void monitor(){
    	System.out.println("模拟性能检测");
	}
}

创建proxy包，并创建代理类MyJdkProxy，在JDK动态代理中代理类必须实现java.lang.reflect.InvocationHandler接口，并编写代理方法，在代理方法中需要通过Proxy实现动态代理。示例代码如下：

package com.aop.proxy;

import com.aop.aspect.MyAspect;
import com.aop.dao.StuDao;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MyJdkProxy implements InvocationHandler {

	//声明目标类接口对象（真实对象）
	private StuDao stuDao;

	public MyJdkProxy(StuDao stuDao){
    	this.stuDao = stuDao;
	}

	//创建代理的方法，建立代理对象和真实对象的代理关系，返回代理对象
	public Object createProxy(){
    	//1.类加载器
    	ClassLoader cld = MyJdkProxy.class.getClassLoader();
    	
    	//2.被代理对象实现的所有接口
    	Class[] clazz = stuDao.getClass().getInterfaces();
    	
    	return Proxy.newProxyInstance(cld,clazz,this);
	}

	/**
	 * 代理的逻辑方法，所有动态代理类的方法调用都交给该方法处理
 	* @param proxy 被代理对象
 	* @param method 要执行的方法
 	* @param args 执行方法时需要的参数
 	* @return 返回代理结果
 	* @throws Throwable
 	*/
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    	//创建一个切面
    	MyAspect myAspect = new MyAspect();
    	
    	//前增强
   		myAspect.check();
    	myAspect.except();
    	
    	//在目标类上调用方法并传入参数，相当于调用stuDao中的方法
    	Object obj = method.invoke(stuDao,args);
    	
    	//后增强
    	myAspect.log();
    	myAspect.monitor();
    	return obj;
	}
}

创建测试类

@Test
public void testStu(){
	//创建目标对象
	StuDao stuDao = new StuDaoImpl();
	//创建代理对象
	MyJdkProxy myJdkProxy = new MyJdkProxy(stuDao);
	//从代理对象中获取增强后的目标对象
	//该对象是一个被代理的对象，它会进入代理的逻辑方法invoke中
	StuDao stuDaoProxy = (StuDao) myJdkProxy.createProxy();
	//执行方法
	stuDaoProxy.add();
	System.out.println("==================");
	stuDaoProxy.update();
	System.out.println("==================");
	stuDaoProxy.delete();
}

2、CGLIB的动态代理

JDK动态代理必须提供接口才能使用，对于没有提供接口的类，只能采用CGLIB动态代理。CGLIB采用非常底层的字节码技术，对指定的目标类生产一个子类，并对子类进行增强。在Spring Core 包中已经集成了CGLIB所需要的jar包，无需另外引入jar包。

Enhancer是CGLIB中使用频率很高的一个类，它是一个字节码增强器，可以用来为无接口的类创建代理。CGLIB的动态代理中，主要就是使用Enhancer来继承一个类，从而实现代理。

创建目标类TestDao

public class TestDao {

	public void save(){
    	System.out.println("保存方法");
	}
	
	public void modify(){
    	System.out.println("修改方法");
	}
	
	public void delete(){
    	System.out.println("删除方法");
	}
}

创建切面类MyAspect，并在该类中定义多个通知

public class MyAspect {

	public void check(){
    	System.out.println("模拟权限控制");
	}
	
	public void except(){
    	System.out.println("模拟异常处理");
	}
	
	public void log(){
    	System.out.println("模拟日志记录");
	}
	
	public void monitor(){
    	System.out.println("模拟性能检测");
	}
}

创建代理类MyCglibProxy，并实现MethodInterceptor接口

package com.aop.proxy;

import com.aop.aspect.MyAspect;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class MyCglibProxy implements MethodInterceptor {

	/**
	 * 创建代理的方法，生成CGLIB代理对象
	 * @param target 目标对象，需要增强的对象
	 * @return 返回目标对象的CGLIB代理对象
	 */
	public Object createProxy(Object target){
    	//创建一个动态类对象，即增强类对象
    	Enhancer enhancer = new Enhancer();
    	//设置其父类
    	enhancer.setSuperclass(target.getClass());
    	//确定代理逻辑对象为当前对象
    	enhancer.setCallback(this);
    	return enhancer.create();
	}

	/**
 	* 该方法会在程序执行目标方法时调用
 	* @param proxy 是CGLIB根据指定父类生成的代理对象
 	* @param method 是拦截方法
 	* @param args 拦截方法的参数数组
 	* @param methodProxy 方法的代理对象，用于执行父类的方法
 	* @return 返回代理结果
 	* @throws Throwable
 	*/
	@Override
	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    	//创建一个切面
    	MyAspect myAspect = new MyAspect();
    	//前置增强
    	myAspect.check();
    	//目标方法执行，返回执行结果
    	Object obj = methodProxy.invokeSuper(proxy,args);
    	//后置增强
    	myAspect.log();
    	return obj;
	}
}

创建测试类

@Test
public void test(){
	//创建目标对象
	TestDao testDao = new TestDao();
	//创建代理对象
	MyCglibProxy myCglibProxy = new MyCglibProxy();
	//获取增强后的目标对象
	TestDao testDaoAdvice = (TestDao) myCglibProxy.createProxy(testDao);
	//执行方法
	testDaoAdvice.save();
	System.out.println("==================");
	testDaoAdvice.modify();
	System.out.println("==================");
	testDaoAdvice.delete();
}

3、动态代理注意事项

程序中应优先对接口创建代理，便于程序解耦维护；
使用final关键字修饰的方法不能被代理，因为无法覆盖
JDK动态代理，是针对接口生成子类，接口中方法不能使用final修饰
CGLIB是针对目标类生成子类，因此类或方法不能使用final修饰
Spring只支持方法连接点，不提供属性连接点

原文地址：spring框架学习06-------AOP底层实现原理潘亚的博客