spring通知执行的顺序

关于spring aop的具体使用，暂时不在这里讲解，后面会特定来讲解，本次主要探讨spring中通知执行的顺序。

spring中通知分为以下几种：

before：前置通知，在方法执行之前执行
around：环绕通知，在方法执行前后执行
afterreturning：在方法执行成功后执行
afterthrowning：异常通知，在方法发生异常后执行
after：后置通知，在方法执行之后执行（不管方法执行成功还是失败）

下面我们将每种通知创建两个，代码如下：

1、before通知2个

package com.cn.aop.demo4;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.springframework.core.annotation.Order;

import org.springframework.stereotype.Component;

/**

 * 我的技术网站 2016/11/17 0017.

 */

@Component

@Aspect

@Order(100000)

public class Before1 {

    @Before(value = "execution(* com.cn.aop.demo4.*Impl.*(..))")

    public void exec(){

        Order order = this.getClass().getAnnotation(Order.class);

        System.out.println(Before1.class+" Before通知 order = "+order.value());

    }

}

package com.cn.aop.demo4;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.springframework.core.annotation.Order;

import org.springframework.stereotype.Component;

/**

 * 我的技术网站 2016/11/17 0017.

 */

@Component

@Aspect

@Order(100000)

public class Before2 {

    @Before(value = "execution(* com.cn.aop.demo4.*Impl.*(..))")

    public void exec(){

        Order order = this.getClass().getAnnotation(Order.class);

        System.out.println(Before2.class+" Before通知 order = "+order.value());

    }

}

2、around通知2个

package com.cn.aop.demo4;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.springframework.core.annotation.Order;

import org.springframework.stereotype.Component;

/**

 * 我的技术网站 2016/11/17 0017.

 */

@Component

@Aspect

@Order(100000)

public class Around1 {

    @Around(value = "execution(* com.cn.aop.demo4.*Impl.*(..))")

    public Object exec(ProceedingJoinPoint invocation) throws Throwable {

        Order order = this.getClass().getAnnotation(Order.class);

        System.out.println(Around1.class+" Around通知 order = "+order.value()+" start");

        Object result = invocation.proceed();

        System.out.println(Around1.class+" Around通知 order = "+order.value()+" end");

        return result;

    }

}

package com.cn.aop.demo4;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.springframework.core.annotation.Order;

import org.springframework.stereotype.Component;

/**

 * 我的技术网站 2016/11/17 0017.

 */

@Component

@Aspect

@Order(100000)

public class Around2 {

    @Around(value = "execution(* com.cn.aop.demo4.*Impl.*(..))")

    public Object exec(ProceedingJoinPoint invocation) throws Throwable {

        Order order = this.getClass().getAnnotation(Order.class);

        System.out.println(Around2.class+" Around通知 order = "+order.value()+" start");

        Object result = invocation.proceed();

        System.out.println(Around2.class+" Around通知 order = "+order.value()+" end");

        return result;

    }

}

3、afterreturning通知2个

package com.cn.aop.demo4;

import org.aspectj.lang.annotation.After;

import org.aspectj.lang.annotation.AfterReturning;

import org.aspectj.lang.annotation.Aspect;

import org.springframework.core.annotation.Order;

import org.springframework.stereotype.Component;

/**

 * 我的技术网站 2016/11/17 0017.

 */

@Component

@Aspect

@Order(100000)

public class AfterReturning1 {

    @AfterReturning(value = "execution(* com.cn.aop.demo4.*Impl.*(..))")

    public void exec(){

        Order order = this.getClass().getAnnotation(Order.class);

        System.out.println(AfterReturning1.class+" AfterReturning通知 order = "+order.value());

    }

}

package com.cn.aop.demo4;

import org.aspectj.lang.annotation.AfterReturning;

import org.aspectj.lang.annotation.AfterThrowing;

import org.aspectj.lang.annotation.Aspect;

import org.springframework.core.annotation.Order;

import org.springframework.stereotype.Component;

/**

 * 我的技术网站 2016/11/17 0017.

 */

@Component

@Aspect

@Order(100000)

public class AfterReturning2 {

    @AfterReturning(value = "execution(* com.cn.aop.demo4.*Impl.*(..))")

    public void exec(){

        Order order = this.getClass().getAnnotation(Order.class);

        System.out.println(AfterReturning2.class+" AfterReturning通知 order = "+order.value());

    }

}

4、afterthrowning通知2个

package com.cn.aop.demo4;

import org.aspectj.lang.annotation.AfterReturning;

import org.aspectj.lang.annotation.AfterThrowing;

import org.aspectj.lang.annotation.Aspect;

import org.springframework.core.annotation.Order;

import org.springframework.stereotype.Component;

/**

 * 我的技术网站 2016/11/17 0017.

 */

@Component

@Aspect

@Order(100000)

