Spring 讲解（六）

如何理解 Spring 中的 AOP

一、AOP 的概述

1. AOP(Aspect Oriented Programming)：面向切面编程，通过预编译方式和运行期动态代理来实现程序功能的统一维护的一种技术。
2. AOP是OOP（面向对象编程）的延续，是 Spring 框架中重要内容，是函数式编程的一种衍生范型。
3. 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
4. AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码
   纵向继承。
5. 经典应用场景：事务管理、性能监视、安全检查、缓存 、日志等。
6. Spring AOP使用纯 Java 实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码。
7. AspectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入。

8. Spring 中的 AOP 实现原理

   a、接口 + 实现类 ：Spring采用 jdk 的 动态代理Proxy。

   b、实现类：Spring 采用 cglib字节码增强。

   a、Aop底层将采用代理机制进行实现（最底层也是依赖反射）。

二、AOP 实现案例

1、对 AOP 的理解（画图解释）

2、AOP 中通过 JDK动态代理简单案例演示

接口、实现类和切面类

public interface UserService {

    void addUser();

    void updateUser();

    int deleteUser(int id);
}
=========================================================================================
public class UserServiceImpl implements UserService {

    @Override
    public void addUser() {
        System.out.println("添加用户");
    }

    @Override
    public void updateUser() {
        System.out.println("更新用户");
    }

    @Override
    public int deleteUser(int id) {
        System.out.println("通过id删除用户");
        return 1;
    }
}

切面类
public class MyAspect {

    public void before(){
       System.out.println("开启事务");
    }

    public void after(){
        System.out.println("提交事务");
    }
}

JDK实现动态代理

public class MyBeanFactory {
    // JDK实现动态代理
    public static UserService createUserService() {
        //1.创建目标对象target
        final UserService userService = new UserServiceImpl();

        //2.声明切面类对象
        final MyAspect aspect = new MyAspect();

        //3.把切面类2个方法应用于目标类
        //3.1 创建JDK代理,拦截方法
        UserService serviceProxy = (UserService) Proxy.newProxyInstance(
                MyBeanFactory.class.getClassLoader(),
                userService.getClass().getInterfaces(),
                (proxy, method, args) -> {
                    //开启事务
                    aspect.before();

                    //方法返回值：业务方法的返回值
                    Object retObj = method.invoke(userService, args);
                    //System.out.println("拦截返回值:" + retObj);

                    //提交事务
                    aspect.after();
                    return retObj;
                }
        );
        return serviceProxy;
    }
}

测试函数

public class AOPTest {

    public static void main(String[] args) {
        UserService userService = MyBeanFactory.createUserService();

        userService.deleteUser(1);
        userService.addUser();
        userService.updateUser();
    }
}

测试结果如下所示：

开启事务
通过id删除用户
提交事务
<=====================>
开启事务
添加用户
提交事务
<=====================>
开启事务
更新用户
提交事务
<=====================>

从测试结果可以看出，每次在执行业务代码的时候，会拦截对应的方法，执行切面类。

重点：JDK 的动态代理是通过接口和实现类完成的。

在 debug 测试函数： UserService userService = MyBeanFactory.createUserService();可以看出直接得到的是代理对象，代理对象中就有实现的功能。

在 debug 测试函数：UserService userService = new UserServiceImpl();可以看出直接得到的是其实现类，没有代理。

感兴趣的同学可以将测试函数中代码替换成上面两种。看看测试结果，以便于更好理解 AOP 思想。

3、AOP 中通过 CGlib 动态代理简单案例演示

public class StudentService {

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

    void add() {
        System.out.println("添加用户");
    }

    void update() {
        System.out.println("更新用户");
    }
}

public class MyBeanFactory {

    //  CGlib实现代理
    public static StudentService createStudentService(){
        //1.创建目标对象target
        final StudentService studentService = new StudentService();

        //2.声明切面类对象
        final MyAspect aspect = new MyAspect();

        //3.创建增强对象
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(studentService.getClass());
        //设置回调【拦截】
        enhancer.setCallback((MethodInterceptor) (proxy, method, args, methodProxy) -> {

            aspect.before();

            Object retObj = methodProxy.invokeSuper(proxy,args);//解藕
            System.out.println("拦截.....");

            aspect.after();
            return retObj;
        });

        //创建代理对象
        StudentService serviceProxy = (StudentService) enhancer.create();
        //System.out.println("serviceProxy);
        return serviceProxy;
    }
}

测试函数

public class AOPTest {

    public static void main(String[] args) {
        StudentService studentService = MyBeanFactory.createStudentService();
        studentService.add();
        System.out.println("<=====================>");
        studentService.delete();
        System.out.println("<=====================>");
        studentService.update();
        System.out.println("<=====================>");
    }
}

测试结果如下所示：

开启事务
添加用户
拦截.....
提交事务
<=====================>
开启事务
删除用户
拦截.....
提交事务
<=====================>
开启事务
更新用户
拦截.....
提交事务
<=====================>

CGlib 代理重点总结

a、没有接口，只有实现类。
b、采用字节码增强框架 cglib，在运行时 创建目标类的子类，从而对目标类进行增强。