Spring5学习（六）——面向切面编程AOP

---

一、什么是AOP？

答：通过预编译方式和运行期动态代理实现程序功能统一维护的一种技术。
第一次看完这句话我也没理解他是干嘛的，下面我将按我的理解进行解释。

• 什么是代理？
  以房屋中介为例，房屋中介帮房主挂买房信息出售房屋，即房屋中介代理房主去做房屋出售的工作，同时中介还有有例如收取中介费等业务。也就说说，一个代理角色（中介），代理了一个真实角色（房主），房主只进行出售房屋（出售的房屋为抽象角色，可用接口/抽象类实现），但中介可以可以代理房主进行房屋出售，还能收取代理费、出售费用（代理类中还可以有其他方法。）

所以使用代理的目的：让真实角色的操作更纯粹（即房主只出售房屋），不用处理一些公共事务（即房屋出售费用），公共事务交给代理（中介）。实现业务分工，降低耦合性。若公共事务发生扩建，方便集中于代理类中管理。例如：想要对一个类增加操作，为了尽量不修改源代码的原则，则可以使用代理实现。

• 代理分类
  静态代理：对于一个真实角色就需要产生一个代理，n个真实角色就需要n个代理，代码量增加。
  动态代理：代理类是动态生成的，可代理一类业务，即可代理同一个接口的多个类。

所以，AOP可以通过预编译方式和运行其动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。

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

二、采用Spring配置文件.xml实现AOP

1）目标：在目标对象类调用的方法的前后分别加入日志。

2）做法：想用一个代理去帮目标对象（业务逻辑）去实现日志功能，而不是在目标对象的代码中实现日志功能。从而降低代码的耦合性，让业务逻辑代码仅做业务。若修改日志代码也不会影响业务逻辑代码。

3）此时：

• 横切关注点：即跨越应用程序多个模块的方法或功能。为前置日志、后置日志的方法。
• 切面：即日志类。
• 通知：日志类中的日志方法。
• 目标：被通知的对象，即目标对象。
• 代理：通知目标对象之后船舰的对象。
• 切入点：切面通知执行的位置，即目标对象的实体类。
• 连接点：与切入点匹配的执行点。

1. 导入包

利用maven导入aspectjweaver包

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

2. 给定一个目标对象接口UserService

public interface UserService {
    public void add();
    public void delete();
    public void updata();
    public void select();
}

3. 给定一个目标对象的实现类UserServiceImple

public class UserServiceImple implements UserService{
    @Override
    public void add() {
        System.out.println("add user");
    }

    @Override
    public void delete() {
        System.out.println("delete user");

    }

    @Override
    public void updata() {
        System.out.println("updata user");
    }

    @Override
    public void select() {
        System.out.println("select user");
    }
}

4.在.xml文件中实现AOP

• 创建applicationContext.xml文件，并进行如下配置。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

</beans>

1）使用Spring中的API接口实现

• 1.创建目标类方法点调用前的日志类BeforeLog

import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;

public class BeforeLog implements MethodBeforeAdvice {
    //target:目标对象，需要被代理的对象 args：参数  method：目标对象的方法
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行");
    }

• 2.创建目标类方法点调用后的日志类BeforeLog

import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"返回了"+returnValue);
    }
}

• 3.配置.xml文件

	<!-- 注册bean,对一个类创建对象 -->
    <bean id="userService" class="com.ali.service.UserServiceImple"></bean>
    <bean id="beforeLog" class="com.ali.log.BeforeLog"></bean>
    <bean id="afterLog" class="com.ali.log.AfterLog"></bean>

	<!-- 方法一：使用原生的Spring API接口 -->
	<!-- 配置AOP：导入aop约束 -->
    <aop:config>
		<!--  切入点 execution（返回值类型 切入的对象）*表示全部 -->
        <aop:pointcut id="pointcut" expression="execution(* com.ali.service.UserServiceImple.*(..))"/>
		<!-- 执行环绕增强 -->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"></aop:advisor>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"></aop:advisor>

    </aop:config>

2）使用自定义切面的方式，调用切面的通知实现

切面：日志类
切面的通知：日志类中的方法

• 1.自定义的切面Log类

public class Log {
    public void before(){
        System.out.println("=====方法使用前=====");
    }

    public void after() {
        System.out.println("=====方法使用后=====");
    }
}

• 2.配置.xml文件

	<!-- 方法二：自定义切面类 -->
    <bean id="diyLog" class="com.ali.log.Log"></bean>
    <aop:config>
	<!--  自定义切面，ref引用 -->
        <aop:aspect ref="diyLog">
			<!-- 切入点：切面通知需要执行的位置 -->
            <aop:pointcut id="point" expression="execution(* com.ali.service.UserServiceImple.*(..))"/>
			<!-- 通知 -->
            <aop:before method="before" pointcut-ref="point"></aop:before>
            <aop:after method="after" pointcut-ref="point"></aop:after>
        </aop:aspect>
    </aop:config>

3）使用注解实现

• 1.创建一个切面AnnotationLog类

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect  // 使用注解
public class AnnotationLog {

    @Before("execution(* com.ali.service.UserServiceImple.*(..))")
    public void before(){
        System.out.println("=====方法使用前=====");
    }

    @After("execution(* com.ali.service.UserServiceImple.*(..))")
    public void after() {
        System.out.println("=====方法使用后=====");
    }

    @Around("execution(* com.ali.service.UserServiceImple.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("=====环绕前=====");
        Object proceed = jp.proceed();
        System.out.println("=====环绕后=====");
    }
}

• 2.配置.xml文件

	<!-- 方法三：注解实现 -->
    <bean id="annotationLog" class="com.ali.log.AnnotationLog"></bean>
	<!-- 开启注解支持 proxy-target-class:默认false指基于JDK的动态代理,ture为基于类的cglib动态代理 -->
    <aop:aspectj-autoproxy proxy-target-class="false"></aop:aspectj-autoproxy>

4. 测试

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 动态代理代理的是接口
        UserService userService = context.getBean("userService", UserService.class);
        userService.delete();
    }
}