文章目录

AOP概述AOP底层原理AOP操作术语AOP开发准备基于xml的AOP操作前置增强和后置增强异常抛出增强最终增强环绕增强 基于注解的AOP操作

AOP

概述

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

主要意图：

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

AOP底层原理

AOP底层使用动态代理

（1）有两种情况的动态代理

第一种，有接口的情况，使用JDK动态代理，创建接口实现类的代理对象；

第二种，没有接口的情况，使用CGLIB动态代理，创建当前类的子类的代理对象，继承重写方法；

AOP操作术语

0、目标类target

被代理的类，一般是业务层（Service）；

1、连接点Joinpoint

类里面哪些方法可能被增强，这些方法称为连接点；

2、切入点Pointcut

实际被真正增强的方法称为切入点；

3、通知Advice

增强的方法（逻辑代码）

4、织入Weaving

把增强的方法应用到目标的对象来创建新的代理对象

5、切面Aspect

切面Aspect是切入点Joinpoint和通知Advice的结合。

一般的，通知有多种类型，

前置通知Before：在目标方法前织入增强代码后置通知AfterReturning：在目标方法正常执行后织入增强代码（不出现异常）异常通知AfterThrowing：在目标方法抛出异常后织入增强代码最终通知After：无论方法是否抛出异常，都会在目标方法最后织入增强代码环绕通知Around：在目标方法的前后都可以织入增强代码

AOP开发准备

在Spring框架中，我们都是基于AspectJ实现AOP相关操作。

AspectJ：AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。

一般情况下把AspectJ和Spring框架一起使用，进行AOP操作。

基于AspectJ实现AOP操作

xml配置文件注解方式（方便）

新建模块spring-04，在模块中引入AOP操作相关依赖。

<dependencies> <!--导入AOP操作相关的jar--> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.6</version> <scope>runtime</scope> </dependency> <dependency> <groupId>aopalliance</groupId> <artifactId>aopalliance</artifactId> <version>1.0</version> </dependency> </dependencies>

切入点表达式：对哪个类的哪个方法进行增强。

语法：

execution([权限修饰符][返回类型][全限定类名][方法名称]([参数列表])) 权限修饰符可以省略 * org.westos.service.*.*(..) 匹配org.westos.service包下所有类的所有方法 * org.westos.service..*.*(..) 匹配org.westos.service包及其子包下所有类的所有方法

基于xml的AOP操作

引入日志Log4j。

<dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency>

前置增强和后置增强

基于上面的项目目录建立service层、mapper层、entity实体类、aop包下的类是一个增强类。

UserServiceLogger，UserService的一个增强类，打印信息。

package org.westos.aop; import org.apache.log4j.Logger; import org.aspectj.lang.JoinPoint; import java.util.Arrays; /** * 增强类 * @author lwj * @date 2020/10/7 19:00 */ public class UserServiceLogger { private static Logger logger = Logger.getLogger(UserServiceLogger.class); /** * 前置增强 * @param joinPoint 连接点 */ public void before(JoinPoint joinPoint) { logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法入参：" + Arrays.toString(joinPoint.getArgs())); } /** * 后置增强 * @param joinPoint 连接点 * @param result 返回值 */ public void afterReturning(JoinPoint joinPoint, Object result) { logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法返回值：" + result); } }

Spring配置文件

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <bean id="userMapper" class="org.westos.mapper.impl.UserMapperImpl"/> <bean id="userService" class="org.westos.service.impl.UserServiceImpl"> <property name="userMapper" ref="userMapper"/> </bean> <bean id="userServiceLogger" class="org.westos.aop.UserServiceLogger"> </bean> <aop:config> <!--配置切入点--> <aop:pointcut id="pointcut" expression="execution(* org.westos.service.UserService.*(..))"/> <!--配置切面--> <!--ref属性代表使用哪一个增强类--> <aop:aspect ref="userServiceLogger"> <!--配置前置增强到切入点--> <aop:before method="before" pointcut-ref="pointcut"/> <!--配置后置增强到切入点--> <!--存在返回值参数--> <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/> </aop:aspect> </aop:config> </beans>

