Spring_动态代理_通知的执行顺序

最新推荐文章于 2023-08-09 22:00:00 发布
最新推荐文章于 2023-08-09 22:00:00 发布
阅读量6.5k 收藏 4
点赞数 5
分类专栏： Spring
记录平时的问题，完全是给自己看的，垃圾博客，浪费各位大佬时间...
本文链接：https://blog.csdn.net/qq_40794973/article/details/97317835
版权

 

 

 

 

一、单切面-普通通知

 目标对象

@Service
public class MyMathCalculator{
	/**
	 * 加法
	 */
	public int add(int i, int j) {
		int result = i + j;
		System.out.println("方法内部执行");
		return result;
	}
	/**
	 * 减法
	 */
	public int sub(int i, int j) {
		int result = i - j;
		System.out.println("方法内部执行");
		return result;
	}
	/**
	 * 乘法
	 */
	public int mul(int i, int j) {
		//方法的兼容性；
		int result = i * j;
		System.out.println("方法内部执行");
		return result;
	}
	/**
	 * 除法
	 */
	public int div(int i, int j) {
		int result = i / j;
		System.out.println("方法内部执行");
		return result;
	}
}

@Aspect
@Component
public class LogUtils {
	/**
	 * @Before：在目标方法之前运行；  					 前置通知
	 * @After：在目标方法结束之后						后置通知
	 * @AfterReturning：在目标方法正常返回之后			返回通知
	 * @AfterThrowing：在目标方法抛出异常之后运行			异常通知
	 * @Around：环绕								环绕通知
	 */
	@Pointcut("execution(public int com.atguigu.impl.MyMathCalculator.*(..))")
	public void hahaMyPoint(){};

    //想在执行目标方法之前运行；写切入点表达式
	@Before("hahaMyPoint()")
	public static void logStart(JoinPoint joinPoint){
		//获取到目标方法运行是使用的参数
		Object[] args = joinPoint.getArgs();
		//获取到方法签名
		Signature signature = joinPoint.getSignature();
		String name = signature.getName();
		System.out.println("[LogUtils-前置]【"+name+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
	}
    //想在目标方法正常执行完成之后执行
	@AfterReturning(value="hahaMyPoint()",returning="result")
	public static void logReturn(JoinPoint joinPoint,Object result){
		Signature signature = joinPoint.getSignature();
		String name = signature.getName();
		System.out.println("[LogUtils-返回]【"+name+"】方法正常执行完成，计算结果是："+result);
	}
    //想在目标方法出现异常的时候执行
    @AfterThrowing(value="hahaMyPoint()",throwing="exception")
    public static void logException(JoinPoint joinPoint,Exception exception) {
        System.out.println("[LogUtils-异常]【"+joinPoint.getSignature().getName()+"】方法执行出现异常了，异常信息是【"+exception+"】：；这个异常已经通知测试小组进行排查");
    }

    //想在目标方法结束的时候执行
    @After("hahaMyPoint()")
	private int logEnd(JoinPoint joinPoint) {
		System.out.println("[LogUtils-后置]【"+joinPoint.getSignature().getName()+"】方法最终结束了");
		return 0;
	}
}

ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");

@Test
public void test02(){
	MyMathCalculator bean = ioc.getBean(MyMathCalculator.class);
	bean.div(1, 1);
}

没有异常的输出： 

[LogUtils-前置]【div】方法开始执行，用的参数列表【[1, 1]】
方法内部执行
[LogUtils-后置]【div】方法最终结束了
[LogUtils-返回]【div】方法正常执行完成，计算结果是：1

异常输出： 

[LogUtils-前置]【div】方法开始执行，用的参数列表【[1, 0]】
[LogUtils-后置]【div】方法最终结束了
[LogUtils-异常]【div】方法执行出现异常了，异常信息是【java.lang.ArithmeticException: / by zero】：；这个异常已经通知测试小组进行排查

java.lang.ArithmeticException: / by zero

    at com.atguigu.impl.MyMathCalculator.div(MyMathCalculator.java:39)

 注意：这里的 后置通知（不管方法是否发生异常，都会执行） 都是在，返回通知（目标方法正常完成后被织入）和异常通知（目标方法发生异常后被织入）之前和我们的理解可能有点不同。

二、 单切面-环绕通知

@Aspect
@Component
public class LogUtils {

	@Pointcut("execution(public int com.atguigu.impl.MyMathCalculator.*(..))")
	public void hahaMyPoint(){};

