SpringAOP四种通知类型+环绕通知说明

目录
  • 一、四种常见的通知类型
    • 注意
  • 二、环绕通知
    • 1、改动日志类 Logger.java
    • 2、改动配置文件
    • 分析
  • AOP机制之环绕通知的见解
    • 其中有五个通知类型

SpringAOP的四种通知类型:前置通知、异常通知、后置通知、异常通知

一、四种常见的通知类型

给出 账户的业务层接口 IAccountService.java,

为了便于演示这四种通知类型,我们就只留下了一个方法。

public interface IAccountService {
   void saveAccount();
}

给出 账户的业务层接口的实现类 AccountServiceImpl.java

public class AccountServiceImpl implements IAccountService{
    @Override
    public void saveAccount() {
        System.out.println("执行了保存");
        //int i=1/0;
    }
}

给出一个日志类, 用于打印日志

public class Logger {
    /**
     * 前置通知
     */
    public  void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }
    /**
     * 后置通知
     */
    public  void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
    }
    /**
     * 异常通知
     */
    public  void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
    }
    /**
     * 最终通知
     */
    public  void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
    }
}

给出配置信息bean.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"
       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.xsd">
    <!-- 配置srping的Ioc,把service对象配置进来-->
    <bean id="accountService" class="service.AccountServiceImpl"></bean>
    <!-- 配置Logger类 -->
    <bean id="logger" class="utils.Logger"></bean>
    <!--配置AOP-->
    <aop:config>
      <!--配置切入点表达式 -->
        <aop:pointcut id="pt1" expression="execution(* service.AccountServiceImpl.saveAccount())"></aop:pointcut>
        <!--配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置前置通知:在切入点方法执行之前执行-->
            <aop:before method="beforePrintLog" pointcut-ref="pt1" ></aop:before>
            <!-- 配置后置通知:在切入点方法正常执行之后值-->
            <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>
            <!-- 配置异常通知:在切入点方法执行产生异常之后执行-->
            <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>
            <!-- 配置最终通知:无论切入点方法是否正常执行它都会在其后面执行-->
            <aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>

        </aop:aspect>
    </aop:config>
</beans>

注意

1)异常通知和后置通知永远只能执行一个

2)配置切入点表达式

此标签写在aop:aspect标签内部只能当前切面使用。

它还可以写在aop:aspect外面,此时就变成了所有切面可用

给出Test类

public class AOPTest {
    public static void main(String[] args) {
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取对象
        IAccountService as = (IAccountService)ac.getBean("accountService");
        //3.执行方法
       as.saveAccount();
    }
}

执行结果:

当我们放开AccountServiceImpl类中我们故意制造的异常 int i=1/0;时:

二、环绕通知

环绕通知,只需要稍稍微改变上面例子的两点即可

1、改动日志类 Logger.java

public class Logger {
    public Object aroundPringLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法执行所需的参数
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");
            rtValue = pjp.proceed(args);//明确调用业务层方法(切入点方法)
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");
            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
        }
    }
}

注意:pjp.proceed(args)会报异常,必须用 Throwable t,因为Exception拦不住它

2、改动配置文件

<?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"
       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.xsd">
    <!-- 配置srping的Ioc,把service对象配置进来-->
    <bean id="accountService" class="service.AccountServiceImpl"></bean>
    <!-- 配置Logger类 -->
    <bean id="logger" class="utils.Logger"></bean>
    <!--配置AOP-->
    <aop:config>
    	<!--配置切入点表达式 -->
        <aop:pointcut id="pt1" expression="execution(* service.AccountServiceImpl.saveAccount())"></aop:pointcut>
        <!--配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置环绕通知 详细的注释请看Logger类中-->
            <aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

分析

  • spring中的环绕通知是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
  • Spring框架为我们提供了一个接口:ProceedingJoinPoint。该接口有一个方法proceed(),此方法就相当于明确调用切入点方法。该接口可以作为环绕通知的方法参数,在程序执行时,spring框架会为我们提供该接口的实现类供我们使用。

AOP机制之环绕通知的见解

我们都知道,AOP机制的核心是在不修改源码的基础上对业务层方法的增强。

