标题有点标题党了，这里说的容易犯错不是Spring AOP的错，是指使用的时候容易犯错。本文会以一些例子来展开讨论AOP的使用以及使用过程中容易出错的点。
几句话说清楚AOP
有关必要术语：
- 切面：Aspect，有的地方也叫做方面。切面=切点+增强，表示我们在什么点切入蛋糕，切入蛋糕后我们以什么方式来增强这个点。
- 切点：Pointcut，类似于查询表达式，通过在连接点运行查询表达式来寻找匹配切入点，Spring AOP中默认使用AspjectJ查询表达式。
- 增强：Advice，有的地方也叫做通知。定义了切入切点后增强的方式，增强方式有前、后、环绕等等。Spring AOP中把增强定义为拦截器。
- 连接点：Join point，蛋糕所有可以切入的点，对于Spring AOP连接点就是方法执行。
有关使用方式：
- Spring AOP API：这种方式是Spring AOP实现的基石。最老的使用方式，在Spring 1.2中的时候用这种API的方式定义AOP。
- 注解声明：使用@AspectJ的@Aspect、@Pointcut等注解来定义AOP。现在基本都使用这种方式来定义，也是官方推荐的方式。
- 配置文件：相比注解声明方式，配置方式有两个缺点，一是定义和实现分离了，二是功能上会比注解声明弱，无法实现全部功能。好处么就是XML在灵活方面会强一点。
- 编程动态配置：使用AspectJProxyFactory进行动态配置。可以作为注解方式静态配置的补充。
有关织入方式：
织入说通俗点就是怎么把增强代码注入到连接点，和被增强的代码融入到一起。
- 运行时：Spring AOP只支持这种方式。实现上有两种方式，一是JDK动态代理，通过反射实现，只支持对实现接口的类进行代理，二是CGLIB动态字节码注入方式实现代理，没有这个限制。Spring 3.2之后的版本已经包含了CGLIB，会根据需要选择合适的方式来使用。
- 编译时：在编译的时候把增强代码注入进去，通过AspjectJ的ajc编译器实现。实现上有两种方式，一种是直接使用ajc编译所有代码，还有一种是javac编译后再进行后处理。
- 加载时：在JVM加载类型的时候注入代码，也叫做LTW。通过启动程序的时候通过javaagent代理默认的类加载器实现。
使用Spring AOP实现事务的坑
新建一个模块：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>me.josephzhu</groupId>
<artifactId>spring101-aop</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>spring101-aop</name>
<description></description>
<parent>
<groupId>me.josephzhu</groupId>
<artifactId>spring101</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.7</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
</project>
在这里我们引入了jackson，以后我们会用来做JSON序列化。引入了mybatis启动器，以后我们会用mybstis做数据访问。引入了h2嵌入式数据库，方便本地测试使用。引入了web启动器，之后我们还会来测试一下对web项目的Controller进行注入。
先来定义一下我们的测试数据类：
package me.josephzhu.spring101aop;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class MyBean {
private Long id;
private String name;
private Integer age;
private BigDecimal balance;
}
然后，我们在resources文件夹下创建schema.sql文件来初始化h2数据库：
CREATE TABLE PERSON(
ID BIGINT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(255),
AGE SMALLINT,
BALANCE DECIMAL
);
还可以在resources文件夹下创建data.sql来初始化数据：
INSERT INTO PERSON (NAME, AGE, BALANCE) VALUES ('zhuye', 35, 1000);
这样程序启动后就会有一个PERSON表，表里有一条ID为1的记录。
通过启动器使用Mybatis非常简单，无需进行任何配置，建一个Mapper接口：
package me.josephzhu.spring101aop;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;
@Mapper
public interface DbMapper {
@Select("SELECT COUNT(0) FROM PERSON")
int personCount();
@Insert("INSERT INTO PERSON (NAME, AGE, BALANCE) VALUES ('zhuye', 35, 1000)")
void personInsertWithoutId();
@Insert("INSERT INTO PERSON (ID, NAME, AGE, BALANCE) VALUES (1,'zhuye', 35, 1000)")
void personInsertWithId();
@Select("SELECT * FROM PERSON")
List<MyBean> getPersonList();
}
这里我们定义了4个方法：
- 查询表中记录数的方法
- 查询表中所有数据的方法
- 带ID字段插入数据的方法，由于程序启动的时候已经初始化了一条数据，如果这里我们再插入ID为1的记录显然会出错，用来之后测试事务使用
- 不带ID字段插入数据的方法
为了我们可以观察到数据库连接是否被Spring纳入事务管理，我们在application.properties配置文件中设置mybatis的Spring事务日志级别为DEBUG：
logging.level.org.mybatis.spring.transaction=DEBUG
现在我们来创建服务接口：
package me.josephzhu.spring101aop;
import java.time.Duration;
import java.util.List;
public interface MyService {
void insertData(boolean success);
List<MyBean> getData(MyBean myBean, int count, Duration delay);
}
定义了插入数据和查询数据的两个方法，下面是实现：
package me.josephzhu.spring101aop;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.Duration;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
@Service
public class MyServiceImpl implements MyService {
@Autowired
private DbMapper dbMapper;
@Transactional(rollbackFor = Exception.class)
public void _insertData(boolean success){
dbMapper.personInsertWithoutId();
if(!success)
dbMapper.personInsertWithId();
}
@Override
public void insertData(boolean success) {
try {
_insertData(success);
} catch (Exception ex) {
ex.printStackTrace();
}
System.out.println("记录数：" + dbMapper.personCount());
}
@Override
public List<MyBean> getData(MyBean myBean, int count, Duration delay) {
try {
Thread.sleep(delay.toMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
return IntStream.rangeClosed(1,count)
.mapToObj(i->new MyBean((long)i,myBean.getName() + i, myBean.getAge(), myBean.getBalance()))
.collect(Collectors.toList());
}
}
getData方法我们就不细说了，只是实现了休眠然后根据传入的myBean作为模板组装了count条测试数据返回。我们来重点看一下insertData方法，这就是使用Spring AOP的一个坑了。看上去配置啥的都没问题，但是_insertData是不能生效自动事务管理的。
我们知道Spring AOP使用代理目标对象方式实现AOP，在从外部调用insertData方法的时候其实走的是代理，这个时候事务环绕可以生效，在方法内部我们通过this引用调用_insertData方法，虽然方法外部我们设置了Transactional注解，但是由于走的不是代理调用，Spring AOP自然无法通过AOP增强为我们做事务管理。
我们来创建主程序测试一下：
package me.josephzhu.spring101aop;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.AdviceMode;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import java.math.BigDecimal;
import java.time.Duration;
@SpringBootApplication
public class Spring101AopApplication implements CommandLineRunner {
public static void main(String[] args) {
SpringApplication.run(Spring101AopApplication.class, args);
}
@Autowired
private MyService myService;
@Override
public void run(String... args) throws Exception {
myService.insertData(true);
myService.insertData(false);
System.out.println(myService.getData(new MyBean(0L, "zhuye",35, new BigDecimal("1000")),
5,
Duration.ofSeconds(1)));
}
}
在Runner中，我们使用true和false调用了两次insertData方法。后面一次调用肯定会失败，因为_insert方法中会进行重复ID的数据插入。运行程序后得到如下输出：
2018-10-07 09:11:44.605 INFO 19380 --- [ main] m.j.s.Spring101AopApplication : Started Spring101AopApplication in 3.072 seconds (JVM running for 3.74)
2018-10-07 09:11:44.621 DEBUG 19380 --- [ main] o.m.s.t.SpringManagedTransaction : JDBC Connection [HikariProxyConnection@2126664214 wrapping conn0: url=jdbc:h2:mem:testdb user=SA] will not be managed by Spring
2018-10-07 09:11:44.626 DEBUG 19380 --- [ main] o.m.s.t.SpringManagedTransaction : JDBC Connection [HikariProxyConnection@775174220 wrapping conn0: url=jdbc:h2:mem:testdb user=SA] will not be managed by Spring
记录数：2
2018-10-07 09:11:44.638 DEBUG 19380 --- [ main] o.m.s.t.SpringManagedTransaction : JDBC Connection [HikariProxyConnection@2084486251 wrapping conn0: url=jdbc:h2:mem:testdb user=SA] will not be managed by Spring
2018-10-07 09:11:44.638 DEBUG 19380 --- [ main] o.m.s.t.SpringManagedTransaction : JDBC Connection [HikariProxyConnection@26418585 wrapping conn0: url=jdbc:h2:mem:testdb user=SA] will not be managed by Spring
2018-10-07 09:11:44.642 INFO 19380 --- [ main] o.s.b.f.xml.XmlBeanDefinitionReader : Loading XML bean definitions from class path resource [org/springframework/jdbc/support/sql-error-codes.xml]
org.springframework.dao.DuplicateKeyException:
### Error updating database. Cause: org.h2.jdbc.JdbcSQLException: Unique index or primary key violation: "PRIMARY KEY ON PUBLIC.PERSON(ID)"; SQL statement:
INSERT INTO PERSON (ID, NAME, AGE, BALANCE) VALUES (1,'zhuye', 35, 1000) [23505-197]
2018-10-07 09:11:44.689 DEBUG 19380 --- [ main] o.m.s.t.SpringManagedTransaction : JDBC Connection [HikariProxyConnection@529949842 wrapping conn0: url=jdbc:h2:mem:testdb user=SA] will not be managed by Spring
记录数：3
[MyBean(id=1, name=zhuye1, age=35, balance=1000), MyBean(id=2, name=zhuye2, age=35, balance=1000), MyBean(id=3, name=zhuye3, age=35, balance=1000), MyBean(id=4, name=zhuye4, age=35, balance=1000), MyBean(id=5, name=zhuye5, age=35, balance=1000)]
从日志的几处我们都可以得到结论，事务管理没有生效：
- 我们可以看到有类似Connection will not be managed by Spring的提示，说明连接没有进入Spring的事务管理。
- 程序启动的时候记录数为1，第一次调用insertData方法后记录数为2，第二次调用方法如果事务生效方法会回滚记录数会维持在2，在输出中我们看到记录数最后是3。
那么，如何解决这个问题呢，有三种方式：
- 使用AspjectJ来实现AOP，这种方式是直接修改代码的，不是走代理实现的，不会有这个问题，下面我们会详细说明一下这个过程。
- 在代码中使用AopContext.currentProxy()来获得当前的代理进行_insertData方法调用。这种方式侵入太强，而且需要被代理类意识到自己是通过代理被访问，显然不是合适的方式。
- 改造代码，使需要事务代理的方法直接调用，类似：
@Override
@Transactional(rollbackFor = Exception.class)
public void insertData(boolean success) {
dbMapper.personInsertWithoutId();
if(!success)
dbMapper.personInsertWithId();
}
这里还容易犯错的地方是，这里不能对异常进行捕获，否则Spring事务代理无法捕获到异常也就无法实现回滚。
使用AspectJ静态织入进行改造
那么原来这段代码如何不改造实现事务呢？可以通过AspjectJ编译时静态织入实现。整个配置过程如下：
首先在pom中加入下面的配置：
<build>
<sourceDirectory>${project.build.directory}/generated-sources/delombok</sourceDirectory>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.projectlombok</groupId>
<artifactId>lombok-maven-plugin</artifactId>
<version>1.18.0.0</version>
<executions>
<execution>
<phase>generate-sources</phase>
<goals>
<goal>delombok</goal>
</goals>
</execution>
</executions>
<configuration>
<addOutputDirectory>false</addOutputDirectory>
<sourceDirectory>src/main/java</sourceDirectory>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>aspectj-maven-plugin</artifactId>
<version>1.10</version>
<configuration>
<complianceLevel>1.8</complianceLevel>
<source>1.8</source>
<aspectLibraries>
<aspectLibrary>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
</aspectLibrary>
</aspectLibraries>
</configuration>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>test-compile</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
这里的一个坑是ajc编译器无法支持lambok，我们需要先使用lombok的插件在生成源码阶段对lombok代码进行预处理，然后我们再通过aspjectj插件来编译代码。Pom文件中还需要加入如下依赖：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
</dependency>
然后需要配置Spring来使用ASPECTJ的增强方式来做事务管理：
@EnableTransactionManagement(mode = AdviceMode.ASPECTJ)
public class Spring101AopApplication implements CommandLineRunner {
重新使用maven编译代码后可以看到，相关代码已经变了样：
@Transactional(
rollbackFor = {Exception.class}
)
public void _insertData(boolean success) {
AnnotationTransactionAspect var10000 = AnnotationTransactionAspect.aspectOf();
Object[] var3 = new Object[]{this, Conversions.booleanObject(success)};
var10000.ajc$around$org_springframework_transaction_aspectj_AbstractTransactionAspect$1$2a73e96c(this, new MyServiceImpl$AjcClosure1(var3), ajc$tjp_0);
}
public void insertData(boolean success) {
try {
this._insertData(success);
} catch (Exception var3) {
var3.printStackTrace();
}
System.out.println("记录数：" + this.dbMapper.personCount());
}
运行程序可以看到如下日志：
2018-10-07 09:35:12.360 DEBUG 19459 --- [ main] o.m.s.t.SpringManagedTransaction : JDBC Connection [HikariProxyConnection@1169317628 wrapping conn0: url=jdbc:h2:mem:testdb user=SA] will be managed by Spring
而且最后输出的结果是2，说明第二次插入数据整体回滚了。
如果使用IDEA的话还可以配置先由javac编译再由ajc后处理，具体参见IDEA官网这里不详述。
使用AOP进行事务后处理
我们先使用刚才说的方法3改造一下代码，使得Spring AOP可以处理事务（Aspject AOP功能虽然强大但是和Spring结合的不好，所以我们接下去的测试还是使用Spring AOP），删除aspjectj相关依赖，在IDEA配置回javac编译器重新编译项目。本节中我们尝试建立第一个我们的切面：
package me.josephzhu.spring101aop;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.support.TransactionSynchronizationAdapter;
import org.springframework.transaction.support.TransactionSynchronizationManager;
@Aspect
@Component
@Slf4j
class TransactionalAspect extends TransactionSynchronizationAdapter {
@Autowired
private DbMapper dbMapper;
private ThreadLocal<JoinPoint> joinPoint = new ThreadLocal<>();
@Before("@within(org.springframework.transaction.annotation.Transactional) || @annotation(org.springframework.transaction.annotation.Transactional)")
public void registerSynchronization(JoinPoint jp) {
joinPoint.set(jp);
TransactionSynchronizationManager.registerSynchronization(this);
}
@Override
public void afterCompletion(int status) {
log.info(String.format("【%s】【%s】事务提交 %s，目前记录数：%s",
joinPoint.get().getSignature().getDeclaringType().toString(),
joinPoint.get().getSignature().toLongString(),
status == 0 ? "成功":"失败",
dbMapper.personCount()));
joinPoint.remove();
}
}
在这里，我们的切点是所有标记了@Transactional注解的类以及标记了@Transactional注解的方法，我们的增强比较简单，在事务同步管理器注册一个回调方法，用于事务完成后进行额外的处理。这里的一个坑是Spring如何实例化切面。通过查文档或做实验可以得知，默认情况下TranscationalAspect是单例的，在多线程情况下，可能会有并发，保险起见我们使用ThreadLocal来存放。运行代码后可以看到如下输出：
2018-10-07 10:01:32.384 INFO 19599 --- [ main] m.j.spring101aop.TransactionalAspect : 【class me.josephzhu.spring101aop.MyServiceImpl】【public void me.josephzhu.spring101aop.MyServiceImpl.insertData(boolean)】事务提交 成功，目前记录数：2
2018-10-07 10:01:32.385 DEBUG 19599 --- [ main] o.m.s.t.SpringManagedTransaction : JDBC Connection [HikariProxyConnection@1430104337 wrapping conn0: url=jdbc:h2:mem:testdb user=SA] will be managed by Spring
2018-10-07 10:01:32.449 DEBUG 19599 --- [ main] o.m.s.t.SpringManagedTransaction : JDBC Connection [HikariProxyConnection@1430104337 wrapping conn0: url=jdbc:h2:mem:testdb user=SA] will be managed by Spring
2018-10-07 10:01:32.449 INFO 19599 --- [ main] m.j.spring101aop.TransactionalAspect : 【class me.josephzhu.spring101aop.MyServiceImpl】【public void me.josephzhu.spring101aop.MyServiceImpl.insertData(boolean)】事务提交 失败，目前记录数：2
可以看到Spring AOP做了事务管理，我们两次事务提交第一次成功第二次失败，失败后记录数还是2。这个功能还可以通过Spring的@TransactionalEventListener注解实现，这里不详述。
切换JDK代理和CGLIB代理
我们现在注入的是接口，我们知道对于这种情况Spring AOP应该使用的是JDK代理。但是SpringBoot默认开启了下面的属性来全局启用CGLIB代理：
spring.aop.proxy-target-class=true
我们尝试把这个属性设置成false，然后在刚才的TransationalAspect中的增强方法设置断点，可以看到这是一个ReflectiveMethodInvocation：
把配置改为true重新观察可以看到变为了CglibMethodInvocation：
我们把开关改为false，然后切换到注入实现，运行程序会得到如下错误提示，意思就是我我们走JDK代理的话不能注入实现，需要注入接口：
The bean 'myServiceImpl' could not be injected as a 'me.josephzhu.spring101aop.MyServiceImpl' because it is a JDK dynamic proxy that implements:
me.josephzhu.spring101aop.MyService
我们修改我们的MyServiceImpl，去掉实现接口的代码和@Override注解，使之成为一个普通的类，重新运行程序可以看到我们的代理方式自动降级为了CGLIB方式（虽然spring.aop.proxy-target-class参数我们现在设置的是false）。
使用AOP无缝实现日志+异常+打点
现在我们来实现一个复杂点的切面的例子。我们知道，出错记录异常信息，对于方法调用记录打点信息（如果不知道什么是打点可以参看《朱晔的互联网架构实践心得S1E4：简单好用的监控六兄弟》），甚至有的时候为了排查问题需要记录方法的入参和返回，这三个事情是我们经常需要做的和业务逻辑无关的事情，我们可以尝试使用AOP的方式一键切入这三个事情的实现，在业务代码无感知的情况下做好监控和打点。
首先实现我们的注解，通过这个注解我们可以细化控制一些功能：
package me.josephzhu.spring101aop;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Metrics {
/**
* 是否在成功执行方法后打点
* @return
*/
boolean recordSuccessMetrics() default true;
/**
* 是否在执行方法出错时打点
* @return
*/
boolean recordFailMetrics() default true;
/**
* 是否记录请求参数
* @return
*/
boolean logParameters() default true;
/**
* 是否记录返回值
* @return
*/
boolean logReturn() default true;
/**
* 是否记录异常
* @return
*/
boolean logException() default true;
/**
* 是否屏蔽异常返回默认值
* @return
*/
boolean ignoreException() default false;
}
下面我们就来实现这个切面：
package me.josephzhu.spring101aop;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.time.Duration;
import java.time.Instant;
@Aspect
@Component
@Slf4j
public class MetricsAspect {
private static ObjectMapper objectMapper = new ObjectMapper();
@Around("@annotation(me.josephzhu.spring101aop.Metrics) || @within(org.springframework.stereotype.Controller)")
public Object metrics(ProceedingJoinPoint pjp) throws Throwable {
//1
MethodSignature signature = (MethodSignature) pjp.getSignature();
Metrics metrics;
String name;
if (signature.getDeclaringType().isInterface()) {
Class implClass = pjp.getTarget().getClass();
Method method = implClass.getMethod(signature.getName(), signature.getParameterTypes());
metrics = method.getDeclaredAnnotation(Metrics.class);
name = String.format("【%s】【%s】", implClass.toString(), method.toString());
} else {
metrics = signature.getMethod().getAnnotation(Metrics.class);
name = String.format("【%s】【%s】", signature.getDeclaringType().toString(), signature.toLongString());
}
//2
if (metrics == null)
metrics = new Metrics() {
@Override
public boolean logException() {
return true;
}
@Override
public boolean logParameters() {
return true;
}
@Override
public boolean logReturn() {
return true;
}
@Override
public boolean recordFailMetrics() {
return true;
}
@Override
public boolean recordSuccessMetrics() {
return true;
}
@Override
public boolean ignoreException() {
return false;
}
@Override
public Class<? extends Annotation> annotationType() {
return Metrics.class;
}
};
RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
if (requestAttributes != null) {
HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest();
if (request != null)
name += String.format("【%s】", request.getRequestURL().toString());
}
//3
if (metrics.logParameters())
log.info(String.format("【入参日志】调用 %s 的参数是：【%s】", name, objectMapper.writeValueAsString(pjp.getArgs())));
//4
Object returnValue;
Instant start = Instant.now();
try {
returnValue = pjp.proceed();
if (metrics.recordSuccessMetrics())
log.info(String.format("【成功打点】调用 %s 成功，耗时：%s", name, Duration.between(Instant.now(), start).toString()));
} catch (Exception ex) {
if (metrics.recordFailMetrics())
log.info(String.format("【失败打点】调用 %s 失败，耗时：%s", name, Duration.between(Instant.now(), start).toString()));
if (metrics.logException())
log.error(String.format("【异常日志】调用 %s 出现异常！", name), ex);
if (metrics.ignoreException())
returnValue = getDefaultValue(signature.getReturnType().toString());
else
throw ex;
}
//5
if (metrics.logReturn())
log.info(String.format("【出参日志】调用 %s 的返回是：【%s】", name, returnValue));
return returnValue;
}
private static Object getDefaultValue(String clazz) {
if (clazz.equals("boolean")) {
return false;
} else if (clazz.equals("char")) {
return 'u0000';
} else if (clazz.equals("byte")) {
return 0;
} else if (clazz.equals("short")) {
return 0;
} else if (clazz.equals("int")) {
return 0;
} else if (clazz.equals("long")) {
return 0L;
} else if (clazz.equals("flat")) {
return 0.0F;
} else if (clazz.equals("double")) {
return 0.0D;
} else {
return null;
}
}
}
看上去代码量很多，其实实现比较简单：
- 最关键的切点，我们在两个点切入，一是标记了Metrics注解的方法，二是标记了Controller的类（我们希望实现的目标是对于Controller所有方法默认都加上这个功能，因为这是对外的接口，比较重要）。所以在之后的代码中，我们还需要额外对Web程序做一些处理。
- 对于@Around我们的参数是ProceedingJoinPoint不是JoinPoint，因为环绕增强允许我们执行方法调用。
- 第一段代码，我们尝试获取当前方法的类名和方法名。这里有一个坑，如果连接点是接口的话，@Metrics的定义需要从实现类（也就是代理的Target）上获取。作为框架的开发者，我们需要考虑到各种使用方使用的情况，如果有遗留的话就会出现BUG。
- 第二段代码，是为Web项目准备的，如果我们希望默认为所有的Controller方法做日志异常打点处理的话，我们需要初始化一个@Metrics注解出来，然后对于Web项目我们可以从上下文中获取到额外的一些信息来丰富我们的日志。
- 第三段代码，实现的是入参的日志输出。
- 第四段代码，实现的是连接点方法的执行，以及成功失败的打点，出现异常的时候还会记录日志。这里我们通过日志方式暂时替代了打点的实现，标准的实现是需要把信息提交到类似Graphite这样的时间序列数据库或对接SpringBoot Actuator。另外，如果开启忽略异常的话，我们需要把结果替换为返回类型的默认值，并且吃掉异常。
- 第五段代码，实现了返回值的日志输出。
最后，我们修改一下MyServiceImpl的实现，在insertData和getData两个方法上加入我们的@Metrics注解。运行程序可以看到如下输出：
2018-10-07 10:47:00.813 INFO 19737 --- [ main] me.josephzhu.spring101aop.MetricsAspect : 【入参日志】调用 【class me.josephzhu.spring101aop.MyServiceImpl】【public void me.josephzhu.spring101aop.MyServiceImpl.insertData(boolean)】 的参数是：【[true]】
2018-10-07 10:47:00.864 INFO 19737 --- [ main] me.josephzhu.spring101aop.MetricsAspect : 【成功打点】调用 【class me.josephzhu.spring101aop.MyServiceImpl】【public void me.josephzhu.spring101aop.MyServiceImpl.insertData(boolean)】 成功，耗时：PT-0.048S
2018-10-07 10:47:00.864 INFO 19737 --- [ main] me.josephzhu.spring101aop.MetricsAspect : 【出参日志】调用 【class me.josephzhu.spring101aop.MyServiceImpl】【public void me.josephzhu.spring101aop.MyServiceImpl.insertData(boolean)】 的返回是：【null】
2018-10-07 10:47:00.927 INFO 19737 --- [ main] me.josephzhu.spring101aop.MetricsAspect : 【入参日志】调用 【class me.josephzhu.spring101aop.MyServiceImpl】【public void me.josephzhu.spring101aop.MyServiceImpl.insertData(boolean)】 的参数是：【[false]】
2018-10-07 10:47:01.084 INFO 19737 --- [ main] me.josephzhu.spring101aop.MetricsAspect : 【失败打点】调用 【class me.josephzhu.spring101aop.MyServiceImpl】【public void me.josephzhu.spring101aop.MyServiceImpl.insertData(boolean)】 失败，耗时：PT-0.156S
2018-10-07 10:47:01.102 ERROR 19737 --- [ main] me.josephzhu.spring101aop.MetricsAspect : 【异常日志】调用 【class me.josephzhu.spring101aop.MyServiceImpl】【public void me.josephzhu.spring101aop.MyServiceImpl.insertData(boolean)】 出现异常！
2018-10-07 10:47:01.231 INFO 19737 --- [ main] me.josephzhu.spring101aop.MetricsAspect : 【入参日志】调用 【class me.josephzhu.spring101aop.MyServiceImpl】【public java.util.List me.josephzhu.spring101aop.MyServiceImpl.getData(me.josephzhu.spring101aop.MyBean,int,java.time.Duration)】 的参数是：【[{"id":0,"name":"zhuye","age":35,"balance":1000},5,{"seconds":1,"zero":false,"nano":0,"units":["SECONDS","NANOS"],"negative":false}]】
2018-10-07 10:47:02.237 INFO 19737 --- [ main] me.josephzhu.spring101aop.MetricsAspect : 【成功打点】调用 【class me.josephzhu.spring101aop.MyServiceImpl】【public java.util.List me.josephzhu.spring101aop.MyServiceImpl.getData(me.josephzhu.spring101aop.MyBean,int,java.time.Duration)】 成功，耗时：PT-1.006S
2018-10-07 10:47:02.237 INFO 19737 --- [ main] me.josephzhu.spring101aop.MetricsAspect : 【出参日志】调用 【class me.josephzhu.spring101aop.MyServiceImpl】【public java.util.List me.josephzhu.spring101aop.MyServiceImpl.getData(me.josephzhu.spring101aop.MyBean,int,java.time.Duration)】 的返回是：【[MyBean(id=1, name=zhuye1, age=35, balance=1000), MyBean(id=2, name=zhuye2, age=35, balance=1000), MyBean(id=3, name=zhuye3, age=35, balance=1000), MyBean(id=4, name=zhuye4, age=35, balance=1000), MyBean(id=5, name=zhuye5, age=35, balance=1000)]】
[MyBean(id=1, name=zhuye1, age=35, balance=1000), MyBean(id=2, name=zhuye2, age=35, balance=1000), MyBean(id=3, name=zhuye3, age=35, balance=1000), MyBean(id=4, name=zhuye4, age=35, balance=1000), MyBean(id=5, name=zhuye5, age=35, balance=1000)]
正确实现了参数日志、异常日志、成功失败打点（含耗时统计）等功能。
下面我们创建一个Controller来测试一下是否可以自动切入Controller：
package me.josephzhu.spring101aop;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.List;
@Controller
public class MyController {
@Autowired
private DbMapper dbMapper;
@ResponseBody
@GetMapping("/data")
public List<MyBean> getPersonList(){
return dbMapper.getPersonList();
}
}
运行程序打开浏览器访问http://localhost:8080/data后能看到如下输出：
2018-10-07 10:49:53.811 INFO 19737 --- [nio-8080-exec-1] me.josephzhu.spring101aop.MetricsAspect : 【入参日志】调用 【class me.josephzhu.spring101aop.MyController】【public java.util.List me.josephzhu.spring101aop.MyController.getPersonList()】【http://localhost:8080/data】 的参数是：【[]】
2018-10-07 10:49:53.819 INFO 19737 --- [nio-8080-exec-1] me.josephzhu.spring101aop.MetricsAspect : 【成功打点】调用 【class me.josephzhu.spring101aop.MyController】【public java.util.List me.josephzhu.spring101aop.MyController.getPersonList()】【http://localhost:8080/data】 成功，耗时：PT-0.008S
2018-10-07 10:49:53.819 INFO 19737 --- [nio-8080-exec-1] me.josephzhu.spring101aop.MetricsAspect : 【出参日志】调用 【class me.josephzhu.spring101aop.MyController】【public java.util.List me.josephzhu.spring101aop.MyController.getPersonList()】【http://localhost:8080/data】 的返回是：【[MyBean(id=1, name=zhuye, age=35, balance=1000), MyBean(id=2, name=zhuye, age=35, balance=1000)]】
最后，我们再来踩一个坑。我们来测一下ignoreException吞掉异常的功能（默认为false）：
@Transactional(rollbackFor = Exception.class)
@Override
@Metrics(ignoreException = true)
public void insertData(boolean success){
dbMapper.personInsertWithoutId();
if(!success)
dbMapper.personInsertWithId();
}
这个功能会吞掉异常，在和Transactional事务管理结合时候会不会出问题呢？
开启这个配置后刷新页面可以看到数据库内有三条记录了，说明第二次的insertData方法执行没有成功回滚事务。这也是合情合理的，毕竟我们的MetricsAspect吃掉了异常。
怎么绕开这个问题呢？答案是我们需要手动控制一下我们的切面的执行优先级，我们希望这个切面优先级比Spring事务控制切面优先级低：
@Aspect
@Component
@Slf4j
@Order(1)
public class MetricsAspect {
再次运行程序可以看到事务正确回滚。
总结
本文我们通过一些例子覆盖了如下内容：
- Spring AOP的一些基本知识点。
- Mybatis和H2的简单配置使用。
- 如何实现Spring事务管理。
- 如何切换为AspjectJ进行AOP。
- 观察JDK代理和CGLIB代理。
- 如何定义切面实现事务后处理和日志异常打点这种横切关注点。
在整个过程中，也踩了下面的坑，印证的本文的标题：
- Spring AOP代理不能作用于代理类内部this方法调用的坑。
- Spring AOP实例化切面默认单例的坑。
- AJC编译器无法支持lambok的坑。
- 切面优先级顺序的坑。
- 切面内部获取注解方式的坑。
老样子，本系列文章代码见我的github：https://github.com/JosephZhu1983/Spring101。