spring学习总结(九)：AOP 基础及基于注解配置的AOP

本文链接：https://blog.youkuaiyun.com/yuchao2015/article/details/53859582

本文介绍了Spring AOP的基础知识，包括AOP的概念、优点和核心术语。详细阐述了如何使用@Before、@After、@AfterReturning、@AfterThrowing和@Around注解实现不同类型的通知，并展示了在Spring中启用AspectJ注解支持的步骤。此外，还讨论了切面的优先级设置和重用切入点定义的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

AOP 前奏

代码实现

Calculator.java

public interface Calculator {

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

CalculatorLogger.java

public class CalculatorLogger implements Calculator {

    @Override
    public int add(int i, int j) {
        System.out.println("The method add with ["+i+" , "+j+"]");
        
        int result = i + j;
        System.out.println("The method add ends with"+ result); 
        
        return result;
    }

    @Override
    public int sub(int i, int j) {
        System.out.println("The method sub with ["+i+" , "+j+"]");
        
        int result = i - j;
        System.out.println("The method sub ends with"+ result); 
        
        return result;
    }

    @Override
    public int mul(int i, int j) {
        System.out.println("The method mul with ["+i+" , "+j+"]");
        
        int result = i * j;
        System.out.println("The method mul ends with"+ result); 
        
        return result;
        
    }

    @Override
    public int div(int i, int j) {
        System.out.println("The method div with ["+i+" , "+j+"]");
        
        int result = i / j;
        System.out.println("The method div ends with"+ result); 
        
        return result;
    }

}

ApplicationBasic.java

public class ApplicationBasic {

    
    public static void main(String[] args) {
        
        
        Calculator calculator = null;
        
        calculator = new CalculatorLogger();
        
        int result = calculator.add(3, 2);
        System.out.println("-->"+result);
        
        
        result = calculator.div(9, 3);
        System.out.println("-->"+result);
        
    }
}

测试结果：

上述实现问题：

代码混乱：越来越多的非业务需求(日志和验证等)加入后,原有的业务方法急剧膨胀. 每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点.
代码分散: 以日志需求为例, 只是为了满足这个单一需求, 就不得不在多个模块（方法）里多次重复相同的日志代码.如果日志需求发生变化, 必须修改所有模块.

使用动态代理解决上述问题

代理设计模式的原理: 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上.

代码实现：

CalculatorLogger.java

public class CalculatorLogger implements Calculator {

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

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

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

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

}

CalculatorLoggerProxy.java

/**
 * 
 * @ClassName:  CalculatorLoggerProxy   
 * @Description:动态代理实现AOP
 * @author: xyc 
 * @date:   2016年12月24日 下午8:25:01   
 *
 */
public class CalculatorLoggerProxy {

    //要代理的对象
    private Calculator target;
    
    public CalculatorLoggerProxy(Calculator target) {
        this.target = target;
    }
    