    /**
     * @throws Throwable
     * @Around：环绕	:是Spring中强大的通知；
     * @Around：环绕:动态代理；
     * 	try{
     * 			//前置通知
     * 			method.invoke(obj,args);
     * 			//返回通知
     * 	}catch(e){
     * 			//异常通知
     *  }finally{
     * 			//后置通知
     * 	}
     *
     * 	四合一通知就是环绕通知；
     * 	环绕通知中有一个参数：	ProceedingJoinPoint pjp
     */

    @Around("hahaMyPoint()")
    public Object myAround(ProceedingJoinPoint pjp) throws Throwable{

        Object[] args = pjp.getArgs();
        String name = pjp.getSignature().getName();
        //args[0] = 100;
        Object proceed = null;
        try {
            //@Before
            System.out.println("【环绕前置通知】【"+name+"方法开始】");
            //就是利用反射调用目标方法即可，就是method.invoke(obj,args)
            proceed = pjp.proceed(args);
            //@AfterReturing
            System.out.println("【环绕返回通知】【"+name+"方法返回，返回值"+proceed+"】");
        } catch (Exception e) {
            //@AfterThrowing
            System.out.println("【环绕异常通知】【"+name+"】方法出现异常，异常信息："+e);
            //为了让外界能知道这个异常，这个异常一定抛出去
            throw new RuntimeException(e);
        } finally{
            //@After
            System.out.println("【环绕后置通知】【"+name+"】方法结束");
        }

        //反射调用后的返回值也一定返回出去
        return proceed;
    }
    
}

没有异常的输出：  

【环绕前置通知】【div方法开始】
方法内部执行
【环绕返回通知】【div方法返回，返回值1】
【环绕后置通知】【div】方法结束

异常输出： 

【环绕前置通知】【div方法开始】
【环绕异常通知】【div】方法出现异常，异常信息：java.lang.ArithmeticException: / by zero
【环绕后置通知】【div】方法结束

java.lang.RuntimeException: java.lang.ArithmeticException: / by zero

