Spring之AOP

什么是AOP

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

主要功能：

日志记录、性能统计、安全控制、事务处理、异常处理等

主要意图：

将 日志记录、性能统计、安全控制、事务处理、异常处理 等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

举个例子，简单来说我们想要给某个业务逻辑的类加上日志功能，之前可以通过动态代理来实现，现在是通过Spring中的AOP来实现

AOP在Spring中的应用

首先先来看一些关键词：

• 横切关注点：跨越应用程序多个模块的方法和功能。即是，与业务逻辑无关的，但是需要关注的部分，就是横切关注点。如日志、安全、缓存、事务等。【就是一个功能】

• 切面（ASPECT）：横切关注点被模块化的特殊对象，它是一个类【如日志类】

• 通知（Advice）：切面必须要完成的工作，它是一个方法【比如日志类中的方法】

• 目标（Target）：被通知的对象【比如把日志类中方法加到这里面】

• 代理（Proxy）：向目标对象应用通知之后创建的对象【代理对象】

• 切入点（PointCut）：切面通知执行的“地点”的定义

• 连接点（JointPoint）：与切入点匹配的执行点

SPringlAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice

Spring实现AOP

想要使用AOP，需要导入依赖

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
    <scope>runtime</scope>
</dependency>

场景：我们有一个业务逻辑是增删查改的接口，我们希望给实现这个接口的类的方法前后都加上日志。类和接口如下

package com.wang.service;
​
public interface UserService {
    public void add();
    public void delete();
    public void select();
    public void update();
}

package com.wang.service;
​
public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }
​
    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }
​
    @Override
    public void select() {
        System.out.println("查找了一个用户");
    }
​
    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }
}
​

AOP实现方式一：使用Spring的API接口

1. 新建一个Log日志类，这个类要实现MethodBeforeAdvice接口，用来在原有方法前面加日志

   这个接口有一个方法before，它的参数分别是：

   Method ：要执行的目标对象的方法，业务逻辑方法

   args：参数

   target：目标对象，业务逻辑方法所在的类

   这个方法会在我们的业务逻辑方法执行之前，自动执行，在这个方法中我们可以给它加上日志功能。

   package com.wang.log;
   ​
   import org.springframework.aop.MethodBeforeAdvice;
   ​
   import java.lang.reflect.Method;
   ​
   public class Log implements MethodBeforeAdvice {
       @Override
       public void before(Method method, Object[] args, Object target) throws Throwable {
           System.out.println(target.getClass().getName()+"的"+method.getName()+"方法执行前！！！");
       }
   }

2. 再写一个日志类，作为后置日志，它要实现AfterReturnAdvice接口，这个接口的方法和上面一样，只是多了一个参数，这个参数是返回的值

   package com.wang.log;
   ​
   import org.springframework.aop.AfterReturningAdvice;
   ​
   import java.lang.reflect.Method;
   ​
   public class AfterLog implements AfterReturningAdvice {
       @Override
       public void afterReturning(Object returnvalue, Method method, Object[] objects, Object target) throws Throwable {
           System.out.println(target.getClass().getName()+"的"+method.getName()+"方法执行后，返回的值是："+returnvalue);
       }
   }

3. 把这些类，都注册到Spring中

   <bean id="userService" class="com.wang.service.UserServiceImpl"/>
   <bean id="log" class="com.wang.log.Log"/>
   <bean id="afterLog" class="com.wang.log.AfterLog"/>

4. 配置AOP，前提需要导入AOP约束

   导入约束

   xmlns:aop="http://www.springframework.org/schema/aop
   "http://www.springframework.org/schema/aop
    https://www.springframework.org/schema/aop/spring-aop.xsd"

   配置AOP

   首先需要一个切入点（在哪个地方执行），标签aop:pointcut，属性id（标识符），属性expression（表达式，这里为固定的表达式execution() 代表要执行的位置 ）

   execution(修饰词 返回值 类名 方法名 参数)，可以用 * 代替

   execution(* com.wang.service.UserServiceImpl.*(..))

   <!--定义切入点-->
   <aop:pointcut id="point" expression="execution(* com.wang.service.UserServiceImpl.*(..))"/>

   然后是选择要执行的日志类，叫做执行环绕增强，是把哪个日志类切入到哪个切入点，即哪个方法

   <aop:advisor advice-ref="log" pointcut-ref="point"/>
   <aop:advisor advice-ref="afterLog" pointcut-ref="point"/>

5. 测试

   public void test01(){
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
       UserService userService = (UserService) context.getBean("userService");
   ​
       userService.add();
   }

   

    

AOP实现方式二：自定义类实现AOP

需要自定义一个日志类

package com.wang.log;
​
public class MyPointCut {
    public void before(){
        System.out.println("xxxx方法执行前");
    }
    public void after(){
        System.out.println("xxxx方法执行后");
    }
}

在xml文件中注册这个日志类

配置切面，自定义切面，使用 aop:aspect标签，ref是你自己引用的类

在这个标签内，使用 aop:pointcut 定义切入点，和上面一样

aop:before 标签是在业务逻辑方法前面加日志，属性method就是日志类中的方法，属性point-ref是定义的切入点，aop:after 标签同理

<aop:config>
    <aop:aspect ref="myPointCut">
        <aop:pointcut id="point" expression="execution(* com.wang.service.UserServiceImpl.*(..))"/>
        <aop:before method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>

测试和上面一样

这种方式没有第一种方式强大，没有办法去操作类中的一些内容，比如：获得类的名字，方法的名字

AOP实现方式三：注解实现AOP

定义一个类，在这个类上使用注解@Aspect来修饰这个类，用来标注这个类是一个切面

定义一个方法，如果要在业务逻辑方法前面加日志，就要用@Before来修饰，在这个注释里面要定义一个切入点，和上面一样.

package com.wang.log;
​
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
​
@Aspect    //用来标记这个类是切面
public class AnnoPointCut {
​
    @Before("execution(* com.wang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("====方法执行前=====");
    }
​
    @After("execution(* com.wang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("====方法执行后=====");
    }
}

在xml配置文件中，注册这个类，并且开启这个注解支持

<bean id="annoPoint" class="com.wang.log.AnnoPointCut"/>
<!--    开启注解支持，默认值JDK，属性proxy-target-class=“false”   基于类的是cglib，参数是true-->
<aop:aspectj-autoproxy />

之前只是使用了 before 和after 这两个

还有一个叫做环绕增强，使用这个我们可以给定一个参数，代表我们要获取处理切入的点

使用@Around 来修饰