Spring 框架AOP

最新推荐文章于 2023-08-04 16:08:03 发布

caoyue_new

最新推荐文章于 2023-08-04 16:08:03 发布

阅读量403

点赞数

分类专栏： Spring 框架文章标签： spring 框架实例

本文链接：https://blog.csdn.net/caoyue_new/article/details/52797296

版权

Spring 框架专栏收录该内容

24 篇文章 0 订阅

订阅专栏

AspectJ：Java 社区里最完整最流行的 AOP 框架.
要在 Spring 中声明 AspectJ 切面, 只需要在 IOC 容器中将切面声明为 Bean 实例. 当在 Spring IOC 容器中初始化 AspectJ 切面之后, Spring IOC 容器就会为那些与 AspectJ 切面相匹配的 Bean 创建代理.
在 AspectJ 注解中, 切面只是一个带有 @Aspect 注解的 Java 类.
通知是标注有某种注解的简单的 Java 方法.

AspectJ 支持 5 种类型的通知注解:

@Before: 前置通知, 在方法执行之前执行
@After: 后置通知, 在方法执行之后执行
@AfterRunning: 返回通知, 在方法返回结果之后执行
@AfterThrowing: 异常通知, 在方法抛出异常之后
@Around: 环绕通知, 围绕着方法执行

例子（加减乘除计算）

需要引入aspectJ相关的jar包
maven配置

<dependency>
    <groupId>aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.5.4</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.0.RELEASE</version>
</dependency>
<dependency>
    <groupId>aopalliance</groupId>
    <artifactId>aopalliance</artifactId>
    <version>1.0</version>
</dependency>

首先我们这里使用注解的方式进行说明。

spring-aop.xml

<?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"
    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
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:component-scan base-package="com.spring.aop.helloworld"></context:component-scan>

    <!-- 使 AspectJ 的注解起作用 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

ArithmeticCalculator.java

package com.spring.aop.helloworld;

public interface ArithmeticCalculator {

    int add(int i, int j);
    int sub(int i, int j);

    int mul(int i, int j);
    int div(int i, int j);
}

ArithmeticCalculatorImpl.java

package com.spring.aop.helloworld;

import org.springframework.stereotype.Component;

@Component("arithmeticCalculator")
public class ArithmeticCalculatorImpl implements ArithmeticCalculator {

    public int add(int i, int j) {
        int result = i + j;
        return result;
    }

    public int sub(int i, int j) {
        int result = i - j;
        return result;
    }

    public int mul(int i, int j) {
        int result = i * j;
        return result;
    }

    public int div(int i, int j) {
        int result = i / j;
        return result;
    }
}

LoggingAspect.java

package com.spring.aop.helloworld;

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 在同一个连接点上应用不止一个切面时, 除非明确指定, 否则它们的优先级是不确定的.
 * 切面的优先级可以通过实现 Ordered 接口或利用 @Order 注解指定.
 * 实现 Ordered 接口, getOrder() 方法的返回值越小, 优先级越高.
 * 若使用 @Order 注解, 序号出现在注解中
 * @author cye
 *
 */
@Order(2)
@Aspect
@Component
public class LoggingAspect {

    /**
     * 用于声明切入点表达式，一般该方法中不需要添加其他代码
     * 使用@Pointcut来声明切入点表达式
     * 后面其他通知直接使用方法名来引用当前的切入点表达式
     * 第一个 * 代表任意修饰符及任意返回值. 第二个 * 代表任意方法. .. 匹配任意数量的参数.
     */
    @Pointcut("execution(* int com.spring.aop.helloworld.ArithmeticCalculator.*(..))")
    public void declareJoinPointExpression() {}