public class AfterThrowing1 {

    @AfterThrowing(value = "execution(* com.cn.aop.demo4.*Impl.*(..))")

    public void exec(){

        Order order = this.getClass().getAnnotation(Order.class);

        System.out.println(AfterThrowing1.class+" AfterThrowing通知 order = "+order.value());

    }

}

package com.cn.aop.demo4;

import org.aspectj.lang.annotation.AfterThrowing;

import org.aspectj.lang.annotation.Aspect;

import org.springframework.core.annotation.Order;

import org.springframework.stereotype.Component;

/**

 * 我的技术网站 2016/11/17 0017.

 */

@Component

@Aspect

@Order(100000)

public class AfterThrowing2 {

    @AfterThrowing(value = "execution(* com.cn.aop.demo4.*Impl.*(..))")

    public void exec(){

        Order order = this.getClass().getAnnotation(Order.class);

        System.out.println(AfterThrowing2.class+" AfterThrowing通知 order = "+order.value());

    }

}

5、after通知两个

package com.cn.aop.demo4;

import org.aspectj.lang.annotation.After;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.springframework.core.annotation.Order;

import org.springframework.stereotype.Component;

/**

 * 我的技术网站 2016/11/17 0017.

 */

@Component

@Aspect

@Order

public class After1 {

    @After(value = "execution(* com.cn.aop.demo4.*Impl.*(..))")

    public void exec(){

        Order order = this.getClass().getAnnotation(Order.class);

        System.out.println(After1.class+" After通知 order = "+order.value());

    }

}

package com.cn.aop.demo4;

import org.aspectj.lang.annotation.After;

import org.aspectj.lang.annotation.AfterReturning;

import org.aspectj.lang.annotation.Aspect;

import org.springframework.core.annotation.Order;

import org.springframework.stereotype.Component;

/**

 * 我的技术网站 2016/11/17 0017.

 */

@Component

@Aspect

@Order(100000)

public class After2 {

    @After(value = "execution(* com.cn.aop.demo4.*Impl.*(..))")

    public void exec(){

        Order order = this.getClass().getAnnotation(Order.class);

        System.out.println(After2.class+" After通知 order = "+order.value());

    }

}

6、其他文件

声明1个接口和一个实现类，在本实现类上面添加上面10个通知

package com.cn.aop.demo4;

/**

 * 我的技术网站 2016/11/15 0015.

 */

public interface IAService {

    String m1();

    void m2();

}

package com.cn.aop.demo4;

import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**

 * 我的技术网站 2016/11/15 0015.

 */

@Component("aservice")

public class AServiceImpl implements IAService {

    public String m1()

    {

        System.out.println(AServiceImpl.class+".m1()");

        return AServiceImpl.class+".m1()";

    }

    @Override

    public void m2() {

        int i=0;

        System.out.println(10/i);

    }

}

spring配置文件spring-demo4.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"

       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"

       xmlns:p="http://www.springframework.org/schema/p"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context-3.1.xsd

    http://www.springframework.org/schema/aop

    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd

    http://www.springframework.org/schema/tx

    http://www.springframework.org/schema/tx/spring-tx-3.1.xsd" default-autowire="byName">

    <aop:aspectj-autoproxy />

    <context:component-scan base-package="com.cn.aop.demo4"/>

</beans>

测试类

package com.cn.aop.demo4;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**

 * 我的技术网站 2016/11/17 0017.

 */

public class Client {

    public static void main(String[] args) {

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:/aop/spring-demo4.xml");

        IAService aservice = context.getBean("aservice", IAService.class);

        System.out.println("\n========================\n");

        aservice.m1();

        System.out.println("\n========================\n");

        try {

            aservice.m2();

        } catch (Exception e){

            //暂时不输出错误信息

        }

    }

}

1、上面所有拦截器的order都为100000，执行结果如下

========================

class com.cn.aop.demo4.Around1 Around通知 order = 100000 start

class com.cn.aop.demo4.Around2 Around通知 order = 100000 start

class com.cn.aop.demo4.Before1 Before通知 order = 100000

class com.cn.aop.demo4.Before2 Before通知 order = 100000

class com.cn.aop.demo4.AServiceImpl.m1()

class com.cn.aop.demo4.Around2 Around通知 order = 100000 end

class com.cn.aop.demo4.Around1 Around通知 order = 100000 end

class com.cn.aop.demo4.AfterReturning1 AfterReturning通知 order = 100000

class com.cn.aop.demo4.AfterReturning2 AfterReturning通知 order = 100000

class com.cn.aop.demo4.After2 After通知 order = 100000

class com.cn.aop.demo4.After1 After通知 order = 100000

========================

class com.cn.aop.demo4.Around1 Around通知 order = 100000 start

class com.cn.aop.demo4.Around2 Around通知 order = 100000 start