    at com.atguigu.utils.LogUtils.myAround(LogUtils.java:62)

注：环绕通知是不存在前面的顺序问题的 

三、 单切面-环绕通知-普通通知

@Aspect
@Component
public class LogUtils {

/**
 * 告诉Spring每个方法都什么时候运行；
 * try{
 * 		@Before
 * 		method.invoke(obj,args);
 * 		@AfterReturning
 * }catch(e){
 * 		@AfterThrowing
 * }finally{
 * 		@After
 * }
 *
 * 5个通知注解
 * @Before：在目标方法之前运行；  					 前置通知
 * @After：在目标方法结束之后						后置通知
 * @AfterReturning：在目标方法正常返回之后			返回通知
 * @AfterThrowing：在目标方法抛出异常之后运行			异常通知
 * @Around：环绕								环绕通知
 *
 *
 * 抽取可重用的切入点表达式；
 * 1、随便声明一个没有实现的返回void的空方法
 * 2、给方法上标注@Pointcut注解
 */
@Pointcut("execution(public int com.atguigu.impl.MyMathCalculator.*(..))")
public void hahaMyPoint(){};


//想在执行目标方法之前运行；写切入点表达式
//execution(访问权限符  返回值类型  方法签名)
@Before("hahaMyPoint()")
public static void logStart(JoinPoint joinPoint){
    //获取到目标方法运行是使用的参数
    Object[] args = joinPoint.getArgs();
    //获取到方法签名
    Signature signature = joinPoint.getSignature();
    String name = signature.getName();
    System.out.println("[LogUtils-前置]【"+name+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
}

//想在目标方法正常执行完成之后执行
@AfterReturning(value="hahaMyPoint()",returning="result")
public static void logReturn(JoinPoint joinPoint,Object result){
    Signature signature = joinPoint.getSignature();
    String name = signature.getName();
    System.out.println("[LogUtils-返回]【"+name+"】方法正常执行完成，计算结果是："+result);
}


//想在目标方法出现异常的时候执行
@AfterThrowing(value="hahaMyPoint()",throwing="exception")
public static void logException(JoinPoint joinPoint,Exception exception) {
    System.out.println("[LogUtils-异常]【"+joinPoint.getSignature().getName()+"】方法执行出现异常了，异常信息是【"+exception+"】：；这个异常已经通知测试小组进行排查");
}

//想在目标方法结束的时候执行
@After("hahaMyPoint()")
private int logEnd(JoinPoint joinPoint) {
    System.out.println("[LogUtils-后置]【"+joinPoint.getSignature().getName()+"】方法最终结束了");
    return 0;
}

/**
 * @throws Throwable
 * @Around：环绕	:是Spring中强大的通知；
 * @Around：环绕:动态代理；
 * 	try{
 * 			//前置通知
 * 			method.invoke(obj,args);
 * 			//返回通知
 * 	}catch(e){
 * 			//异常通知
 *  }finally{
 * 			//后置通知
 * 	}
 *
 * 	四合一通知就是环绕通知；
 * 	环绕通知中有一个参数：	ProceedingJoinPoint pjp
 *
 *环绕通知：是优先于普通通知执行，执行顺序；
 *
 *[普通前置]
 *{
 *	try{
 *		环绕前置
 *		环绕执行：目标方法执行
 *		环绕返回
 *	}catch(){
 *		环绕出现异常
 *	}finally{
 *		环绕后置
 *	}
 *}
 *
 *
 *[普通后置]
 *[普通方法返回/方法异常]
 *新的顺序：
 *		（环绕前置---普通前置）----目标方法执行----环绕正常返回/出现异常-----环绕后置----普通后置---普通返回或者异常
 *注意：
 */

@Around("hahaMyPoint()")
public Object myAround(ProceedingJoinPoint pjp) throws Throwable{

    Object[] args = pjp.getArgs();
    String name = pjp.getSignature().getName();
    //args[0] = 100;
    Object proceed = null;
    try {
        //@Before
        System.out.println("【环绕前置通知】【"+name+"方法开始】");
        //就是利用反射调用目标方法即可，就是method.invoke(obj,args)
        proceed = pjp.proceed(args);
        //@AfterReturing
        System.out.println("【环绕返回通知】【"+name+"方法返回，返回值"+proceed+"】");
    } catch (Exception e) {
        //@AfterThrowing
        System.out.println("【环绕异常通知】【"+name+"】方法出现异常，异常信息："+e);
        //为了让外界能知道这个异常，这个异常一定抛出去
        throw new RuntimeException(e);
    } finally{
        //@After
        System.out.println("【环绕后置通知】【"+name+"】方法结束");
    }

    //反射调用后的返回值也一定返回出去
    return proceed;
}
}

没有异常的输出：   

【环绕前置通知】【div方法开始】
[LogUtils-前置]【div】方法开始执行，用的参数列表【[1, 1]】
方法内部执行
【环绕返回通知】【div方法返回，返回值1】
【环绕后置通知】【div】方法结束
[LogUtils-后置]【div】方法最终结束了
[LogUtils-返回]【div】方法正常执行完成，计算结果是：1

异常输出：  

【环绕前置通知】【div方法开始】
[LogUtils-前置]【div】方法开始执行，用的参数列表【[1, 0]】
【环绕异常通知】【div】方法出现异常，异常信息：java.lang.ArithmeticException: / by zero
【环绕后置通知】【div】方法结束
[LogUtils-后置]【div】方法最终结束了
[LogUtils-异常]【div】方法执行出现异常了，异常信息是【java.lang.RuntimeException: java.lang.ArithmeticException: / by zero】：；这个异常已经通知测试小组进行排查

java.lang.RuntimeException: java.lang.ArithmeticException: / by zero

    at com.atguigu.utils.LogUtils.myAround(LogUtils.java:143)

注：如果环绕通知不显示的抛出异常，那么普通通知是感知不到异常的，这个时候普通通知还是正常执行正常返回。 