测试类

@Test public void test() { //测试前置增强和后置增强 ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml"); User user = new User(); user.setUserId("001"); user.setUsername("lucy"); user.setUserPwd("admin"); UserService userService = (UserService) context.getBean("userService"); //基于接口的动态代理 //第一次在强转时，强转为UserServiceImpl，执行报错，动态代理类$Proxy6不能强转为UserServiceImpl //也是啊，同样是UserService接口的实现类，就好比猫不能强转为狗 userService.addUser(user); } 调用org.westos.service.impl.UserServiceImpl@1bd4fdd的addUser方法，方法入参：[org.westos.entity.User@1283bb96] UserServiceImpl >>> addUser UserMapperImpl >>> addUser 调用org.westos.service.impl.UserServiceImpl@1bd4fdd的addUser方法，方法返回值：1

上面是前置增强和后置增强。

异常抛出增强

下面说异常抛出增强，在目标方法抛出异常后织入增强代码。

UserServiceImpl业务层

@Override public int addUser(User user) { if (true) { throw new ArrayIndexOutOfBoundsException(); } System.out.println("UserServiceImpl >>> addUser"); return userMapper.addUser(user); }

UserServiceLogger业务增强类

public class UserServiceLogger { private static Logger logger = Logger.getLogger(UserServiceLogger.class); /** * 前置增强 * @param joinPoint 连接点 */ public void before(JoinPoint joinPoint) { logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法入参：" + Arrays.toString(joinPoint.getArgs())); } /** * 后置增强 * @param joinPoint 连接点 * @param result 返回值 */ public void afterReturning(JoinPoint joinPoint, Object result) { logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法返回值：" + result); } /** * 异常抛出增强 * @param joinPoint 连接点 * @param e 异常 */ public void afterThrowing(JoinPoint joinPoint, Exception e) { logger.error("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法抛出异常：" + e); } }

bean.xml Spring配置文件

<aop:config> <!--配置切入点--> <aop:pointcut id="pointcut" expression="execution(* org.westos.service.UserService.*(..))"/> <!--配置切面--> <!--ref属性代表使用哪一个增强类--> <aop:aspect ref="userServiceLogger"> <!--配置前置增强到切入点--> <aop:before method="before" pointcut-ref="pointcut"/> <!--配置后置增强到切入点--> <!--存在返回值参数--> <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/> <!--配置异常抛出增强到切入点--> <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"/> </aop:aspect> </aop:config>

测试