    /**
     * 前置通知
     * 在方法执行之前执行
     * @param joinPoint
     */
    @Before("declareJoinPointExpression()")
    public void beforeMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " begins with " + Arrays.asList(joinPoint.getArgs()));
    }

    /**
     * 后置通知
     * 在方法执行之后执行，无论方法是否出现异常
     * @param joinPoint
     */
    @After("declareJoinPointExpression()")
    public void afterMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " ends with " + Arrays.asList(joinPoint.getArgs()));
    }

    /**
     * 返回通知
     * 在方法正常执行之后执行
     * 可以访问到方法的返回值
     */
    @AfterReturning(value="declareJoinPointExpression()", returning="result")
    public void afterReturningMethod(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " afterReturning with " + Arrays.asList(joinPoint.getArgs()) + ", result is " + result);
    }

    /**
     * 异常通知
     * 在目标方法出现异常时执行
     * 可以访问到异常对象，且可以指定在出现特定异常时再执行
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(value="execution(public int com.spring.aop.helloworld.ArithmeticCalculator.*(..))", throwing="e")
    public void afterThrowingMethod(JoinPoint joinPoint, ArithmeticException e) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " occurs exception " + e);
    }

    /**
     * 环绕通知
     * 需要带有ProceedingJoinPoint类型的参数，可以决定是否有执行目标方法
     *      ProceedingJoinPoint . 它是 JoinPoint 的子接口, 允许控制何时执行, 是否执行连接点.
     * 且环绕通知必须有返回值，返回值即为目标方法的返回值
     * @param joinPoint
     */
    @Around(value="execution(public int com.spring.aop.helloworld.ArithmeticCalculator.*(..))")
    public Object aroundMethod(ProceedingJoinPoint pjp) {
        String methodName = pjp.getSignature().getName();

        Object result = null;
        try {
            //前置通知
            System.out.println("The method " + methodName + " begins with " + Arrays.asList(pjp.getArgs()));
            //执行方法
            result = pjp.proceed();
            //返回通知, 可以访问到方法的返回值
            System.out.println("The method " + methodName + " returns with " + Arrays.asList(pjp.getArgs()));
        } catch (Throwable e) {
            //异常通知, 可以访问到方法出现的异常
            System.out.println("The method occurs exception:" + e);
            throw new RuntimeException(e);

        }

        //后置通知. 因为方法可以能会出异常, 所以访问不到方法的返回值
        System.out.println("The method " + methodName + " ends with " + Arrays.asList(pjp.getArgs()));
        return result;
    }
}

ValidateAspect.java

package com.spring.aop.helloworld;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 
 * @author cye
 *
 */
@Order(1)
@Aspect
@Component
public class ValidateAspect {

    /**
     * 前置通知
     * 在方法执行之前执行
     * @param joinPoint
     */
    @Before("LoggingAspect.declareJoinPointExpression()")
    public void validateMethod(JoinPoint joinPoint) {
        System.out.println("The validateMethod method ");
    }   
}

Main.java

package com.spring.aop.helloworld;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-aop.xml");
        ArithmeticCalculator arithmeticCalculator = (ArithmeticCalculator) ctx.getBean("arithmeticCalculator");

        int result = arithmeticCalculator.add(11, 12);
        System.out.println("result:" + result);

        result = arithmeticCalculator.div(21, 3);
        System.out.println("result:" + result);
    }
}

注解方式

下面我们只把xml配置文件给出，具体类参考上面的。

<?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"
    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
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置bean -->
    <bean id="arithmeticCalculator" class="com.spring.aop.test.ArithmeticCalculatorImpl"></bean>
    <!-- 配置切面的bean -->
    <bean id="loggingAspect" class="com.spring.aop.test.LoggingAspect"></bean>
    <bean id="validateAspect" class="com.spring.aop.test.ValidateAspect"></bean>

    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切面表达式 -->
        <aop:pointcut expression="execution(* com.spring.aop.test.ArithmeticCalculator.*(int, int))" id="pointcut"/>
        <!-- 配置切面及通知 -->
        <aop:aspect ref="loggingAspect" order="2">
            <aop:before method="beforeMethod" pointcut-ref="pointcut"/>
            <aop:after method="afterMethod" pointcut-ref="pointcut"/>
            <aop:after-returning method="afterReturningMethod" pointcut-ref="pointcut" returning="result"/>
            <aop:after-throwing method="afterThrowingMethod" pointcut-ref="pointcut" throwing="e"/>
            <aop:around method="aroundMethod" pointcut-ref="pointcut"/>
        </aop:aspect>
        <aop:aspect ref="validateAspect" order="1">
            <aop:before method="validateMethod" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
</beans>