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

本文介绍了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);
    }




评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值