@Test public void test1() { //测试异常抛出增强 ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml"); User user = new User(); user.setUserId("002"); user.setUsername("lisa"); user.setUserPwd("admin"); UserService userService = (UserService) context.getBean("userService"); //调用UserService的addUser(User user)方法，抛出异常，当抛出异常时，会有增强代码执行 userService.addUser(user); } 调用org.westos.service.impl.UserServiceImpl@2a3b5b47的addUser方法，方法入参：[org.westos.entity.User@313ac989] 调用org.westos.service.impl.UserServiceImpl@2a3b5b47的addUser方法，方法抛出异常：java.lang.ArrayIndexOutOfBoundsException

从打印结果中可以看出，前置增强和异常抛出增强都有效果，但是因为目标方法没有正常执行完毕，所以不会有后置增强。

最终增强

无论方法是否抛出异常，都会在目标方法的最后织入该增强。

类似于异常机制中finally块的作用，一般用于释放资源。

public class UserServiceLogger { private static Logger logger = Logger.getLogger(UserServiceLogger.class); /** * 前置增强 * @param joinPoint 连接点 */ public void before(JoinPoint joinPoint) { logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法入参：" + Arrays.toString(joinPoint.getArgs())); } /** * 后置增强 * @param joinPoint 连接点 * @param result 返回值 */ public void afterReturning(JoinPoint joinPoint, Object result) { logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法返回值：" + result); } /** * 异常抛出增强 * @param joinPoint 连接点 * @param e 异常 */ public void afterThrowing(JoinPoint joinPoint, Exception e) { logger.error("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法抛出异常：" + e); } /** * 最终增强 * @param joinPoint 连接点 */ public void after(JoinPoint joinPoint) { logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法执行结束。"); } } <aop:config> <!--配置切入点--> <aop:pointcut id="pointcut" expression="execution(* org.westos.service.UserService.*(..))"/> <!--配置切面--> <!--ref属性代表使用哪一个增强类--> <aop:aspect ref="userServiceLogger"> <!--配置前置增强到切入点--> <aop:before method="before" pointcut-ref="pointcut"/> <!--配置后置增强到切入点--> <!--存在返回值参数--> <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/> <!--配置异常抛出增强到切入点--> <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"/> <!--配置最终增强到切入点--> <aop:after method="after" pointcut-ref="pointcut"/> </aop:aspect> </aop:config>

测试

@Test public void test2() { //测试最终增强 ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml"); User user = new User(); user.setUserId("003"); user.setUsername("jack"); user.setUserPwd("admin"); UserService userService = (UserService) context.getBean("userService"); //调用UserService的addUser(User user)方法，抛出异常，当抛出异常时，会有增强代码执行，最终增强同样会执行 userService.addUser(user); } 调用org.westos.service.impl.UserServiceImpl@6302bbb1的addUser方法，方法入参：[org.westos.entity.User@7c7b252e] 调用org.westos.service.impl.UserServiceImpl@6302bbb1的addUser方法，方法抛出异常：java.lang.ArrayIndexOutOfBoundsException 调用org.westos.service.impl.UserServiceImpl@6302bbb1的addUser方法，方法执行结束。

环绕增强

目标方法执行前后都可以织入增强。

功能最强大的增强处理。

可获取或修改目标方法的参数、返回值，可对它进行异常处理，甚至可以决定目标方法是否执行。

public Object around(ProceedingJoinPoint joinPoint) throws Throwable { logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法入参：" + Arrays.toString(joinPoint.getArgs())); try { Object result = joinPoint.proceed(); logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法返回值：" + result); return result; } catch (Throwable e) { logger.error("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法抛出异常：" + e); throw e; } finally { logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法执行结束。"); } } <aop:config> <!--配置切入点--> <aop:pointcut id="pointcut" expression="execution(* org.westos.service.UserService.*(..))"/> <!--配置切面--> <!--ref属性代表使用哪一个增强类--> <aop:aspect ref="userServiceLogger"> <!--配置前置增强到切入点--> <aop:before method="before" pointcut-ref="pointcut"/> <!--配置后置增强到切入点--> <!--存在返回值参数--> <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/> <!--配置异常抛出增强到切入点--> <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"/> <!--配置最终增强到切入点--> <aop:after method="after" pointcut-ref="pointcut"/> <!--配置环绕增强到切入点--> <aop:around method="around" pointcut-ref="pointcut"/> </aop:aspect> </aop:config>

测试

@Test public void test3() { //测试环绕增强 ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml"); User user = new User(); user.setUserId("004"); user.setUsername("jenny"); user.setUserPwd("admin"); UserService userService = (UserService) context.getBean("userService"); userService.addUser(user); }

1、前置增强

[org.westos.aop.UserServiceLogger.before(UserServiceLogger.java:24) ] 2020/10/08 13:56:52INFO [UserServiceLogger] - org.westos.aop.UserServiceLogger.before(UserServiceLogger.java:24) - 调用org.westos.service.impl.UserServiceImpl@692f203f的addUser方法，方法入参：[org.westos.entity.User@235834f2]

2、环绕增强

[org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:58) ] 2020/10/08 13:56:52INFO [UserServiceLogger] - org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:58) - 调用org.westos.service.impl.UserServiceImpl@692f203f的addUser方法，方法入参：[org.westos.entity.User@235834f2]

3、目标方法抛出异常，触发环绕增强对于异常的处理

[org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:66) ] 2020/10/08 13:56:52ERROR [UserServiceLogger] - org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:66) - 调用org.westos.service.impl.UserServiceImpl@692f203f的addUser方法，方法抛出异常：java.lang.ArrayIndexOutOfBoundsException

4、目标方法抛出异常，触发环绕增强的finally块

