Spring AOP的两种代码使用方法

本篇文章小编给大家分享一下Spring AOP的两种代码使用方法，文章代码介绍的很详细，小编觉得挺不错的，现在分享给大家供大家参考，有需要的小伙伴们可以来看看。

1 注解方式

1.1 声明目标类 UserDao 类

@Repository("userDao")
public class UserDao {

    public void addUser() {
        System.out.println("? 拦截的方法 addUser 开始执行");
    }
}

1.2 声明切面 AnnotationAspect 类

@Aspect
@Component
public class AnnotationAspect {

    // 定义切入点表达式, 使用一个返回值为 void、方法体为空的方法来命名切入点
    @Pointcut("execution(* com.fairy.springmvc.aspectj.annotation.*.*(..))")
    private void customPointCut(){}

    // 前置通知
    @Before("customPointCut()")
    public void myBefore(JoinPoint joinPoint){
        System.out.print("前置通知：模拟执行权限检查..，");
        System.out.print("目标类是：" + joinPoint.getTarget());
        System.out.println("，被植入增强处理的目标方法为：" + joinPoint.getSignature().getName());
    }

    // 后置通知
    @AfterReturning(value="customPointCut()")
    public void myAfterReturning(JoinPoint joinPoint) {
        System.out.print("后置通知：模拟记录日志..，");
        System.out.println("被植入增强处理的目标方法为：" + joinPoint.getSignature().getName());
    }

    /**
     * 环绕通知
     * ProceedingJoinPoint 是 JoinPoint的子接口，表示可执行目标方法
     * 1.必须是 Object 类型的返回值
     * 2.必须接收一个参数，类型为 ProceedingJoinPoint
     * 3.必须 throws Throwable
     */
    @Around("customPointCut()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        // 开始
        System.out.println("环绕开始：执行目标方法之前，模拟开启事务..，");
        // 执行当前目标方法
        Object obj = proceedingJoinPoint.proceed();
        // 结束
        System.out.println("环绕结束：执行目标方法之后，模拟关闭事务..，");
        return obj;
    }

    /**
     * 异常通知处理
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(value="customPointCut()",throwing="e")
    public void myAfterThrowing(JoinPoint joinPoint, Throwable e){
        System.out.println("异常通知：出错了" + e.getMessage());
    }

    // 最终通知
    @After("customPointCut()")
    public void myAfter(){
        System.out.println("最终通知：模拟方法结束后释放资源..");
    }
}

1.3 声明配置

开启@AspectJ的注解配置方式，有两种方式

1 在xml文件，添加以下配置：

2 使用了Java代码风格的配置，则需使用EnableAspectJAutoProxy注解

示例如下

@Configuration
@EnableAspectJAutoProxy
@ComponentScan("com.fairy.springmvc")
public class ApplicationConfig {
    ....
}

1.4 测试用例

public class TestCase {
    @Test
    public void testAnnotation() throws Exception {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "spring-test.xml");

        // 从容器中获得内容
        UserDao userDao= (UserDao) applicationContext.getBean("userDao");
        // 执行方法
        userDao.addUser();
    }
}

运行结果如下：

环绕开始：执行目标方法之前，模拟开启事务..，

前置通知：模拟执行权限检查..，

目标类是：com.fairy.springmvc.aspectj.annotation.UserDao@4a699efa，

被植入增强处理的目标方法为：addUser

? 拦截的方法 addUser 开始执行

后置通知：模拟记录日志..，被植入增强处理的目标方法为：addUser

最终通知：模拟方法结束后释放资源..

环绕结束：执行目标方法之后，模拟关闭事务..，

通过输出结果看出，符合预期。

2 XML 配置方式

2.1 声明目标类 CompanyDao

@Repository("companyDao")
public class CompanyDao {

    public void addCompany() {
        System.out.println("? 真正的业务处理：add company ?");
    }

    public void exception() throws Exception {
        throw new Exception("业务异常了");
    }
}

2.2 声明切面拦截类 XmlAspect

@Component("xmlAspectConfig")
public class XmlAspect {

    public void printUnderscore() {
        System.out.println("------------------------------------------------");
    }

    /**
     * 在核心业务执行前执行，不能阻止核心业务的调用
     * @param joinPoint
     */
    public void beforeAdvice(JoinPoint joinPoint) {
        printUnderscore();
        System.out.println("1️⃣ 通知：beforeAdvice 执行开始");
        System.out.println("   执行核心业务逻辑前，可以做一些前置的安全性的检测等");
        System.out.println("   通知：beforeAdvice 执行结束");
        printUnderscore();
    }

