Spring AOP动态代理

AOP的相关概念

AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程)。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。

在传统的业务处理代码中，通常都会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但如果要实现某个功能（如日志记录)，同样的代码仍然会分散到各个方法中。这样，如果想要关闭某个功能，或者对其进行修改，就必须要修改所有的相关方法,这不但增加了开发人员的工作量，而且提高了代码的出错率。

为了解决这一问题，AOP思想随之产生。AOP采取横向抽取机制，将分散在各个方法中的重复代码提取出来,然后在程序编译或运行时,再将这些提取出来的代码应用到需要执行的地方。这种采用横向抽取机制的方式，采用传统的OOP思想显然是无法办到的，因为OOP只能实现父子关系的纵向的重用。虽然AOP是一种新的编程思想,但却不是OOP的替代品，它只是OOP的延伸和补充。

专业名词

Aspect(切面):在实际应用中，切面通常是指封装的用于横向插入系统功能（如事务日志等）的类，如图3-1中的Aspect。该类要被Spring容器识别为切面，需要在配置文件中通过<bean>元素指定。

Joinpoint(连接点):在程序执行过程中的某个阶段点，它实际上是对象的一个操作，例如方法的调用或异常的抛出。在Spring AOP中，连接点就是指方法的调用。

Pointcut(切入点):是指切面与程序流程的交叉点，即那些需要处理的连接点，如图3-2所示。通常在程序中，切入点指的是类或者方法名，如某个通知要应用到所有以add开头的方法中，那么所有满足这一规则的方法都是切入点

Advice( 通知/增强处理):AOP框架在特定的切入点执行的增强处理,即在定义好的切入点处所要执行的程序代码。可以将其理解为切面类中的方法，它是切面的具体实现。

Target Object (目标对象):是指所有被通知的对象，也称为被增强对象。如果AOP框架采用的是动态的AOP实现，那么该对象就是一个被代理对象。

Proxy(代理):将通知应用到目标对象之后，被动态创建的对象。

Weaving(织入):将切面代码插入到目标对象上

动态代理

JDK代理

JDK动态代理是通过 java.lang.reflect.Proxy类来实现的，我们可以调用Proxy 类的newProxyInstance()方法来创建代理对象。对于使用业务接口的类，Spring 默认会使用JDK动态代理来实现AOP。

创建一个接口来放置你的方法

public interface UserDao {
	//添加用户
	void addUser();
	//删除用户
	void deleteUser();
}

创建一个接口的实现类

public class UserDaoImpl implements UserDao {
	public void addUser() {
		System.out.println("添加用户...");

	}
	public void deleteUser() {
		System.out.println("删除用户...");
	}
}

创建一个切面来进行存放通知

//切面类 可以存在多个通知 增强的方法
public class MyAspect {
	public void check_Permission() {
		System.out.println("模拟检查权限...");
	}
	public void log() {
		System.out.println("模拟检查记录日志...");
	}
}

创建JDK代理类 需要实现InvocationHandler接口

//JDK的代理类 需要实现InvocationHandler
public class JdkProxy implements InvocationHandler{
	//声明目标类的接口
	private UserDao userDao;
	//创建代理方法
	public Object createProxy(UserDao userDao) {
		this.userDao = userDao;
		//1.类加载器
		ClassLoader classLoader = JdkProxy.class.getClassLoader();
		//2.被代理对象实现所有接口 进行获取
		Class[] clazz = userDao.getClass().getInterfaces();//getClass()获取当前类  获取所有接口getInterfaces()
		//3.使用代理类 进行增强 返回的是代理后的对象     类本身 类接口 
		return Proxy.newProxyInstance(classLoader, clazz, this);
	}
	//所有动态代理类的调用 都是交给invoke()方法进行处理
	//proxy 被代理后的对象
	//method将要被执行的方法
	//args执行方法是所需要的参数
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//动态代理类方法的调用会交给它处理
		//1.声明切面对象
		MyAspect myAspect = new MyAspect();
		//2.前增强
		myAspect.check_Permission();
		//执行目标方法 用invoke执行
		Object object = method.invoke(userDao, args);//(对象，参数和上边一致)
		//4.后增强
		myAspect.log();
		return object;
	}
}

最后进行测试类测试

public class JdkTest {
	public static void main(String[] args) {
		//创建代理对象
		JdkProxy jdkProxy = new JdkProxy();
		//创建目标对象
		UserDao userDao = new UserDaoImpl();
		//从代理对象中获取增强后的目标对象
		UserDao userDao2 = (UserDao) jdkProxy.createProxy(userDao);
		//执行没有增强的
		userDao.addUser();
		userDao.deleteUser();
		//执行增强后的方法
		userDao2.addUser();
		userDao2.deleteUser();
	}
}

最后结果是

添加用户...
删除用户...

userDao2的结果是
模拟检查权限...
添加用户...
模拟检查记录日志...
模拟检查权限...
删除用户...
模拟检查记录日志...

CGLIB代理

JDK动态代理的使用非常简单,但它还有一定的局限性——使用动态代理的对象必须实现一个或多个接口。如果要对没有实现接口的类进行代理，那么可以使用CGLIB代理。

CGLIB ( Code Generation Library )是一个高性能开源的代码生成包，它采用非常底层的字节码技术，对指定的目标类生成一个子类，并对子类进行增强。在Spring 的核少包中已经集成了CGLIB所需要的句.所以开发中不需要另外导入JAR包。

创建一个UserDao类

public class UserDao {
	public void addUser() {
		System.out.println("添加用户...");

	}
	public void deleteUser() {
		System.out.println("删除用户...");
	}
}

创建一个切面来存放通知和增强

public class MyAspect {
	public void check_Permission() {
		System.out.println("模拟检查权限...");
	}
	public void log() {
		System.out.println("模拟检查记录日志...");
	}
}

创建一个CGLIB代理类 实现MethodInterceptor接口

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import com.qc.jdk.MyAspect;
public class CglibProxy implements MethodInterceptor{
	//代理方法
	public Object createProxy(Object target) {
		//创建一个动态类对象
		Enhancer enhancer = new Enhancer();
		//确定需要增强的类 设置成父类
		enhancer.setSuperclass(target.getClass());//因为不知道目标类是谁所以用一个getClass()
		//添加回调函数
		enhancer.setCallback(this);
		//返回创建的代理类
		return enhancer.create();
	}
	//proxy 根据指定父类生成的代理对象
	//method拦截的方法
	//args拦截的方法参数
	//methodProxy 方法的代理对象 用户执行父类的方法
	@Override
	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
		//1.创建切面对象
		MyAspect myAspect = new MyAspect();
		//前增强
		myAspect.check_Permission();
		Object object = methodProxy.invokeSuper(proxy, args);
		//后增强
		myAspect.log();
		return object;
	}
}

最后进行测试

public class CglibTest {
	public static void main(String[] args) {
		//创建代理对象
		CglibProxy cglibProxy = new CglibProxy();
		//创建目标对象
		UserDao userDao = new UserDao();
		//获取增强对象
		UserDao userDao2 = (UserDao) cglibProxy.createProxy(userDao);
		
		userDao2.addUser();
		userDao2.deleteUser();
	}
}

结果是

模拟检查权限...
添加用户...
模拟检查记录日志...
模拟检查权限...
删除用户...
模拟检查记录日志...