class com.cn.aop.demo4.Before1 Before通知 order = 100000

class com.cn.aop.demo4.Before2 Before通知 order = 100000

class com.cn.aop.demo4.AfterThrowing2 AfterThrowing通知 order = 100000

class com.cn.aop.demo4.AfterThrowing1 AfterThrowing通知 order = 100000

class com.cn.aop.demo4.After2 After通知 order = 100000

class com.cn.aop.demo4.After1 After通知 order = 100000

2、修改配置

Before1 @Order(1)

Before2 @Order(2)

client执行结果

========================

class com.cn.aop.demo4.Before1 Before通知 order = 1

class com.cn.aop.demo4.Before2 Before通知 order = 2

class com.cn.aop.demo4.Around1 Around通知 order = 100000 start

class com.cn.aop.demo4.Around2 Around通知 order = 100000 start

class com.cn.aop.demo4.AServiceImpl.m1()

class com.cn.aop.demo4.Around2 Around通知 order = 100000 end

class com.cn.aop.demo4.Around1 Around通知 order = 100000 end

class com.cn.aop.demo4.AfterReturning1 AfterReturning通知 order = 100000

class com.cn.aop.demo4.AfterReturning2 AfterReturning通知 order = 100000

class com.cn.aop.demo4.After2 After通知 order = 100000

class com.cn.aop.demo4.After1 After通知 order = 100000

========================

class com.cn.aop.demo4.Before1 Before通知 order = 1

class com.cn.aop.demo4.Before2 Before通知 order = 2

class com.cn.aop.demo4.Around1 Around通知 order = 100000 start

class com.cn.aop.demo4.Around2 Around通知 order = 100000 start

class com.cn.aop.demo4.AfterThrowing2 AfterThrowing通知 order = 100000

class com.cn.aop.demo4.AfterThrowing1 AfterThrowing通知 order = 100000

class com.cn.aop.demo4.After2 After通知 order = 100000

class com.cn.aop.demo4.After1 After通知 order = 100000

3、修改配置

Before1 @Order(1)

Before2 @Order(2)

AfterReturning1 @Order(1)

AfterReturning2 @Order(1000001)

AfterThrowing1 @Order(1)

AfterThrowing2 @Order(1000001)

After1 @Order(1)

After2 @Order(1000001)

执行结果：

========================

class com.cn.aop.demo4.Before1 Before通知 order = 1

class com.cn.aop.demo4.Before2 Before通知 order = 2

class com.cn.aop.demo4.Around1 Around通知 order = 100000 start

class com.cn.aop.demo4.Around2 Around通知 order = 100000 start

class com.cn.aop.demo4.AServiceImpl.m1()

class com.cn.aop.demo4.AfterReturning2 AfterReturning通知 order = 1000001

class com.cn.aop.demo4.After2 After通知 order = 1000001

class com.cn.aop.demo4.Around2 Around通知 order = 100000 end

class com.cn.aop.demo4.Around1 Around通知 order = 100000 end

class com.cn.aop.demo4.AfterReturning1 AfterReturning通知 order = 1

class com.cn.aop.demo4.After1 After通知 order = 1

========================

class com.cn.aop.demo4.Before1 Before通知 order = 1

class com.cn.aop.demo4.Before2 Before通知 order = 2

class com.cn.aop.demo4.Around1 Around通知 order = 100000 start

class com.cn.aop.demo4.Around2 Around通知 order = 100000 start

class com.cn.aop.demo4.AfterThrowing2 AfterThrowing通知 order = 1000001

class com.cn.aop.demo4.After2 After通知 order = 1000001

class com.cn.aop.demo4.AfterThrowing1 AfterThrowing通知 order = 1

class com.cn.aop.demo4.After1 After通知 order = 1

结论：

1、无异常情况

所有通知order一样，执行顺序：around start -> before ->around
start -> afterreturning -> after
before.order < around.order，执行顺序： before -> around start
afterreturning.order > around.order，执行顺序：afterreturning -> around
end
after.order > around.order，执行顺序：after -> around
end
after.order >afterreturning.order，执行顺序：
after -> afterreturning

2、异常情况

所有通知order一样，执行顺序：around start -> before -> afterthrowing -> after
before.order < around.order，执行顺序： before -> around start
after.order > afterthrowing .order，执行顺序：after -> afterthrowing

如果喜欢，点个赞，关注公众号，我们将最好的内容分享与你！谢谢！

spring通知执行的顺序的更多相关文章

