Spring系列之面向切面编程-15

面向方面编程 (AOP) 通过提供另一种思考程序结构的方式来补充面向对象编程 (OOP)。OOP 中模块化的关键单元是类，而 AOP 中模块化的单元是方面。

AOP 概念

• Aspect：切面，即一个横跨多个核心逻辑的功能，或者称之为系统关注点；
• Joinpoint：连接点，即定义在应用程序流程的何处插入切面的执行；
• Pointcut：切入点，即一组连接点的集合；
• Advice：增强，指特定连接点上执行的动作；
• Introduction：引介，指为一个已有的Java对象动态地增加新的接口；
• Weaving：织入，指将切面整合到程序的执行流程中；
• Interceptor：拦截器，是一种实现增强的方式；
• Target Object：目标对象，即真正执行业务的核心逻辑对象；
• AOP Proxy：AOP代理，是客户端持有的增强后的对象引用。

AOP 代理

Spring AOP 默认为 AOP 代理使用标准 JDK 动态代理。这使得任何接口（或一组接口）都可以被代理。

Spring AOP 也可以使用 CGLIB 代理。这是代理类而不是接口所必需的。默认情况下，如果业务对象未实现接口，则使用 CGLIB。由于对接口而不是类进行编程是一种很好的做法，因此业务类通常实现一个或多个业务接口。在那些（希望很少见）需要建议未在接口上声明的方法或需要将代理对象作为具体类型传递给方法的情况下，可以 强制使用 CGLIB

@AspectJ 支持

@AspectJ 指的是一种将切面声明为带有注解的常规 Java 类的风格。

启用@AspectJ 支持

要在 Spring 配置中使用 @AspectJ 方面，您需要启用 Spring 支持以基于 @AspectJ 方面配置 Spring AOP，并根据这些方面是否建议它们来自动代理 bean。通过自动代理，我们的意思是，如果 Spring 确定一个 bean 由一个或多个方面通知，它会自动为该 bean 生成一个代理来拦截方法调用并确保根据需要运行通知。

可以使用 XML 或 Java 样式的配置启用 @AspectJ 支持。

使用 Java 配置启用 @AspectJ 支持

要使用 Java 启用 @AspectJ 支持@Configuration，请添加@EnableAspectJAutoProxy 注释，如以下示例所示：

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {

}

通过 XML 配置启用 @AspectJ 支持

要使用基于 XML 的配置启用 @AspectJ 支持，请使用该aop:aspectj-autoproxy 元素，如以下示例所示：

<aop:aspectj-autoproxy/>

声明一个方面

作用是把当前类标识为一个切面供容器读取。

这两个示例中的第一个显示了应用程序上下文中的常规 bean 定义，它指向具有@Aspect注释的 bean 类：

<bean id="myAspect" class="org.xyz.NotVeryUsefulAspect">
    <!-- configure properties of the aspect here -->
</bean>

两个示例中的第二个显示了NotVeryUsefulAspect类定义

package org.xyz;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class NotVeryUsefulAspect {

}

请注意， @Aspect注释不足以在类路径中进行自动检测。为此，您需要添加一个单独的@Component注释

声明切入点

切入点确定连接点，从而使我们能够控制建议何时运行。

以下示例定义了一个名为的切入点anyOldTransfer，它与任何名为 transfer的方法的执行相匹配：

@Pointcut("execution(* transfer(..))") // the pointcut expression
private void anyOldTransfer() {} // the pointcut signature

execution函数用于匹配方法执行的连接点，语法为：

execution(方法修饰符(可选) 返回类型 方法名 参数 异常模式(可选))

参数部分允许使用通配符：

* 匹配任意字符，但只能匹配一个元素

… 匹配任意字符，可以匹配任意多个元素，表示类时，必须和*联合使用

+ 必须跟在类名后面，如Horseman+，表示类本身和继承或扩展指定类的所有类

示例中的* transfer(…)解读为：

方法修饰符 无

返回类型 *匹配任意数量字符，表示返回类型不限

方法名 transfer表示匹配名称为transfer的方法

参数 (…)表示匹配任意数量和类型的输入参数

异常模式 不限

声明通知

Advice 与切入点表达式相关联，并在切入点匹配的方法执行之前、之后或周围运行。切入点表达式可以是对命名切入点的简单引用，也可以是就地声明的切入点表达式。

Spring AOP 包括以下类型的通知：

