1. Spring AOP简介

1.1 什么是AOP

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

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

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

AOP的使用，使开发人员在编写业务逻辑时可以专心于核心业务，而不用过多的关注于其他业务逻辑的实现，这不但提高了开发效率，而且增强了代码的可维护性。

1.2 AOP术语

Aspect（切面）：封装的用于横向插入系统功能（如事务、日志等）的类。该类要被Spring容器识别为切面，需要在配置文件中通过元素指定。
Joinpoint（连接点）：在程序执行过程中的某个阶段点，它实际上是一个对象的操作，例如方法的调用或者异常的抛出。在Spring AOP中，连接点就是指方法的调用。
Pointcut（切入点）：切面与程序流程的交叉点，即那些需要处理的连接点。通常在程序中，切入点指的是类或者方法名，如某个通知要应用到所有以add开头的方法中，那么所有满足这一规则的方法都是切入点。
Advice(通知/增强处理）：AOP框架在特定的切入点执行的增强处理，即在定义好的切入点处所要执行的程序代码。可以将其理解为切面类中的方法，它是切面的具体实现。
Target Object(目标对象）：指所有被通知的对象，也称为被增强对象。如果AOP框架采用的是动态的AOP实现，那么该对象就是一个被代理对象。
Proxy（代理）：将通知应用到目标对象之后，被动态创建的对象
Weaving（织入）：将切面代码插入到目标对象上，从而生成代理对象的过程。

2.动态代理

AOP中的代理说是由AOP框架动态生成的一个对象，该对象可以作为目标对象使用。Spring 中的AOP有两种，JDK动态代理，CGLIB代理

2.1 JDK动态代理

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

案例演示：

1.创建cn.ssm.jdk包，在该包下创建接口UserDao，并在该接口中编写添加和删除的方法。

public interface UserDao {
    public void addUser();
    public void deleteUser();
}

2.创建UserDao接口的实现类UserDaoImpl，分别实现接口中的方法

//目标类
public class UserDaoImpl implements UserDao {
    @Override
    public void addUser() {
        System.out.println("添加用户");
    }
    @Override
    public void deleteUser() {
        System.out.println("删除用户");
    }
}

3.创建com.ssm.aspect包，在该包下创建切面类MyAspect，在该类中定义一个模拟权限检查的方法和一个模拟记录日志的方法，这两个方法就表示切面中的通知。

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

4.在cn.ssm.jdk包下创建代理类JdkProxy，该类需要实现InvocationHandler接口，并 编写代理方法。在代理方法中，需要通过Proxy类实现动态代理.

/**
 * 代理类
 */
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();
        //3.使用代理类进行增强，返回的是代理后的对象
        return Proxy.newProxyInstance(classLoader,clazz,this);
    }
    /*
    所有动态代理类的方法调用，都会交由invoke()方法处理
    proxy 被代理后的对象
    method 将要被执行的方法信息（反射）
    args 执行方法时需要的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //声明切面
        MyAspect myAspect=new MyAspect();
        //前增强
        myAspect.check_Permissions();
        //在目标类上调用方法，并传入参数
        Object obj=method.invoke(userDao,args);
        //后增强
        myAspect.log();
        return obj;
    }
}

JdkProxy类实现了InvocationHandler接口，并实现了接口中的invoke()方法，所有动态代理类所调用的方法都会交由该方法处理。在创建的代理方法createProxy()中，使用了Proxy类的newProxyInstance()方法来创建代理对象。newProxyInstance()方法中包含3个参数，其中第1个参数是当前类的类加载器，第2个参数表示的是被代理对象实现的所有接口，第3个参数this代表的就是代理类JdkProxy本身。在invoke()方法中，目标类方法执行的前后，会分别执行切面类中的check_Permissions()方法和log()方法。
5.在cn.ssm.jdk包中，创建测试类JdkTest。在该类中的main()方法中创建代理对象和目标对象，然后从代理对象中获得对目标对象userDao增强后的对象，最后调用该对象中的添加和删除方法。

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

执行结果：
模拟检查权限…
添加用户
模拟记录日志…
模拟检查权限…
删除用户
模拟记录日志…

2.2 CGLIB代理

通过前面的学习可知，JDK的动态代理用起来非常简单，但它是有局限性的，使用动态代理的对象必须实现一个或多个接口（如UserDaoImpl实现了UserDao接口）。 如果想代理没有实现接口的类，那么可以使用CGLIB代理.
CGLIB（Code Generation Library）是一个高性能开源的代码生成包，它采用非常底层的字节码技术，对指定的目标类生成一个子类，并对子类进行增强。
在Spring的核心包中已经集成了CGLIB所需的包，所以开发中不需要导包。
1.创建cn.ssm.cglib包，在包中创建一个目标类UserDao，UserDao 需要实现任何接口，只需定义一个添加用户的方法和一个删除用户的方法。

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

2.创建代理类CglibProxy，该代理类需要实现MethodInterceptor接口，并实现接口中的intercept()方法。

//代理类
public class CglibProxy implements MethodInterceptor {
    //代理方法
    public Object createProxy(Object target){
        //创建一个动态类对象
        Enhancer enhancer=new Enhancer();
        //确定要增强的类，设置其父类
        enhancer.setSuperclass(target.getClass());
        //添加回调函数
        enhancer.setCallback(this);
        //返回创建的代理类
        return enhancer.create();
    }
    /**
     * proxy CGlib根据父类生成的代理对象
     * method 拦截的方法
     * args 拦截方法的参数组
     * methodProxy 方法的代理对象，用于执行父类的方法
     */
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //创建切面类对象
        MyAspect myAspect=new MyAspect();
        //前增强
        myAspect.check_Permissions();
        //目标方法执行
        Object obj=methodProxy.invokeSuper(proxy,args);
        //后增强
        myAspect.log();
        return obj;
    }
}

首先创建了一个动态类对象Enhancer，它是CGLIB的核心类；然后调用了Enhancer类的setSuperclass()方法来确定目标对象；接下来调用了setCallback()方法添加回调函数，其中的this代表的就是代理类CglibProxy本身。最后通过return 语句将创建的代理类对象返回。intercept()方法会在程序执行目标方法时被调用，方法运行时奖会执行切面类中的增强方法。
3.创建测试类 CglibTest.java

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

目标类UserDao中的方法被成功调用并增强了。这种没有实现接口的代理方式就是CGLIB代理。