Spring切面通知执行的顺序（Advice Order）
问题描述如果在Spring的程序中同时定义了环绕通知(Around)和前置通知(Before)..那么,有以下问题: 1.怎么让两个切面通知都起作用 2.或者让两者切面按自己指定的顺序进行执行? 3 ...
浅谈Spring AOP 面向切面编程最通俗易懂的画图理解AOP、AOP通知执行顺序~
简介我们都知道,Spring 框架作为后端主流框架之一,最有特点的三部分就是IOC控制反转.依赖注入.以及AOP切面.当然AOP作为一个Spring 的重要组成模块,当然IOC是不依赖于Spring ...
spring多个AOP执行先后顺序（面试问题：怎么控制多个aop的执行循序）
转载:spring多个AOP执行先后顺序(面试问题:怎么控制多个aop的执行循序) 众所周知,spring声明式事务是基于AOP实现的,那么,如果我们在同一个方法自定义多个AOP,我们如何指定他们的执 ...
【原】不定义Order属性，通过切面类的定义顺序来决定通知执行的先后顺序
[结论] 在多个切面类的“切入点相同”并且每个切面都“没有定义order属性”的情况下,则切面类(中的通知)的执行顺序与该切面类在<aop:config>元素中“声明的顺序”相关,即先声明 ...
【原】Order属性决定了不同切面类中通知执行的先后顺序
[障碍再现] MyBatis配置多数据源时,数据源切换失败. [原因分析] 自定义切面和Spring自带事务切面“即<aop:advisor>”执行的先后顺序导致数据源不能切换成功. ...
Spring通知类型及使用ProxyFactoryBean创建AOP代理
Spring 通知类型通过前面的学习可以知道,通知(Advice)其实就是对目标切入点进行增强的内容,Spring AOP 为通知(Advice)提供了 org.aopalliance.aop.Ad ...
吴裕雄--天生自然JAVA SPRING框架开发学习笔记：Spring通知类型及使用ProxyFactoryBean创建AOP代理
通知(Advice)其实就是对目标切入点进行增强的内容,Spring AOP 为通知(Advice)提供了 org.aopalliance.aop.Advice 接口. Spring 通知按照在目标类 ...
使用@AutoConfigureBefore、After、Order调整Spring Boot自动配置顺序
前言 Spring Boot是Spring家族具有划时代意义的一款产品,它发展自Spring Framework却又高于它,这种高于主要表现在其最重要的三大特性,而相较于这三大特性中更为重要的便是Sp ...
Java中的继承与静态static等的执行先后顺序
package extend; public class X { Y y=new Y(); static{ System.out.println("tttt"); } X(){ ...

随机推荐

【重学计算机】操作系统D2章：处理器管理
1. 指令与处理器模式指令执行周期:取指.译码.执行指令分类(根据权限) 特权指令:只能被操作系统内核使用(启动IO,置PC值) 非特权指令:所有程序都能使用处理器模式: 共有四种:0内核模式, ...
[译]PEP 380--子生成器的语法
导语: PEP(Python增强提案)几乎是 Python 社区中最重要的文档,它们提供了公告信息.指导流程.新功能的设计及使用说明等内容.对于学习者来说,PEP 是非常值得一读的第一手材料,学习中遇 ...
C# 接口的使用(工厂模式)
接口(interface)与抽象类(abstract)的区别: 相同点: 1.都不能被直接实例化,都可以通过继承实现其抽象方法. 2.都是面向抽象编程的技术基础,实现诸多模式不同点: 1.接口可以多 ...
用python复制图片、视频
图片复制 f_src = open('1.jpg','rb') content = f_src.read() f_copy = open('1-副本.jpg','wb') f_copy.write(c ...
Oracle数据库知识要点
一.卸载安装(来自百度经验) 完全卸载: 1. 停止相关服务 2. 运行Universal Installer,卸载产品 3. 清理注册表 4. 重启电脑,删除目录(Oracle文件夹和app文件夹) ...
Android WebView 缓存
android很多情况是使用webView用来显示界面,但是webview的加载速度略慢,想让这个webview更快一些所以需要使用缓存,在没有更新的时候使用缓存技术来提高速度.总体来讲有两个方案可以 ...
外呼系统APP外呼软件手机电销软件拨号销售软件功能设计
外呼系统APP外呼软件 1 系统概述该软件系统设计功能主要为贷款.投资.资产管理等金融中介公司提供方便快捷的线上管理各类资源的一款应用软件工具. 可根据不同职位的账号登录APP来管理电话营销.客户签 ...
windows update error 0x8024401c
Error 0x8024401c 以管理员身份运行-命令提示符执行以下3条命令 net stop wuauserv reg delete HKEY_LOCAL_MACHINE\SOFTWARE\Po ...
hexo 报错 Cannot read property 'replace' of null
详细错误信息: FATAL Cannot read property 'replace' of null TypeError: Cannot read property 'replace' of nu ...
Intellij Idea 无法启动项目的配置坑
1. run/debug configuration里面,tomcat的deployment点击添加不能自动创建war-explorded包: 方案:删除project libraries,重新mav ...

spring通知执行的顺序

spring通知执行的顺序的更多相关文章

随机推荐

热门专题