• @Before：这种拦截器先执行拦截代码，再执行目标代码。如果拦截器抛异常，那么目标代码就不执行了；
• @After：这种拦截器先执行目标代码，再执行拦截器代码。无论目标代码是否抛异常，拦截器代码都会执行；
• @AfterReturning：和@After不同的是，只有当目标代码正常返回时，才执行拦截器代码；
• @AfterThrowing：和@After不同的是，只有当目标代码抛出了异常时，才执行拦截器代码；
• @Around：能完全控制目标代码是否执行，并可以在执行前后、抛异常后执行任意拦截代码，可以说是包含了上面所有功能。

实例化切面

默认情况下，应用程序上下文中的每个方面都有一个实例。

例子

我们定义一个LoggingAspect：

@Aspect
@Component
public class LoggingAspect {
    // 在执行UserService的每个方法前执行:
    @Before("execution(public * com.itranswarp.learnjava.service.UserService.*(..))")
    public void doAccessCheck() {
        System.err.println("[Before] do access check...");
    }

    // 在执行MailService的每个方法前后执行:
    @Around("execution(public * com.itranswarp.learnjava.service.MailService.*(..))")
    public Object doLogging(ProceedingJoinPoint pjp) throws Throwable {
        System.err.println("[Around] start " + pjp.getSignature());
        Object retVal = pjp.proceed();
        System.err.println("[Around] done " + pjp.getSignature());
        return retVal;
    }
}

观察doAccessCheck()方法，我们定义了一个@Before注解，后面的字符串是告诉AspectJ应该在何处执行该方法，这里写的意思是：执行UserService的每个public方法前执行doAccessCheck()代码。

再观察doLogging()方法，我们定义了一个@Around注解，它和@Before不同，@Around可以决定是否执行目标方法，因此，我们在doLogging()内部先打印日志，再调用方法，最后打印日志后返回结果。

在LoggingAspect类的声明处，除了用@Component表示它本身也是一个Bean外，我们再加上@Aspect注解，表示它的@Before标注的方法需要注入到UserService的每个public方法执行前，@Around标注的方法需要注入到MailService的每个public方法执行前后。

紧接着，我们需要给@Configuration类加上一个@EnableAspectJAutoProxy注解：

@Configuration
@ComponentScan
@EnableAspectJAutoProxy
public class AppConfig {
    ...
}

使用注解装配AOP

在实际项目中，这种写法其实很少使用execution(* xxx.Xyz.*(..))语法来定义应该如何装配AOP。

因为，基本能实现无差别全覆盖，即某个包下面的所有Bean的所有方法都会被方法拦截。

我们在使用AOP时，要注意到虽然Spring容器可以把指定的方法通过AOP规则装配到指定的Bean的指定方法前后，但是，如果自动装配时，因为不恰当的范围，容易导致意想不到的结果，即很多不需要AOP代理的Bean也被自动代理了，并且，后续新增的Bean，如果不清楚现有的AOP装配规则，容易被强迫装配。

使用AOP时，被装配的Bean最好自己能清清楚楚地知道自己被安排了。例如，Spring提供的@Transactional就是一个非常好的例子。如果我们自己写的Bean希望在一个数据库事务中被调用，就标注上@Transactional：

@Component
public class UserService {
    // 有事务:
    @Transactional
    public User createUser(String name) {
        ...
    }

    // 无事务:
    public boolean isValidName(String name) {
        ...
    }

    // 有事务:
    @Transactional
    public void updateUser(User user) {
        ...
    }
}

因此，装配AOP的时候，使用注解是最好的方式。

@Target(METHOD)
@Retention(RUNTIME)
public @interface MetricTime {
    String value();
}

在需要被监控的关键方法上标注该注解：

@Component
public class UserService {
    // 监控register()方法性能:
    @MetricTime("register")
    public User register(String password, String name) {
        ...
    }
    ...
}

然后，我们定义MetricAspect：

@Aspect
@Component
public class MetricAspect {
    @Around("@annotation(metricTime)")
    public Object metric(ProceedingJoinPoint joinPoint, MetricTime metricTime) throws Throwable {
        String name = metricTime.value();
        long start = System.currentTimeMillis();
        try {
            return joinPoint.proceed();
        } finally {
            long t = System.currentTimeMillis() - start;
            // 写入日志或发送至JMX:
            System.err.println("[Metrics] " + name + ": " + t + "ms");
        }
    }
}

注意metric()方法标注了@Around("@annotation(metricTime)")，它的意思是，符合条件的目标方法是带有@MetricTime注解的方法，因为metric()方法参数类型是MetricTime（注意参数名是metricTime不是MetricTime），我们通过它获取性能监控的名称。

有了@MetricTime注解，再配合MetricAspect，任何Bean，只要方法标注了@MetricTime注解，就可以自动实现性能监控。