 四、多个切面-普通通知

@Aspect
@Component
@Order(1)//使用Order改变切面顺序；数值越小优先级越高
public class LogUtils {

@Pointcut("execution(public int com.atguigu.impl.MyMathCalculator.*(..))")
public void hahaMyPoint(){};

//想在执行目标方法之前运行；写切入点表达式
//execution(访问权限符  返回值类型  方法签名)
@Before("hahaMyPoint()")
public static void logStart(JoinPoint joinPoint){
    //获取到目标方法运行是使用的参数
    Object[] args = joinPoint.getArgs();
    //获取到方法签名
    Signature signature = joinPoint.getSignature();
    String name = signature.getName();
    System.out.println("[LogUtils-前置]【"+name+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
}

//想在目标方法正常执行完成之后执行
@AfterReturning(value="hahaMyPoint()",returning="result")
public static void logReturn(JoinPoint joinPoint,Object result){
    Signature signature = joinPoint.getSignature();
    String name = signature.getName();
    System.out.println("[LogUtils-返回]【"+name+"】方法正常执行完成，计算结果是："+result);
}

//想在目标方法出现异常的时候执行
@AfterThrowing(value="hahaMyPoint()",throwing="exception")
public static void logException(JoinPoint joinPoint,Exception exception) {
    System.out.println("[LogUtils-异常]【"+joinPoint.getSignature().getName()+"】方法执行出现异常了，异常信息是【"+exception+"】：；这个异常已经通知测试小组进行排查");
}

//想在目标方法结束的时候执行
@After("hahaMyPoint()")
private int logEnd(JoinPoint joinPoint) {
    System.out.println("[LogUtils-后置]【"+joinPoint.getSignature().getName()+"】方法最终结束了");
    return 0;
}

}

@Aspect
@Component
@Order(2)
public class ValidateApsect {


@Before("com.atguigu.utils.LogUtils.hahaMyPoint()")
public void logStart(JoinPoint joinPoint){
	Object[] args = joinPoint.getArgs();
	Signature signature = joinPoint.getSignature();
	String name = signature.getName();
	System.out.println("[VaApsect-前置]【"+name+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
}

@AfterReturning(value="com.atguigu.utils.LogUtils.hahaMyPoint()",returning="result")
public void logReturn(JoinPoint joinPoint,Object result){
	Signature signature = joinPoint.getSignature();
	String name = signature.getName();
	System.out.println("[VaApsect-返回]【"+name+"】方法正常执行完成，计算结果是："+result);
}

@AfterThrowing(value="com.atguigu.utils.LogUtils.hahaMyPoint()",throwing="exception")
public void logException(JoinPoint joinPoint,Exception exception) {
	System.out.println("[VaApsect-异常]【"+joinPoint.getSignature().getName()+"】方法执行出现异常了，异常信息是【"+exception+"】：；这个异常已经通知测试小组进行排查");
}

@After("com.atguigu.utils.LogUtils.hahaMyPoint()")
private int logEnd(JoinPoint joinPoint) {
	System.out.println("[VaApsect-后置]【"+joinPoint.getSignature().getName()+"】方法最终结束了");
	return 0;
}
}

 没有异常的输出：  

[LogUtils-前置]【div】方法开始执行，用的参数列表【[1, 1]】
[VaApsect-前置]【div】方法开始执行，用的参数列表【[1, 1]】
方法内部执行
[VaApsect-后置]【div】方法最终结束了
[VaApsect-返回]【div】方法正常执行完成，计算结果是：1
[LogUtils-后置]【div】方法最终结束了
[LogUtils-返回]【div】方法正常执行完成，计算结果是：1

异常输出：  

[LogUtils-前置]【div】方法开始执行，用的参数列表【[1, 0]】
[VaApsect-前置]【div】方法开始执行，用的参数列表【[1, 0]】
[VaApsect-后置]【div】方法最终结束了
[VaApsect-异常]【div】方法执行出现异常了，异常信息是【java.lang.ArithmeticException: / by zero】：；这个异常已经通知测试小组进行排查
[LogUtils-后置]【div】方法最终结束了
[LogUtils-异常]【div】方法执行出现异常了，异常信息是【java.lang.ArithmeticException: / by zero】：；这个异常已经通知测试小组进行排查

java.lang.ArithmeticException: / by zero

    at com.atguigu.impl.MyMathCalculator.div(MyMathCalculator.java:39)