其中有五个通知类型

  • 1、前置通知:在切入点方法之前执行
  • 2、后置通知:在切入点方法之后通知
  • 3、异常通知:在执行切入点方法过程中出现异常后执行(因此异常通知和后置通知只能执行一个)
  • 4、最终通知:无论切入点方法是否正常执行它都会执行
  • 5、环绕通知: 当配置环绕通知之后,在环绕通知里面必须要明确调用业务层的方法,如果不调用,就会出现只出现通知,而不执行方法。其中原理和动态代理是一样的,代码如下。
public AccountService getAccountService() {
        return (AccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(), accountService.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                Object rtValue=null;
                try {
                    //1、开启事务
                    txManager.beginTransaction();
                    //2、执行操作,整个过程像对每个方法进行了包装,并返回新的accountService对象
                    rtValue=method.invoke(accountService,objects);
                    //3、提交事务
                    txManager.commit();
                    //4、返回结果
                    return rtValue;
                }catch (Exception e){
                    //5、回滚事务
                    txManager.rollback();
                    throw new RuntimeException(e);
                }finally {
                    //6、释放连接
                    txManager.release();
                }
            }
        });
    }

如果不明确调用业务层方法,就像一个画皮,没有发挥本质的作用。

除此之外,我认为环绕通知可以代替其他的四个通知,

public Object aroundPrintLog(ProceedingJoinPoint pjp){//环绕通知是不是能够代替其他的通知
        Object rtvalue=null;
        try {
            /**
             *这里的一切都是为都是给业务层方法进行增强,例如:把那些方法拿过来,然后核心的还是rtvalue=pjp.proceed(args),
             *其他的输出只不过是为核心的业务层方法进行修饰
             */
            Object[] args=pjp.getArgs();//得到方法执行所需的参数
            System.out.println("前置通知");
            rtvalue=pjp.proceed(args);//明确调用业务层方法
            System.out.println("后置通知");
            return rtvalue;
        }catch (Throwable e){
            System.out.println("异常通知");
            throw new RuntimeException(e);
        }finally {
            System.out.println("最终通知");
        }
    }

这个属于典型的环绕通知,其中把输出方法换成相应的通知方法就可以(有不同观点的可以说出来一起讨论)。

