【SSM-笔记】Spring AOP 详讲，面向切面编程

绪论：

AOP最好了解代理模式（静态代理，动态代理（JDK动态代理、CGLIB动态代理））后再去学会如何使用，我觉得可能效率会比较高吧。
还有就是本篇大部分都是老杜的Spring笔记，少部分自身理解。
代理模式可以看看篇：代理模式，挺全的。
结尾我也会给出老杜的 Spring 笔记。

👀AOP的概述

AOP（Aspect-Oriented-Programing）面向切面编程。它是Spring的重要思想之一。

引入 AOP

小编就知道，Java是一种面向对象（OOP，Object-Oriented-Programing）的编程语言。使用静态代理去处理拓展业务功能时就能很好的体现出来。当我们使用继承去实现拓展某个业务的时候（比如有时候业务需要记录日志，需要统计什么东西，需要事务管理时），代码会存在冗余，而且因为存在继承关系，所以存在高耦合，而且业务操作不是单个的，有多少个业务操作，就要有多少个重复代码（记录日志，统计，事务管理等）。显然是不利于维护的。

（可能有人说将这些公告代码写成方法不就好了？但是不是还是需要程序员去调用吗，所以小编觉得仍不够好，仍然存在重复代码。）

于是有了AOP，AOP将权限校验、日志记录等非业务代码完全提取出来，与业务代码分离，并寻找结点切入到代码中。

👀面向切面编程之七大术语

• 连接点 Joinpoint
  在程序的整个执行流程中，可以织入切面的位置，方法的执行前后，异常抛出之后等位置。连接点描述的是位置，切入点。

• 切点 Pointcut
  在程序执行流程中，真正织入切面的方法（一个切点可以对应多个连接点）。切点描述的是方法。（在哪个方法上切，描述的就是这个）

• 通知 Advice
  通知又叫做增强，就是具体要织入的代码。通知描述的是代码。
  通知包括：

  1. 前置通知（方法前）@Before
  2. 后置通知（方法后）@AfterReturning
  3. 环绕通知（方法前后都有）@Around
  4. 异常通知（放在 catch 语句块中）@AfterThrowing
  5. 最终通知（放在 finally 语句块中）@After

• 切面 Aspect
  切点 + 通知就是切面。（方法加上通知要织入的代码形成的面及为切面）

• 织入 Weaving
  把通知应用到目标对象的过程。

• 代理对象 Proxy
  一个目标对象被织入通知后产生的新对象。

• 目标对象 Target
  被织入通知的对象。

（代理对象和目标对象是指代理模式中的相应角色）

下面很好的描述AOP四个主要的术语：

我觉得这样理解七大术语算具体的了，看官方或者书籍资料给的解释还得花时间去理解概念。

👀切点表达式（重要）

切点肯定是需要指定的，可以通过 表达式或者模式 指定切入点 Pointcut。

切点表达式即用来定义通知（Advice）往哪些方法上切入。

切入点表达式的语法格式

execution([访问控制权限修饰符] 返回值类型 [全限定类名]. 方法名(形式参数列表) [异常])
[] 中的内容属于可选项

• 访问控制权限修饰符（可选项，没写就是4个权限都包括）

• 返回值类型（必填项，* 表示返回值类型任意）

• 全限定类名（可选项，“…”代表当前包以及子包下的所有类，省略则表示所有的类）

• 方法名（必填项，* 表示所有的方法，set*表示所有的set方法）

• 形式参数列表

1. 必填项；
2. ()表示没有参数列表；
3. (. .)表示参数类型和个数随意的方法;
4. (*)表示只有一个参数的方法；
5. ( *,String)表示第一个参数随意，第二个参数必须是String类型的。

• 异常（可选项，省略时表示任意异常类型）

注意：返回值类型、方法名、形式参数列表是必填项。类名和方法是点连接起来的。

举例：

这个表示：service包下的所有公开的delete方法（参数和返回值任意）
execution(public * com.powernode.mall.service.*.delete*(..))

这个表示：mall 包下的所有类的所有方法
execution(* com.powernode.mall.*(..))

这个表示：所有类的所有方法
execution(* *(..))

👀AOP的实现

Spring常用的AOP实现有俩种方式：

1. Spring框架结合AspectJ框架实现的AOP，基于注解的方式。（使用较普遍）
2. Spring框架结合AspectJ框架实现的AOP，基于XML方式。

AspectJ概述

Eclipse组织的一个支持AOP的框架。AspectJ框架是独立于Spring框架之外的一个框架，Spring框架用了AspectJ。

五大通知测试

首先你想要利用Spring去实现AOP，那么目标对象，和代理所需执行的通知对象肯定是要暴露给Spring的，不然它咋实现呢？所以这一过程中仍然是需要使用DI的。

为实现AOP，最重要的就是确定好切点和通知。切面=切点+通知。可以使用AspectJ框架下的注解@Aspect对切面类进行标注，以提示Spring该类存在很多个切面实现。

切点可以利用切点表达式进行确认，通知即是要写的代码，而切入点的位置就是通知的位置，用那通知五大注解即可（@Before、@AfterReturning、@Around、@AfterThrowing、@After）

测试先提供个目标类

@Service
public class OrderService {
	// 测试用来做切面
    public void order(){
        System.out.println("正在进行订单");
    }
}