[org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:70) ] 2020/10/08 13:56:52INFO [UserServiceLogger] - org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:70) - 调用org.westos.service.impl.UserServiceImpl@692f203f的addUser方法，方法执行结束。

5、最终增强

[org.westos.aop.UserServiceLogger.after(UserServiceLogger.java:53) ] 2020/10/08 13:56:52INFO [UserServiceLogger] - org.westos.aop.UserServiceLogger.after(UserServiceLogger.java:53) - 调用org.westos.service.impl.UserServiceImpl@692f203f的addUser方法，方法执行结束。

6、抛出异常增强

[org.westos.aop.UserServiceLogger.afterThrowing(UserServiceLogger.java:44) ] 2020/10/08 13:56:52ERROR [UserServiceLogger] - org.westos.aop.UserServiceLogger.afterThrowing(UserServiceLogger.java:44) - 调用org.westos.service.impl.UserServiceImpl@692f203f的addUser方法，方法抛出异常：java.lang.ArrayIndexOutOfBoundsException

基于注解的AOP操作

使用注解进行AOP操作。

新建模块spring-05来实现基于注解的AOP。

使用注解，需要扫描，那么在bean.xml中就需要引入context命名空间。

准备工作：

@Component @Scope("prototype") public class User { @Value("001") private String userId; @Value("shine") private String username; @Value("admin") private String userPwd; //setter/getter } @Repository public class UserMapperImpl implements UserMapper { //模拟数据库操作 } @Service public class UserServiceImpl implements UserService { @Autowired @Qualifier("userMapperImpl") private UserMapper userMapper; } <?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" 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"> <context:component-scan base-package="org.westos"/> </beans>

下面就该简化AOP的xml代码。

Spring通过集成AspectJ实现了以注解的方式定义增强类，大大减少了配置文件中的工作量。

使用@AspectJ，首先要保证所用的JDK是5.0及以上版本。

首先，在Spring配置文件中需要开启对于@AspectJ注解的支持。

<?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"> <context:component-scan base-package="org.westos"/> <aop:aspectj-autoproxy/> </beans>

其次在增强类上添加@Aspect注解来标注这是一个增强类。另外，还需要一个@Component注解。

@Aspect @Component public class UserServiceLogger { private static Logger logger = Logger.getLogger(UserServiceLogger.class); /** * 前置增强 * @param joinPoint 连接点 */ @Before("execution(* org.westos.service.*.*(..))") public void before(JoinPoint joinPoint) { logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法入参：" + Arrays.toString(joinPoint.getArgs())); } /** * 后置增强 * @param joinPoint 连接点 * @param result 返回值 */ @AfterReturning(value = "execution(* org.westos.service.*.*(..))", returning = "result") public void afterReturning(JoinPoint joinPoint, Object result) { logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法返回值：" + result); } /** * 异常抛出增强 * @param joinPoint 连接点 * @param e 异常 */ @AfterThrowing(value = "execution(* org.westos.service.*.*(..))", throwing = "e") public void afterThrowing(JoinPoint joinPoint, Exception e) { logger.error("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法抛出异常：" + e); } /** * 最终增强 * @param joinPoint 连接点 */ @After(value = "execution(* org.westos.service.*.*(..))") public void after(JoinPoint joinPoint) { logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法执行结束。"); } @Around(value = "execution(* org.westos.service.*.*(..))") public Object around(ProceedingJoinPoint joinPoint) throws Throwable { logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法入参：" + Arrays.toString(joinPoint.getArgs())); try { Object result = joinPoint.proceed(); logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法返回值：" + result); return result; } catch (Throwable e) { logger.error("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法抛出异常：" + e); throw e; } finally { logger.info("调用" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，方法执行结束。"); } } }

测试目标方法无异常：

@Test public void test() { //基于注解，测试方法无异常 ApplicationContext context = new ClassPathXmlApplicationContext("application.xml"); UserService userService = (UserService) context.getBean("userServiceImpl"); User user = (User) context.getBean("user"); userService.addUser(user); }

1、环绕增强

[org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:68) ] 2020/10/08 17:13:35INFO [UserServiceLogger] - org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:68) - 调用org.westos.service.impl.UserServiceImpl@d29f28的addUser方法，方法入参：[org.westos.entity.User@37654521]