    /**
     * 核心业务退出后，不管是正常结束还是异常退出，均执行此通知
     * @param joinPoint
     */
    public void afterAdvice(JoinPoint joinPoint) {
        printUnderscore();
        System.out.println("4️⃣ 通知：afterAdvice 执行开始");
        System.out.println("   此处可以对返回值做进一步的处理");
        System.out.println("   通知：afterAdvice 执行结束");
    }

    /**
     * 核心业务调用正常退出后，不管是否有返回值，只要是正常退出，都会执行此通知
     * @param joinPoint
     */
    public void afterReturningAdvice(JoinPoint joinPoint) {
        printUnderscore();
        System.out.println("2️⃣ 通知：afterReturningAdvice 执行开始");
        System.out.println("   此处可以对返回值做进一步处理");
        System.out.println("   通知：afterReturningAdvice 执行结束");
    }

    /**
     * 核心业务逻辑调用异常退出后，执行此通知，处理错误信息
     * @param e
     */
    public void afterThrowingAdvice(Exception e) {
        printUnderscore();
        System.out.println("3️⃣ 通知：afterThrowingAdvice 执行开始");
        System.out.println("   错误信息：" + e.getMessage());
        System.out.println("   此处意味着，在核心业务逻辑出错时，捕获异常，并可以做一些日志记录相关的操作");
    }

    /**
     * 手动控制调用核心业务逻辑，以及调用前和调用后的处理
     * @param pjp
     */
    public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
        // 开始
        System.out.println("5️⃣ 环绕开始：执行目标方法之前");
        System.out.println("   此处可以做类似于 Before Advice 的事情");
        // 调用核心逻辑，执行当前目标方法
        Object obj = pjp.proceed();

        // 打印下划线
        printUnderscore();
        // 结束
        System.out.println("   此处可以做类似于 After Advice 的事情");
        System.out.println("5️⃣ 环绕结束：执行目标方法之后");
        return obj;
    }
}

2.3 声明 XML 配置

注意：

值得注意的是around与before和after的执行顺序。3者的执行顺序取决于在xml中的配置顺序。

2.3 测试用例

public class TestCase {
    @Test
    public void testAnnotation() throws Exception {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "spring-test.xml");

        CompanyDao companyDao = (CompanyDao) applicationContext.getBean("companyDao");
        companyDao.addCompany();
        // companyDao.exception();
    }

}

输出结果如下:

-------------------------------

5️⃣ 环绕开始：执行目标方法之前

此处可以做类似于 Before Advice 的事情

------------------------------------------------

1️⃣ 通知：beforeAdvice 执行开始

执行核心业务逻辑前，可以做一些前置的安全性的检测等

通知：beforeAdvice 执行结束

------------------------------------------------

? 真正的业务处理：add company ?

------------------------------------------------

2️⃣ 通知：afterReturningAdvice 执行开始

此处可以对返回值做进一步处理

通知：afterReturningAdvice 执行结束

------------------------------------------------

4️⃣ 通知：afterAdvice 执行开始

此处可以对返回值做进一步的处理

通知：afterAdvice 执行结束

------------------------------------------------

此处可以做类似于 After Advice 的事情

5️⃣ 环绕结束：执行目标方法之后

结果符合预期。