测试程序

	@Test
    public void testAopByAnnotation(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
        orderService.order();
    }

• @Before测试

@Component
@Aspect // 切面类是需要使用@Aspect注解进行标注的。
public class LogAspect {// 切面

    private final Logger logger = Logger.getLogger(Logger.class);

    @Before("execution(* com.ncpowernode.spring6.service.OrderService.order(..))")
    public void beforeAdvice(){
        logger.info("订单之前进行的操作~");
    }

}

• @AfterReturning

@AfterReturning("execution(* com.ncpowernode.spring6.service.OrderService.order(..))")
    public void afterAdvice(){
        logger.info("订单之后进行的操作");
    }

• @Around

环绕通知需要传入一个连接点对象 ProceedingJoinPoint，以便告诉Spring 哪个是切点前的通知，哪个是后的。

@Around("execution(* com.ncpowernode.spring6.service.OrderService.order(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 前通知
        logger.info("订单前");
        // 切点程序
        joinPoint.proceed();
        // 后通知
        logger.info("订单后");
    }

• @AfterThrowing

该通知对应的是catch语句块；

下面给OrderService类中添加段语句测试一下

@AfterThrowing("execution(* com.ncpowernode.spring6.service.OrderService.order(..))")
    public void exceptionAdvice(){
        logger.error("出现异常");
    }

• @After

@After("execution(* com.ncpowernode.spring6.service.OrderService.order(..))")
    public void finallyAdvice(){
        logger.info("finally内执行语句");
    }

可以简单推断代理过程是 try-catch-finally 的形式的。

切面顺序（@Order注解）

日常项目中可能不止存在一个切面类，比如可能会有日志切面类、安全切面类、事务控制切面类等等。但如果业务中同时使用俩个及以上的切面类呢？执行顺序是怎样的呢？

下面是@Order注解的源代码，里面有个int类型的value属性，默认值是Integer.MAX_VALUE整型最大值。

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
@Documented
public @interface Order {
    int value() default Integer.MAX_VALUE;
}

通过@Target元注解可以知道，该@Order注解可以出现的位置。

LogAspect 切面类 + SecurityAspect 切面类进行测试。

下面是SecurityAspect 类的代码

@Aspect
@Component
@Order(1)
public class SecurityAspect {

    private final Logger logger = Logger.getLogger(SecurityAspect.class);

    @Before("execution(* com.ncpowernode.spring6.service.OrderService.order(..))")
    public void beforeAdvice(){
        logger.info("安全前置通知");
    }

}

下面是LogAspect 类的代码

@Component
@Aspect // 切面类是需要使用@Aspect注解进行标注的。
@Order(2)
public class LogAspect {

	private final Logger logger = Logger.getLogger(Logger.class);

	@Before("execution(* com.ncpowernode.spring6.service.OrderService.order(..))")
    public void beforeAdvice(){
        logger.info("订单之前进行的操作");
    }
}

@Order 注解中 value 值小的先执行。

通用切点（@Pointcut注解）

为了使得通用表达式得到复用，可以使用@Pointcut注解让某个方法表示通用切点表达式。

下面是@Pointcut注解的源码。（通过@Target元注解可以知道仅能用在方法上）

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Pointcut {
    String value() default "";

    String argNames() default "";
}

测试

在另一个切面类中也可以使用通用切点表达式。

全注解形式

这里需要使用三个注解（都只能用在类上）：

1. @Configuration注解（用来替代xml文件）
2. @ComponentScan注解（用来扫描注解，其中value属性值是指定的扫描包）
3. @EnableAspectJAutoProxy（使用AspectJ框架实现AOP，可以设置proxyTargetClass 属性值为true，表示只用CGLIB动态代理）

类名无所谓，下面举例

@Configuration
@ComponentScan("com.ncpowernode.spring6.service")
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class Spring6Config {
}

测试程序，现在实例化的是AnnotationConfigApplicationContext对象了，然后向上转型为ApplicationContext对象。

@Test
    public void testNoXml(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Spring6Config.class);
        OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
        orderService.order();
    }

测试结果

👀XML配置实现

不管是注解配置还是xml配置文件的方式进行配置，都是根据下面的步骤：

1. 首先是确定目标对象，然后确定切面类（同时排好切面类的执行顺序，用@Order注解）
2. 将目标类和切面类（用@Aspect注解标注了的）暴露给Spring容器。
3. 确定切面，切面=切点+通知。切点利用切点表达式进行设置，通知即对应着切面类中的方法。

下面给出个案例配置然后执行测试

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="registeService" class="com.ncpowernode.spring6.xml.service.RegisteService"/>
    <bean id="registeAspect" class="com.ncpowernode.spring6.xml.service.RegisteAspect"/>

    <aop:config>
        <!--切点表达式-->
        <aop:pointcut id="mypointcut" expression="execution(* com.ncpowernode.spring6.xml.service.RegisteService.registe(..))"/>
        <!--切面：通知 + 切点-->
        <aop:aspect ref="registeAspect">
            <aop:around method="around" pointcut-ref="mypointcut"/>
        </aop:aspect>
    </aop:config>


</beans>

👀总结

老杜的Spring笔记
密码：mg9b

还借用了骆驼整理说博客中的图片。骆驼整理说是小编最近比较喜欢的一位博主。
骆驼整理说的主页