Spring AOP的使用（基于传统动态代理）

什么是AOP？

专业术语：

	AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和
	运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个
	热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑
	的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高
	了开发的效率。

想要详细了解建议去看这位大牛的文章----【SpringBoot-3】

简单来说AOP的核心思想就是把一个类中那些不重要的部分切出去或者说拆出去，做成一个切面，然后在需要使用的时候再把切面加上去。

动态代理是JAVA的JDK给我们提供的一种机制，为什么会有这种机制呢？是因为JAVA本身运行就是基于代理的，JAVA有虚拟机，JAVA所有的类都是交给虚拟机运行的，这个过程就是一种代理。代码在运行时，每一个类和每一个方法的运行都是被虚拟机代理的。

---

动态代理的实现

1、实现一个代理类

下方的代码是实现代理类的简单流程：

• 代理类的创建，首先需要实现InvocationHandler接口
• 类中定义一个Object属性，在后续使用代理类的时候，可以用来转换为各种类，因为Object类是所有类的父类。
• invoke方法里就包括被代理的类中的方法，方法中的method参数就是被invoke方法代理的类中的方法，为了方便能够获取代理类，最后再把这个类return出去。

//代理类的写法
//需要这个类能够代理别人，需要实现这个接口，调用InvocationHandler句柄
public class ProxyDemo implements InvocationHandler {
   

    private Object object;

    //传入需要被代理的类（object）
    public ProxyDemo(Object object){
   
        this.object = object;
    }

    //invoke方法里就包括被代理的类中的方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   

        //这里就是实现AOP的核心思想，面向切面编程，我们可以把切面代码写到这个地方
        //因为在这里添加切面后，后续只要使用这个代理类的方法，都会远行切面，就比如说日志功能

        beforeAdvice();//实现AOP思想，beforeAdvice作为一个切面切入

        //method参数就是被invoke方法代理的类中的方法
        //运行代理对象的方法
        Object proxyObject = method.invoke(object,args);
        return proxyObject;
    }
    //前置通知
    public void beforeAdvice(){
   
        //模拟一下日志功能
        System.out.println("前置建议：日志记录");
    }
}

---

2、使用代理类

假如我现在想要获取AccountDAO的代理类并调用insert方法，获取代理类的方式如下：

package org.csu.spring.demo.aop.test;

import org.csu.spring.demo.aop.persistence.AccountDAO;
import org.csu.spring.demo.aop.persistence.AccountDAOImpl;
import org.csu.spring.demo.aop.proxy.ProxyDemo;
import org.junit.Test;

import java.lang.reflect.Proxy;

public class Demo {
   

    @Test
    public void test(){
   
        AccountDAO accountDAO = new AccountDAOImpl();

        //获得类的原型 class1 获得了accountDAO类的原型，因为类最终是以.class文件形式存在的
        Class class1 = accountDAO.getClass();
        //虚拟机提供的反射Proxy，new一个代理出来。三个参数分别是一个加载器，还需要一个类的接口，最后需要一个代理的对象
        Object object = Proxy.newProxyInstance(class1.getClassLoader(),class1.getInterfaces(),new ProxyDemo(accountDAO));
        //把代理的对象，强制转换成被代理对象，后面使用这个对象的就是通过代理执行的
        accountDAO = (AccountDAO)object;
        //这个时候使用的对象，就是被代理之后的对象
        accountDAO.insert();

    }
}

获取代理类的核心就是这四条代码

---

但是这样使用代理类，怎么反映了AOP的思想？

AOP的思想就是把一个类中那些不重要的部分切出去或者说拆出去，做成一个切面，然后在需要使用的时候再把切面加上去。

再看看我们的代理类的实现代码，哪里可以体现AOP的思想？

当我们想调用被代理的对象的方法，我们实际上执行的是这串代码
Object proxyObject = method.invoke(object,args);

但是在invoke方法中，我们还有上下个地方（分为前置通知和后置通知）可以自由的添加方法，而我们正可以把那些经常用到，但是不是很重要的方法放在这两个地方。就比如说日志记录，我们很多地方都需要使用它，但是在每次调用时都需要新建一个日志记录的对象，会较为麻烦。所以我们采取动态代理的方式来简化代码。

运行一个类例子

对比一下直接accountDAO对象的insert方法和使用代理对象accountDAO的insert方法，我们看看输入结果。


不难看出同样是account.insert()方法。通过动态代理的方式，可以在代理运行insert方法时（不止是insert方法，只要是类中存在的方法都会在之前运行我们添加的方法），在之前还能加入其他的方法，这就可以体现出AOP的思想。

---

我们使用Spring AOP可以帮我们简化动态代理的过程

Spring AOP的实现(传统动态代理)

---

1、导入spring-aop依赖

在pom.xml文件中加入spring-aop的依赖

	 <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
<!--      spring依赖的版本都需要相同-->
      <version>5.2.4.RELEASE</version>
    </dependency>

---

2、创建切面

通过实现spring给我们提供的切面，spring给我们提供了很多种类的接口，比如：BeforeAdvice接口，意思是后置建议，在所代理的类中的方法实现后再实现我们添加的方法。而这里我们使用的是AfterReturningAdvice（在一个方法返回后的一个建议，或者说一个切面）

package org.csu.spring.demo.aop.proxy;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class SpringAOPProxyDemo implements AfterReturningAdvice {
   
    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
   
        System.out.println("后置建议：日志记录.....");
    }
}

---

3、配置xml文件