最后,分享一下我学这个知识的方法。方法增强,本质上就是对源码不修改的情况下进行方法的加工。就好像烤羊肉串一样,其中的核心就是羊肉,就像公司给你的业务层方法(这个是不让修改的)。在给顾客使用前,收先对羊肉进行刷油、烤、撒料一系列过程,这一过程就是我们对业务层方法的增强,使业务层的功能更加健壮,对应的烧烤也就是更美味。核心的一点就是正确调用业务层的方法,不管在哪类通知中,都能对业务层方法进行正确、有效地增强

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • 通过实例解析spring环绕通知原理及用法

    环绕通知: 它是spring框架为我们提供的一种可以在代码中手动控制增强部分什么时候执行的方式. 问题: 当我们配置了环绕通知之后,增强的代码执行了,业务核心方法没有执行. 分析: 通过动态代理我们知道在invoke方法中,有明确调用业务核心方法:method.invoke(). 我们配置的环绕通知中,没有明确调用业务核心方法. 解决: spring框架为我们提供了一个接口:ProceedingJoinPoint,它可以作为环绕通知的方法参数在环绕通知执行时,spring框架会为我们提供该接口的

  • 如何使用Spring AOP的通知类型及创建通知

    写在最前端 1.SpringAOP中共有六种通知类型,只要我们自定义一个类实现对应的接口,它们全都是org.springframework.aop包中的. 2.AOP的连接点可以是方法调用.方法调用本身.类初始化.对象实例化时,但是SpringAOP中全是方法调用,更简单,也最实用 通知名称 接口 前置通知 org.springframework.aop.MethodBeforeAdvice 后置返回通知 org.springframework.aop.AfterReturningAdvice

  • 通过AOP环绕通知如何实现事务控制

    目录 通过AOP环绕通知实现事务控制 1.导入相关的依赖 2.配置连接池和开启AOP注解 2.创建链接工具类 3.AOP环绕事务类 spring AOP 环绕通知的思路 1.设计一个接口 2.编写这个接口的实现 3.编写前置通知的逻辑代码 4.编写XML配置文件 通过AOP环绕通知实现事务控制 1.导入相关的依赖 <dependencies> <dependency> <groupId>org.springframework</groupId> <ar

  • 浅谈spring aop的五种通知类型

    spring aop通知(advice)分成五类:  前置通知[Before advice]:在连接点前面执行,前置通知不会影响连接点的执行,除非此处抛出异常. 正常返回通知[After returning advice]:在连接点正常执行完成后执行,如果连接点抛出异常,则不会执行. 异常返回通知[After throwing advice]:在连接点抛出异常后执行. 返回通知[After (finally) advice]:在连接点执行完成后执行,不管是正常执行完成,还是抛出异常,都会执行返回

  • SpringAOP四种通知类型+环绕通知说明

    目录 一.四种常见的通知类型 注意 二.环绕通知 1.改动日志类 Logger.java 2.改动配置文件 分析 AOP机制之环绕通知的见解 其中有五个通知类型 SpringAOP的四种通知类型:前置通知.异常通知.后置通知.异常通知 一.四种常见的通知类型 给出 账户的业务层接口 IAccountService.java, 为了便于演示这四种通知类型,我们就只留下了一个方法. public interface IAccountService { void saveAccount(); } 给出

  • 浅谈python 四种数值类型(int,long,float,complex)

    Python支持四种不同的数值类型,包括int(整数)long(长整数)float(浮点实际值)complex (复数),本文章向码农介绍python 四种数值类型,需要的朋友可以参考一下. 数字数据类型存储数值.他们是不可改变的数据类型,这意味着改变数字数据类型的结果,在一个新分配的对象的值. Number对象被创建,当你给他们指派一个值.例如: var1 = 1 var2 = 10 您也可以删除数字对象的参考,使用del语句. del语句的语法是: del var1[,var2[,var3[

  • Docker四种网络类型原理实例解析

    四种网络类型: None:不为容器配置任何网络功能,--net=none Container:与另一个运行中的容器共享Network Namespace,--net=container:containerID(K8S) Host:与宿主机共享Network Namespace,--net=host Bridge:Docker设计的NAT网络模型 下面分别讲解下: none: [root@docker1 centos_zabbix]# docker run -it --network none c

  • angular 动态组件类型详解(四种组件类型)

    组件类型1:纯函数功能,而没有视图部分,即Factory(类似于$http) promise.component.html 常见的有内置的$http,$q之类的.一般使用promise与作用域进行交互 组件类型2:不是常驻于视图,而是动态插入的.有UI的一类组件,有输入交互.不常被调用(类似于Model对话框) factory.component.html 并发性.这里收到es6的启发.在factory内使用了构造函数,来区分不同的实例.当然,factory接口返回的类型要根据需求来定:仅仅是一

  • 一文搞懂Spring AOP的五大通知类型

    目录 一.通知类型 二.环境准备 添加AOP依赖 创建目标接口和实现类 创建通知类 创建Spring核心配置类 编写运行程序 三.添加通知 普通通知 环绕通知(重点) 一.通知类型 Advice 直译为通知,也有人翻译为 “增强处理”,共有 5 种类型,如下表所示. 通知类型 注解 说明 before(前置通知) @Before 通知方法在目标方法调用之前执行 after(后置通知) @After 通知方法在目标方法返回或异常后调用 after-returning(返回通知) @AfterRet

  • SpringMVC 方法四种类型返回值总结(你用过几种)

    SpringMVC 现在算是 Java 领域的一个基础性框架了,很多人天天用,可是对于 SpringMVC 方法的返回值,你又是否完全清楚呢?今天松哥就来和大家聊一聊 SpringMVC 中四种不同类型的返回值,看看有没有 get 到你的知识盲点? 1. ModelAndView 以前前后端不分的情况下,ModelAndView 应该是最最常见的返回值类型了,现在前后端分离后,后端都是以返回 JSON 数据为主了.后端返回 ModelAndView 这个比较容易理解,开发者可以在 ModelAn

  • 深入C++四种强制类型转换的总结

    c++中提供了四种新的强制转换分别是:const_cast.dynamic_cast.reinterpret_cast.static_cast.这四种转换类型,每一种都适用于特定的目的:const_cast 一般用于强制取消对象的常量性.它是唯一能够做到这一点的C++风格的强制转型.dynamic_cast 主要用于执行"安全向下转型",也就是说,要确定一个对象是否是一个继承体系中的一个特定类型.它是唯一不能用旧风格语法执行强制转型.reinterpret_cast 是特意用于底层转型

随机推荐