 注：通知的执行顺序就是先进后出的执行顺序。谁先执行是按照通知类的类名字典序排序，当然可以用 @Order() 指定，值越小越靠前。

 

[LogUtils-前置]【add】方法开始执行，用的参数列表【[1, 1]】
[VaApsect-前置]【add】方法开始执行，用的参数列表【[1, 1]】
方法内部执行
[VaApsect-后置]【add】方法最终结束了
[VaApsect-返回]【add】方法正常执行完成，计算结果是：2
[LogUtils-后置]【add】方法最终结束了
[LogUtils-返回]【add】方法正常执行完成，计算结果是：2

五、多切面-普通通知-环绕通知

现在我们给 LogUtils 加上环绕通知 

@Aspect
@Component
@Order(1)//使用Order改变切面顺序；数值越小优先级越高
public class LogUtils {
    
@Pointcut("execution(public int com.atguigu.impl.MyMathCalculator.*(..))")
public void hahaMyPoint(){};




//想在执行目标方法之前运行；写切入点表达式
//execution(访问权限符  返回值类型  方法签名)
@Before("hahaMyPoint()")
public static void logStart(JoinPoint joinPoint){
    //获取到目标方法运行是使用的参数
    Object[] args = joinPoint.getArgs();
    //获取到方法签名
    Signature signature = joinPoint.getSignature();
    String name = signature.getName();
    System.out.println("[LogUtils-前置]【"+name+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
}

//想在目标方法正常执行完成之后执行
@AfterReturning(value="hahaMyPoint()",returning="result")
public static void logReturn(JoinPoint joinPoint,Object result){
    Signature signature = joinPoint.getSignature();
    String name = signature.getName();
    System.out.println("[LogUtils-返回]【"+name+"】方法正常执行完成，计算结果是："+result);
}


//想在目标方法出现异常的时候执行
@AfterThrowing(value="hahaMyPoint()",throwing="exception")
public static void logException(JoinPoint joinPoint,Exception exception) {
    System.out.println("[LogUtils-异常]【"+joinPoint.getSignature().getName()+"】方法执行出现异常了，异常信息是【"+exception+"】：；这个异常已经通知测试小组进行排查");
}

//想在目标方法结束的时候执行
@After("hahaMyPoint()")
private int logEnd(JoinPoint joinPoint) {
    System.out.println("[LogUtils-后置]【"+joinPoint.getSignature().getName()+"】方法最终结束了");
    return 0;
}

@Around("hahaMyPoint()")
public Object myAround(ProceedingJoinPoint pjp) throws Throwable{
    
    Object[] args = pjp.getArgs();
    String name = pjp.getSignature().getName();
    //args[0] = 100;
    Object proceed = null;
    try {
        //@Before
        System.out.println("【环绕前置通知】【"+name+"方法开始】");
        //就是利用反射调用目标方法即可，就是method.invoke(obj,args)
        proceed = pjp.proceed(args);
        //@AfterReturing
        System.out.println("【环绕返回通知】【"+name+"方法返回，返回值"+proceed+"】");
    } catch (Exception e) {
        //@AfterThrowing
        System.out.println("【环绕异常通知】【"+name+"】方法出现异常，异常信息："+e);
        //为了让外界能知道这个异常，这个异常一定抛出去
        throw new RuntimeException(e);
    } finally{
        //@After
        System.out.println("【环绕后置通知】【"+name+"】方法结束");
    }
    
    //反射调用后的返回值也一定返回出去
    return proceed;
}
}

 没有异常的输出：   

【环绕前置通知】【div方法开始】
[LogUtils-前置]【div】方法开始执行，用的参数列表【[1, 1]】
[VaApsect-前置]【div】方法开始执行，用的参数列表【[1, 1]】
方法内部执行
[VaApsect-后置]【div】方法最终结束了
[VaApsect-返回]【div】方法正常执行完成，计算结果是：1
【环绕返回通知】【div方法返回，返回值1】
【环绕后置通知】【div】方法结束
[LogUtils-后置]【div】方法最终结束了
[LogUtils-返回]【div】方法正常执行完成，计算结果是：1

异常输出：   

【环绕前置通知】【div方法开始】
[LogUtils-前置]【div】方法开始执行，用的参数列表【[1, 0]】
[VaApsect-前置]【div】方法开始执行，用的参数列表【[1, 0]】
[VaApsect-后置]【div】方法最终结束了
[VaApsect-异常]【div】方法执行出现异常了，异常信息是【java.lang.ArithmeticException: / by zero】：；这个异常已经通知测试小组进行排查
【环绕异常通知】【div】方法出现异常，异常信息：java.lang.ArithmeticException: / by zero
【环绕后置通知】【div】方法结束
[LogUtils-后置]【div】方法最终结束了
[LogUtils-异常]【div】方法执行出现异常了，异常信息是【java.lang.RuntimeException: java.lang.ArithmeticException: / by zero】：；这个异常已经通知测试小组进行排查

java.lang.RuntimeException: java.lang.ArithmeticException: / by zero