2、前置增强

[org.westos.aop.UserServiceLogger.before(UserServiceLogger.java:29) ] 2020/10/08 17:13:35INFO [UserServiceLogger] - org.westos.aop.UserServiceLogger.before(UserServiceLogger.java:29) - 调用org.westos.service.impl.UserServiceImpl@d29f28的addUser方法，方法入参：[org.westos.entity.User@37654521]

UserServiceImpl >>> addUser UserMapperImpl >>> addUser

3、后置增强

[org.westos.aop.UserServiceLogger.afterReturning(UserServiceLogger.java:40) ] 2020/10/08 17:13:35INFO [UserServiceLogger] - org.westos.aop.UserServiceLogger.afterReturning(UserServiceLogger.java:40) - 调用org.westos.service.impl.UserServiceImpl@d29f28的addUser方法，方法返回值：1

4、最终增强

[org.westos.aop.UserServiceLogger.after(UserServiceLogger.java:61) ] 2020/10/08 17:13:35INFO [UserServiceLogger] - org.westos.aop.UserServiceLogger.after(UserServiceLogger.java:61) - 调用org.westos.service.impl.UserServiceImpl@d29f28的addUser方法，方法执行结束。

5、环绕增强

[org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:72) ] 2020/10/08 17:13:35INFO [UserServiceLogger] - org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:72) - 调用org.westos.service.impl.UserServiceImpl@d29f28的addUser方法，方法返回值：1

6、环绕增强

[org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:80) ] 2020/10/08 17:13:35INFO [UserServiceLogger] - org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:80) - 调用org.westos.service.impl.UserServiceImpl@d29f28的addUser方法，方法执行结束。

测试目标方法抛出异常：

@Override public int addUser(User user) { if (true) { throw new ArrayIndexOutOfBoundsException(); } System.out.println("UserServiceImpl >>> addUser"); return userMapper.addUser(user); }

1、环绕增强

[org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:68) ] 2020/10/08 17:18:08INFO [UserServiceLogger] - org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:68) - 调用org.westos.service.impl.UserServiceImpl@d29f28的addUser方法，方法入参：[org.westos.entity.User@37654521]

2、前置增强

[org.westos.aop.UserServiceLogger.before(UserServiceLogger.java:29) ] 2020/10/08 17:18:08INFO [UserServiceLogger] - org.westos.aop.UserServiceLogger.before(UserServiceLogger.java:29) - 调用org.westos.service.impl.UserServiceImpl@d29f28的addUser方法，方法入参：[org.westos.entity.User@37654521]

3、异常抛出增强

[org.westos.aop.UserServiceLogger.afterThrowing(UserServiceLogger.java:51) ] 2020/10/08 17:18:08ERROR [UserServiceLogger] - org.westos.aop.UserServiceLogger.afterThrowing(UserServiceLogger.java:51) - 调用org.westos.service.impl.UserServiceImpl@d29f28的addUser方法，方法抛出异常：java.lang.ArrayIndexOutOfBoundsException

4、最终增强

[org.westos.aop.UserServiceLogger.after(UserServiceLogger.java:61) ] 2020/10/08 17:18:08INFO [UserServiceLogger] - org.westos.aop.UserServiceLogger.after(UserServiceLogger.java:61) - 调用org.westos.service.impl.UserServiceImpl@d29f28的addUser方法，方法执行结束。

5、环绕增强

[org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:76) ] 2020/10/08 17:18:08ERROR [UserServiceLogger] - org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:76) - 调用org.westos.service.impl.UserServiceImpl@d29f28的addUser方法，方法抛出异常：java.lang.ArrayIndexOutOfBoundsException

6、环绕增强

[org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:80) ] 2020/10/08 17:18:08INFO [UserServiceLogger] - org.westos.aop.UserServiceLogger.around(UserServiceLogger.java:80) - 调用org.westos.service.impl.UserServiceImpl@d29f28的addUser方法，方法执行结束。