    public Calculator getLoggerProxy(){
        Calculator proxy = null;
        
        //打理对象由哪一个类加载器加载
        ClassLoader loader = target.getClass().getClassLoader();
        //代理对象的类型，即其中有那些方法
        Class[] interfaces = new Class[]{Calculator.class};
        
        //当调用代理对象其中的方法时，该执行的代码
        InvocationHandler h = new InvocationHandler() {
            /**
             * 
             * <p>Title: invoke</p>   
             * <p>Description: </p>   
             * @param proxy 正在返回的那个代理对象，一般情况下，在invoke方法中不使用该对象
             * @param method 正在被调用的那个方法
             * @param args  调用方法时，传递的参数
             * @return
             * @throws Throwable   
             * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                
                String methodName = method.getName();
                
                //执行方法
                Object result = null ;
                try {
                    //前置通知
                    System.out.println("The method "+methodName+" with "+Arrays.asList(args));
                    result = method.invoke(target, args);
                    //返回通知
                } catch (Exception e) {
                    //异常通知
                }
                //后置通知
                System.out.println("The method "+result+" ends with"+ result);
                
                return result;
            }
        };
        proxy = (Calculator) Proxy.newProxyInstance(loader, interfaces, h);
        
        return proxy;
    }
}

ApplicationProxy.java

public class ApplicationProxy {

    
    public static void main(String[] args) {
        
        CalculatorLogger calculatorLogger = new CalculatorLogger();
        
        Calculator proxy = new CalculatorLoggerProxy(calculatorLogger).getLoggerProxy();
        
        int result = proxy.add(3, 2);
        System.out.println("-->"+result);
        
        
        result = proxy.div(9, 3);
        System.out.println("-->"+result);
        
    }
}

测试结果：

好了，说了这么多，到底什么是Aop?

AOP简介

AOP(Aspect-Oriented Programming, 面向切面编程): 是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充.
AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点.
在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方式应用,并且不必修改受影响的类. 这样一来横切关注点就被模块化到特殊的对象(切面)里.

AOP 的好处:

每个事物逻辑位于一个位置, 代码不分散, 便于维护和升级
业务模块更简洁, 只包含核心业务代码.

AOP 术语

切面(Aspect): 横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象上述图中业务逻辑模块一个个具体
通知(Advice): 切面必须要完成的工作，切面中的每一个方法称为通知
目标(Target): 被通知的对象
代理(Proxy): 向目标对象应用通知之后创建的对象
连接点（Joinpoint）：程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等。连接点由两个信息确定：方法表示的程序执行点；相对点表示的方位。例如 ArithmethicCalculator#add() 方法执行前的连接点，执行点为 ArithmethicCalculator#add()；方位为该方法执行前的位置
切点（pointcut）：每个类都拥有多个连接点：例如 ArithmethicCalculator 的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务。AOP 通过切点定位到特定的连接点。类比：连接点相当于数据库中的记录，切点相当于查询条件。切点和连接点不是一对一的关系，一个切点匹配多个连接点，切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

Spring AOP

AspectJ：Java 社区里最完整最流行的 AOP 框架.
在 Spring2.0 以上版本中, 可以使用基于 AspectJ 注解或基于 XML 配置的 AOP

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

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

在 Spring 中启用 AspectJ 注解支持

①.引入依赖

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>4.3.2.RELEASE<version>
</dependency>

<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjrt</artifactId>
	<version>1.6.11</version>
</dependency>
<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjweaver</artifactId>
	<version>1.6.11</version>
</dependency>

②要在 Spring IOC 容器中启用 AspectJ 注解支持, 只要在 Bean 配置文件中定义一个空的 XML 元素 <aop:aspectj-autoproxy> 当 Spring IOC 容器侦测到 Bean 配置文件中的 <aop:aspectj-autoproxy> 元素时, 会自动为与 AspectJ 切面匹配的 Bean 创建代理.

③.在切面类中使用@Aspect，然后在类中声明各种通知

④.可以在通知方法中声明一个类型为JoinPoint的参数，然后就能访问链接明细，如方法名称和参数

⑤.切入点表达式根据方法的签名来匹配各种方法（execution(* com.xyc.spring.aop.CalculatorLogger.*(..) ）第一个 * 代表任意修饰符及任意返回值. 第二个 * 代表任意方法. .. 匹配任意数量的参数

⑥.在 AspectJ 中, 切入点表达式可以通过操作符 &&, ||, ! 结合起来. （execution(* com.xyc.spring.aop.CalculatorLogger.add(..) || execution(* com.xyc.spring.aop.CalculatorLogger.div(..)）

前置通知:

前置通知:在方法执行之前执行的通知
前置通知使用 @Before 注解, 并将切入点表达式的值作为注解值.

/**
 * 
 * @ClassName:  LoggerAspectJ   
 * @Description:把这个类声明为一个切面：需要先将该类放入到IOC容器中，然后在声明为切面
 * @author: xyc 
 * @date:   2016年12月24日 下午6:04:05   
 *
 */
@Component
@Aspect
public class LoggerAspectJ { 
    /**
     * 
     * @Title: beforeMethod   
     * @Description: 声明该方法是一个前置通知：在目标方法之前执行
     * @param: @param joinPoint      
     * @return: void      
     * @throws
     */
    @Before("execution(* com.xyc.spring.aop.Calculator.*(..))")
    public void beforeMethod(JoinPoint joinPoint){
        System.out.println("This is 前置通知");
    }
}

后置通知:

后置通知是在连接点完成之后执行的, 即连接点返回结果或者抛出异常的时候, 下面的后置通知记录了方法的终止.
一个切面可以包括一个或者多个通知.

/**
 * 
 * @ClassName:  LoggerAspectJ   
 * @Description:把这个类声明为一个切面：需要先将该类放入到IOC容器中，然后在声明为切面
 * @author: xyc 
 * @date:   2016年12月24日 下午6:04:05   
 *
 */
@Component
@Aspect
public class LoggerAspectJ {
    /**
     * 
     * @Title: afterMethod   
     * @Description: 后置通知：在目标方法执行后执行(无论执行目标方法过程中是否发生异常都会执行)，执行的通知 
     * @param: @param joinPoint      
     * @return: void      
     * @throws
     */
    @After("execution(* com.xyc.spring.aop.Calculator.*(..))")
    public void afterMethod(JoinPoint joinPoint){
        System.out.println("This is 后置通知");
    }
}

返回通知：

无论连接点是正常返回还是抛出异常, 后置通知都会执行. 如果只想在连接点返回的时候记录日志, 应使用返回通知代替后置通知.
在返回通知中, 只要将 returning 属性添加到 @AfterReturning 注解中, 就可以访问连接点的返回值. 该属性的值即为用来传入返回值的参数名称.
必须在通知方法的签名中添加一个同名参数. 在运行时, Spring AOP 会通过这个参数传递返回值.
原始的切点表达式需要出现在 pointcut 属性中

/**
     * 
     * @Title: afterReturning   
     * @Description: 在方法正常结束后执行的代码  返回通知是可以访问到方法的返回值的
     * @param: @param joinPoint
     * @param: @param result      
     * @return: void      
     * @throws
     */
    @AfterReturning(value="execution(* com.xyc.spring.aop.Calculator.*(..))",returning="result")
    public void afterReturning(JoinPoint joinPoint,Object result){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method "+methodName+" result "+result);
    }

异常通知：

只在连接点抛出异常时才执行异常通知
将 throwing 属性添加到 @AfterThrowing 注解中, 也可以访问连接点抛出的异常. Throwable 是所有错误和异常类的超类. 所以在异常通知方法可以捕获到任何错误和异常.
如果只对某种特殊的异常类型感兴趣, 可以将参数声明为其他异常的参数类型. 然后通知就只在抛出这个类型及其子类的异常时才被执行.

/**
     * 
     * @Title: afterThrowing   
     * @Description: 在目标方法出现异常时会执行的代码   可以访问到异常对象，切可以指定在出现特定异常时再执行通知代码
     * @param: @param joinPoint
     * @param: @param e      
     * @return: void      
     * @throws
     */
    @AfterThrowing(value="execution(* com.xyc.spring.aop.Calculator.*(..))",throwing="e")
    public void afterThrowing(JoinPoint joinPoint,Exception e){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method "+methodName+" Exception "+e);
    }

环绕通知：

环绕通知是所有通知类型中功能最为强大的, 能够全面地控制连接点. 甚至可以控制是否执行连接点.
对于环绕通知来说, 连接点的参数类型必须是 ProceedingJoinPoint . 它是 JoinPoint 的子接口, 允许控制何时执行, 是否执行连接点.
在环绕通知中需要明确调用 ProceedingJoinPoint 的 proceed() 方法来执行被代理的方法. 如果忘记这样做就会导致通知被执行了, 但目标方法没有被执行.
注意: 环绕通知的方法需要返回目标方法执行之后的结果, 即调用 joinPoint.proceed(); 的返回值, 否则会出现空指针异常

    /**
     * 
     * @Title: around   
     * @Description:  环绕通知需要携带 ProceedingJoinPoint 类型的参数
     * 环绕通知类似于动态代理的全过程，ProceedingJoinPoint 类型的参数可以决定是否执行目标方法.
     * 且环绕通知必须有返回值，返回值即为目标方法的返回值
     * @param: @param pjp
     * @param: @return      
     * @return: Object      
     * @throws
     */
    @Around("execution(* com.xyc.spring.aop.Calculator.*(..))")
    public Object around(ProceedingJoinPoint pjp){
        
        Object result = null;
        String methodName = pjp.getSignature().getName();
        
        try {
            //前置通知、
            System.out.println("The method "+methodName+" with "+Arrays.asList(pjp.getArgs()));
            //执行目标方法
            result = pjp.proceed();
            //返回通知
            System.out.println("The method "+methodName+" result "+result);
        } catch (Throwable e) {
            //异常通知
            System.out.println("The method "+methodName+" Exception "+e);
            throw new RuntimeException(e);
        }
        //后置通知
        System.out.println("The method "+methodName+" end ");
        return result;
    }

AOP实现前奏需求：

LoggerAspectJ.java

package com.xyc.spring.aop;

import java.util.Arrays;
import java.util.List;

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


/**
 * 
 * @ClassName:  LoggerAspectJ   
 * @Description:把这个类声明为一个切面：需要先将该类放入到IOC容器中，然后在声明为切面
 * @author: xyc 
 * @date:   2016年12月24日 下午6:04:05   
 *
 */
@Component
@Aspect
public class LoggerAspectJ {

    
    /**
     * 
     * @Title: beforeMethod   
     * @Description: 声明该方法是一个前置通知：在目标方法之前执行
     * @param: @param joinPoint      
     * @return: void      
     * @throws
     */
    @Before("execution(* com.xyc.spring.aop.Calculator.*(int, int))")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("The method "+methodName+" with "+args);
    }
    
    /**
     * 
     * @Title: afterMethod   
     * @Description: 后置通知：在目标方法执行后执行(无论执行目标方法过程中是否发生异常都会执行)，执行的通知 
     * @param: @param joinPoint      
     * @return: void      
     * @throws
     */
    @After("execution(* com.xyc.spring.aop.Calculator.*(int, int))")
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        //在后置通知中不能访问目标方法执行的结果
        System.out.println("The method "+methodName+" end ");
    }
}

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