    at com.atguigu.utils.LogUtils.myAround(LogUtils.java:86)

 

LogProxy{
	环绕前置
	method.invoke(){
		VaProxy{
			va前置
	   		  target
			va后置
			va返回
		}

	}
	环绕返回
	环绕后置
}
1、Spring-IOC-AOP（动态代理）；多层代理
               LogAspectpRroxy{
                         try{
                              @Before
                              method.invoke()//pjp.procced(args){
                                        BAspectProxy{
                                                       @Before
                                                       method.invoke()//---目标方法
                                                         @AfterReturning
                                                        //xxxxxxxx
                                                            //修改了返回值
                                        }
                              }
                              @AfterReturning
                         }catch(e){
                               @AfterThrowing
                         }finally{
                               @After 
                         }        
               }

 注：LogUtils 里面的环绕通知，跟ValidateApsect里面的通知没有关系，他只是影响当前切面

六、如何选择通知

由于环绕通知比较强大，他能直接控制目标方法的执行。如果我们是做日志记录等仅仅感知目标方法执行，我们使用普通通知即可。如果我需要写一一个动态代理，要影响目标方法，那么我就使用环绕通知。

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

	<context:component-scan base-package="com.atguigu"/>

	<!--  开启基于注解的AOP功能；aop名称空间-->
	<aop:aspectj-autoproxy/>
</beans>
<dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.0.0.RELEASE</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.0.0.RELEASE</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.0.0.RELEASE</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>4.0.0.RELEASE</version>
    </dependency>


    <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.1.3</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>4.0.0.RELEASE</version>
    </dependency>

    <!--基本切面包-->
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>4.0.0.RELEASE</version>
    </dependency>

    <!--切面plus包-->

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.6.12</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.6.12</version>
    </dependency>
    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.2</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/junit/junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>


</dependencies>

 

 

 

爪 哇
关注
专栏目录
Spring 6【前置通知注解实现、同一切面多个相同类型通知执行顺序、代理设计模式、动态代理示例】(十六)-全面详解（学习总结---从入门到深化）
07-29 577
Spring 6【前置通知注解实现、同一切面多个相同类型通知执行顺序、代理设计模式、动态代理示例】(十六)-全面详解（学习总结---从入门到深化）
图解动态代理
opi
10-16 863
1.类图关系 目标类target和jdk动态代理生成的代理类 $Proxy0 都实现共同的接口interface，有接口方法method() Proxy类提供静态工厂方法 newProxyInstance() 代理类 $Proxy0继承Proxy类，依赖InvocationHandler 执行处理器 2.时序图 当用户调用接口方法method时，$Proxy0会委托给Invocati...
动态代理的工作原理图
weixin_34007879的博客
07-29 150
spring aop切面通知调用顺序与输出顺序
weixin_40857858的博客
01-23 307
spring4、spring5aop切面通知执行顺序。
Spring通知执行顺序 -回复 1
08-08
本篇将深入探讨Spring通知的执行顺序以及如何控制多个切面的执行顺序。 首先，让我们了解Spring中的五种不同类型的通知： 1. **前置通知（Before）**：在目标方法被调用之前执行。 2. **后置通知（After）**：在...
Spring的AOP执行顺序
liangsheng_g的专栏
01-26 3690
Spring中的Advisors的执行顺序
spring使用动态代理面向切面编程(AOP) xml
04-22
但如果有特殊需求，可以通过`<aop:aspect-order>`或`<aop:declare-parents>`来调整切面的执行顺序。 四、例子解析 文件名`spring_1600_AOP_xml`可能是指Spring AOP的示例代码，可能包含了如何在XML配置中定义和使用...
Spring-Reference_zh_CN（Spring中文参考手册）
06-06
7.3.2. Spring里的通知类型 7.3.2.1. 拦截around通知 7.3.2.2. 前置通知 7.3.2.3. 异常通知 7.3.2.4. 后置通知 7.3.2.5. 引入通知 7.4. Spring里的advisor（Advisor） API 7.5. 使用ProxyFactoryBean创建AOP代理 ...
java消息顺序执行_spring通知执行的顺序
weixin_33438009的博客
02-27 291
关于spring aop的具体使用，暂时不在这里讲解，后面会特定来讲解，本次主要探讨spring中通知执行的顺序。spring中通知分为以下几种：before：前置通知，在方法执行之前执行around：环绕通知，在方法执行前后执行afterreturning：在方法执行成功后执行afterthrowning：异常通知，在方法发生异常后执行after：后置通知，在方法执行之后执行(不管方法执行成功还...
spring@Async动态代理的排序深入processor
hzh727172424的博客
01-07 370
spring@Async动态代理的排序深入processor 在java需要让自定义的aop在@async之前执行。修改order却做不到。研究1天发现了原因和解决方法。留下笔记。 spring的BeanPostProcessor是可以利用order进行排序的 在异步AsyncAnnotationBeanPostProcessor中的抽象父类AbstractAdvisingBeanPostProcessor中发现postProcessAfterInitialization中把advisor添加到第一位。构造
面试官：Spring Aop 常见注解和执行顺序
良月柒
07-20 225
程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 3.5 分钟。来自：juejin.cn/post/7062506923194581029Spring 一开始最强大的就是 IOC / AOP 两大核心功能，我们今天一起来学习一下 Spring AOP 常见注解和执行顺序。Spring Aop 的常用注解首先我们一起来回顾一下 Spring Aop 中常...
spring中执行过程中程序不进通知
qq_37190771的博客
03-14 117
今天在做spring的demo时，程序一直不进我的写好的 通知中，纠结了一下午➕一晚上才搞好，其实是很简单的问题就是我的 execution表达式没有写对 很难受 ，public void可以写成 * 但是不能 省略 ， 方法中的参数可以写成 … 但是如果不写的话，就回去找没有参数的那个通知，我就是没写参数，导致一直不进我的通知里面去，难受 ...
Spring AOP及代理类执行顺序
weixin_41866717的博客
03-19 686
关于 Spring AOP和Aspectj的关系，两个都实现了切面编程，Spring AOP更多地是为了Spring框架本身服务的，而Aspectj具有更强大、更完善的切面功能，我们在写业务时一般使用AspectJ。不过他们的概念、原理都差不多。Spring AOP说：可参考AspectJ项目中提供了@AspecJ注解，Spring interprets the same annotations@AspectSpring AOP提供了定义切面的两种方式。
Spring(二)----动态代理、AOP
qq_43699614的博客
06-15 181
Spring(二)----动态代理、AOP Spring基础知识学习笔记(二)，内容包括： 代理模式：静态代理和动态代理 AOP实现：注解实现+配置文件实现 切面、通知、切入点、切入点表达式 环绕通知 OOP：(Object Oriented Programming) 面向对象编程。 AOP：(Aspect Oriented Programming) 面向切面编程，基于OOP基础之上的编程思想，在程序运行期间，将某段代码动态的切入到指定方法的指定位置进行运算。 应用场景：计算器运行计算方法的时候进行日志
【Java-16】动态代理的使用方法及原理实现
最新发布
接着奏乐接着舞的博客
08-09 892
目标了解什么是动态代理路径动态代理概述动态代理在上面静态代理的例子中，代理类(SongZhe)是自己定义好的，在程序运行之前就已经编译完成然而动态代理中，代理类是在程序运行时利用反射机制动态创建的，这种代理方式被成为动态代理在实际开发过程中动态代理是通过JDK提供的Proxy类在程序运行时，运用反射机制动态创建而成大白话：静态代理需要自己写代理类、动态代理不用自己写代理类。
Java动态代理执行细节
azurelaker的博客
04-03 411
Java SDK中提供了在运行其生成动态代理类的机制. 被代理类通过定义接口规范, 代理类可以执行接口规范中的函数调用.使用动态代理机制时, 涉及到几个不同的角色:被代理类, 代理类,InvocationHandler类以及Proxy类. 他们的功能说明如下: ...
Java进阶 | Proxy动态代理机制详解
【积累】，是一个长期持续的过程。
06-28 3372
在说Java动态代理之前，还是要说一下Jvm加载对象的过程，这个依旧是理解动态代理的基础性原理Java类即源代码程序.java类型文件，经过编译器编译之后就被转换成字节代码.class类型文件，类加载器负责读取字节代码，并转换成java.lang.Class对象，描述类在元数据空间的数据结构，类被实例化时，堆中存储实例化的对象信息，并且通过对象类型数据的指针找到类。所以通过New创建对象，独断其背后很多实现细节，理解上述过程之后，再了解一个常用的设计模式，即代理模式。...
spring的aop执行顺序】
05-17
1. JDK动态代理：JDK动态代理只能代理实现了接口的类，它的执行顺序是先执行前置通知，然后执行目标方法，最后执行后置通知和返回通知（如果有异常通知，则在最后执行）。 2. CGLIB动态代理：CGLIB动态代理可以代理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值