	<!-- 配置自动扫描包 -->
	<context:component-scan base-package="com.xyc.spring.aop"></context:component-scan>
	
	<!-- 使用aspectj注解起作用：自动为匹配的类生成代理对象 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

ApplicationAop.java

/**
 * 
 * @ClassName:  ApplicationAop   
 * @Description:测试AOP
 * @author: xyc 
 * @date:   2016年12月24日 下午6:12:59   
 *
 */
public class ApplicationAop {

    public static void main(String[] args) {
        
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationAop.xml");
        
        Calculator bean = context.getBean(Calculator.class);
        
        int result = bean.add(3, 2);
        System.out.println("-->"+result);
        
        
        result = bean.div(9, 3);
        System.out.println("-->"+result);
    }
}

测试结果：

切面的优先级

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

@Order(2)
@Aspect
@Component
public class LoggerAspectJ {}

@Order(1)
@Aspect
@Component
public class ViladationAspectj {}

重用切入点定义

在编写 AspectJ 切面时, 可以直接在通知注解中书写切入点表达式. 但同一个切点表达式可能会在多个通知中重复出现.
在 AspectJ 切面中, 可以通过 @Pointcut 注解将一个切入点声明成简单的方法. 切入点的方法体通常是空的, 因为将切入点定义与应用程序逻辑混在一起是不合理的.
切入点方法的访问控制符同时也控制着这个切入点的可见性. 如果切入点要在多个切面中共用, 最好将它们集中在一个公共的类中. 在这种情况下, 它们必须被声明为 public. 在引入这个切入点时, 必须将类名也包括在内. 如果类没有与这个切面放在同一个包中, 还必须包含包名.
其他通知可以通过方法名称引入该切入点.

同一个类中，只需要引入方法名称.

     /**
     * 
     * @Title: declareJoinPointExpression   
     * @Description: 定义一个方法，声明切入点表达式，该方法不需要其他代码 
     * @param:       
     * @return: void      
     * @throws
     */
    @Pointcut("execution(* com.xyc.spring.aop.Calculator.*(..))")
    public void declareJoinPointExpression(){}
    
    
    @Before("declareJoinPointExpression()")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("The method "+methodName+" with "+args);
    }

同包不同类中，需要类名.方法

@Before("LoggerAspectJ.declareJoinPointExpression()")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("--->ViladationAspectj "+methodName+" with "+args);
    }

不同包下，需要全类名.方法

@Before("com.xyc.spring.aop.LoggerAspectJ.declareJoinPointExpression()")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("--->ViladationAspectj "+methodName+" with "+args);
    }