从零开始学Spring（九）——AOP通知类型

最新推荐文章于 2024-05-24 02:08:26 发布
最新推荐文章于 2024-05-24 02:08:26 发布
阅读量156 收藏
点赞数
分类专栏： Spring 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tony_chenph/article/details/119765777
版权

      根据通知在目标方法执行前后位置的织入分为前置通知、后置通知、环绕通知、异常抛出通知以及最终通知

  • 前置通知

前置通知指的是在目标方法执行之前进行操作

  1. 编写切面类myAspect
public class myAspect {
    public void check(){
        System.out.println("权限校验");
    }
}
  1. 编写业务类Goods
public class Goods {
    public void save(){
        System.out.println("执行保存方法");
    }
}
  1. 配置applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:annotation-config/>

    <bean id="goods" class="com.ph.demo2.Goods"/>
    <bean id="myaspect" class="com.ph.demo2.myAspect"/>

    <!--配置AOP完成对目标产生代理-->
    <aop:config>
        <!--配置切入点，也就是需要被增强的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.ph.demo2.Goods.save())"/>
       <!--配置切面，也就是增加的内容（通知）ref为哪一个类-->
        <aop:aspect ref="myaspect">
            <!--method为添加哪一个 方法 pointcut-ref表示添加到哪一个切入点-->
            <!--aop：before为通知类型，表示前置通知-->
            <aop:before method="check" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
</beans>
  1. 编写测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class testClass {
    @Autowired
    private Goods goods;
   @Test
    public void test(){
       goods.save();
   }
}

运行结果

 

  • 后置通知

在目标方法执行之后进行操作

  1. 编写切面类myAspect 
public class myAspect {
    public void check(){
        System.out.println("权限校验");
    }
    public void log(){
        System.out.println("记录日志");
    }
}
  1. 编写业务类Goods
public class Goods {
    public void save(){
        System.out.println("执行保存方法");
    }
}
  1. 编写applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:annotation-config/>

    <bean id="goods" class="com.ph.demo2.Goods"/>
    <bean id="myaspect" class="com.ph.demo2.myAspect"/>

    <!--配置AOP完成对目标产生代理-->
    <aop:config>
        <!--配置切入点，也就是需要被增强的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.ph.demo2.Goods.save())"/>
       <!--配置切面，也就是增加的内容（通知）ref为哪一个类-->
        <aop:aspect ref="myaspect">
            <!--method为添加哪一个 方法 pointcut-ref表示添加到哪一个切入点-->
            <!--aop：before为通知类型，表示前置通知-->
            <aop:before method="check" pointcut-ref="pointcut"/>
            <!--aop：after为通知类型，表示后置通知-->
            <aop:after method="log" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
</beans>
  1. 编写测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class testClass {
    @Autowired
    private Goods goods;
   @Test
    public void test(){
       goods.save();
   }
}

运行结果

  • 环绕通知

在目标方法执行之前和之后都要进行的操作，使用public Object around（）

  1. 编写切面类myAspect
public class myAspect {
    public void check(){
        System.out.println("权限校验");
    }
    public void log(){
        System.out.println("记录日志");
    }
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前通知");
        Object proceed = joinPoint.proceed();
        System.out.println("环绕后通知");
        return proceed;
    }
}
  1. 编写业务类
public class Goods {
    public void save(){
        System.out.println("执行保存方法");
    }
}
  1. 编写applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:annotation-config/>

    <bean id="goods" class="com.ph.demo2.Goods"/>
    <bean id="myaspect" class="com.ph.demo2.myAspect"/>

    <!--配置AOP完成对目标产生代理-->
    <aop:config>
        <!--配置切入点，也就是需要被增强的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.ph.demo2.Goods.save())"/>
       <!--配置切面，也就是增加的内容（通知）ref为哪一个类-->
        <aop:aspect ref="myaspect">
            <!--method为添加哪一个 方法 pointcut-ref表示添加到哪一个切入点-->
            <!--aop：before为通知类型，表示前置通知-->
            <aop:before method="check" pointcut-ref="pointcut"/>
            <!--aop：after-returning为通知类型，表示后置通知-->
            <aop:after-returning method="log" pointcut-ref="pointcut"/>
            <!--aop：around为通知类型，表示环绕通知-->
            <aop:around method="around" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
</beans>
  1. 编写测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class testClass {
    @Autowired
    private Goods goods;
   @Test
    public void test(){
       goods.save();
   }
}

运行结果

  • 异常抛出通知

在程序出现异常时进行操作，否则不操作

  1. 编写切面类myAspect
public class myAspect {
    public void check(){
        System.out.println("权限校验");
    }
    public void log(){
        System.out.println("记录日志");
    }
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前通知");
        Object proceed = joinPoint.proceed();
        System.out.println("环绕后通知");
        return proceed;
    }
    public void exceptionNotice(){
        System.out.println("程序出异常啦");
    }
}
  1. 编写业务类Goods
public class Goods {
    public void save(){
        int a=10/0;//写入异常
        System.out.println("执行保存方法");
    }
}
  1. 配置applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:annotation-config/>

    <bean id="goods" class="com.ph.demo2.Goods"/>
    <bean id="myaspect" class="com.ph.demo2.myAspect"/>

    <!--配置AOP完成对目标产生代理-->
    <aop:config>
        <!--配置切入点，也就是需要被增强的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.ph.demo2.Goods.save())"/>
       <!--配置切面，也就是增加的内容（通知）ref为哪一个类-->
        <aop:aspect ref="myaspect">
            <!--method为添加哪一个 方法 pointcut-ref表示添加到哪一个切入点-->
            <!--aop：before为通知类型，表示前置通知-->
            <aop:before method="check" pointcut-ref="pointcut"/>
            <!--aop：after-returing 为通知类型，表示后置通知-->
            <aop:after-returning method="log" pointcut-ref="pointcut"/>
            <!--aop：around为通知类型，表示环绕通知-->
            <aop:around method="around" pointcut-ref="pointcut"/>
            <!--aop：after-throwing为通知类型，表示异常抛出通知-->
            <aop:after-throwing method="exceptionNotice" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
</beans>
  1. 编写测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class testClass {
    @Autowired
    private Goods goods;
   @Test
    public void test(){
       goods.save();
   }
}

运行结果

  • 最终通知

无论程序是否出现异常都会执行操作

  1. 编写切面类myAspect
public class myAspect {
    public void check(){
        System.out.println("权限校验");
    }
    public void log(){
        System.out.println("记录日志");
    }
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前通知");
        Object proceed = joinPoint.proceed();
        System.out.println("环绕后通知");
        return proceed;
    }
    public void exceptionNotice(){
        System.out.println("程序出异常啦");
    }
    public void finallyNotice(){
        System.out.println("程序执行完毕，释放资源");
    }
}
  1. 编写业务类Goods
public class Goods {
    public void save(){
        int a=10/0;
        System.out.println("执行保存方法");
    }
}
  1. 配置applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:annotation-config/>

    <bean id="goods" class="com.ph.demo2.Goods"/>
    <bean id="myaspect" class="com.ph.demo2.myAspect"/>

    <!--配置AOP完成对目标产生代理-->
    <aop:config>
        <!--配置切入点，也就是需要被增强的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.ph.demo2.Goods.save())"/>
       <!--配置切面，也就是增加的内容（通知）ref为哪一个类-->
        <aop:aspect ref="myaspect">
            <!--method为添加哪一个 方法 pointcut-ref表示添加到哪一个切入点-->
            <!--aop：before为通知类型，表示前置通知-->
            <aop:before method="check" pointcut-ref="pointcut"/>
            <!--aop：after-returing 为通知类型，表示后置通知-->
            <aop:after-returning method="log" pointcut-ref="pointcut"/>
            <!--aop：around为通知类型，表示环绕通知-->
            <aop:around method="around" pointcut-ref="pointcut"/>
            <!--aop：after-throwing为通知类型，表示异常抛出通知-->
            <aop:after-throwing method="exceptionNotice" pointcut-ref="pointcut"/>
            <!--aop：after为通知类型，表示最终通知-->
            <aop:after method="finallyNotice" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
</beans>
  1. 编写测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class testClass {
    @Autowired
    private Goods goods;
   @Test
    public void test(){
       goods.save();
   }
}

程序出现异常运行结果

修改异常程序片段后运行结果

补充说明配置文件中的AOP切入点表达式的涵义

<!--配置切入点，也就是需要被增强的方法-->

  <aop:pointcut id="pointcut" expression="execution(* com.ph.demo2.Goods.save())"/>

它是基于execution函数完成格式为（【访问修饰符】 方法返回值 包名.类名.方法名（参数））

Public com.ph.demo2.Goods.save(..)  表示参数为任意参数

* com.ph.demo2.Goods.save(..)  *表示任意类型

* com.ph.demo2.Goods+.save(..)  +表示当前类的子类

* com.ph.demo2..*.*(..)  表示com.ph.demo2包以及子包下的所有类的所有方法

Tony_chenph
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈spring aop的五种通知类型
08-28
主要介绍了浅谈spring aop的五种通知类型，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringAOP 前置通知、后置通知
weixin_33857230的博客
06-13 231
AspectJ：Java社区中最完整、最流行的AOP框架。在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。在Spring中2启用AspectJ注解支持：1、要在Spring应用中使用AspectJ注解，需要添加spring-aspect、aspectj-weaver、aopalliance依赖2、将aop Schema添加...
spring aop的五种通知类型
热门推荐
cqabl的专栏
07-20 4万+
spring aop通知(advice)分成五类： 前置通知、正常返回通知、异常返回通知、返回通知、环绕通知
关于Spring Aop 通知类型
weixin_30593261的博客
03-08 74
1. 前置通知 * 在目标类的方法执行之前执行。 * 配置文件信息：<aop:after method="before" pointcut-ref="myPointcut3"/> * 应用：可以对方法的参数来做校验 2. 最终通知 * 在目标类的方法执行之后执行，如果程序出现了异常，最终通知也会执行。 * 在配置文件中编写具体的配置：<aop:after method...
Spring AOP 通知类型
qq_64360391的博客
12-13 2138
·AOP中的通知一共分为五种类型，分别为：前置通知 ，后置通知，环绕通知，异常通知以及最终通知。 try{ // 前置通知、环绕通知 // 目标类的方法 // 后置通知、环绕通知 } catch() { // 抛出异常通知 } finally { // 最终通知 } //前置通知 @Before //后置通知 @AfterReturning //环绕通知 @Around //抛出异常通知 @AfterThrowing //最终通知 @After 1.1环境搭...
如何使用Spring AOP的通知类型及创建通知
08-25
主要给大家介绍了关于如何使用Spring AOP的通知类型及创建通知的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Spring AOP具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
详解Spring学习总结——Spring实现AOP的多种方式
08-31
主要介绍了详解Spring学习总结——Spring实现AOP的多种方式，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring 入门案例——AOP
08-19
配套教材，里面的代码测试过都是可运行的，配套学习很方便
Spring——aop
12-23
里面是精确的讲解了Aop 的配置 初级人员能够读懂的
Spring AOP（5种通知类型）
kimi
03-08 1817
Spring AOP（5种通知类型）
Spring AOP 五种通知类型
Dark丶照萤映雪
02-04 2757
1.before：前置通知，在一个方法执行前被调用。 2.after: 在方法执行之后调用的通知，无论方法执行是否成功。 3.after-returning: 仅当方法成功完成后执行的通知。 4.after-throwing: 在方法抛出异常退出时执行的通知。 5.around: 在方法执行之前和之后调用的通知。
Spring aop 五种通知类型
小熊
12-20 9415
Spring aop 五种通知类型 spring aop 的五种通知类型 前置通知 Before advice：在连接点前面执行，前置通知不会影响连接点的执行，除非此处抛出异常 后置通知 After returning advice：在连接点正常执行完成后执行，如果连接点抛出异常，则不会执行 异常通知 After throwing advice：在连接点抛出异常后执行 最终通知 After (finally) advice：在连接点执行完成后执行，不管是正常执行完成，还是抛出异常，都会执行返回通知中的内
Spring AOP的5种通知类型
流楚丶格念的博客
07-24 5747
AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置。编写通知类，我们使用5种通知类型分别配置update与save方法上。接下来我们将save中的除0操作取消注释。编写配置类，开启切面编程配置。再运行，发现运行异常通知。.........
Spring AOP 五大通知类型
sparky的博客
04-26 865
文章目录前置通知环绕通知后置通知异常通知最终通知五种通知执行的位置通知的执行顺序多个切面的执行顺序 前置通知 环绕通知 后置通知 异常通知 在目标方法抛出异常时执行的通知 最终通知 有异常时： 没有异常时： 五种通知执行的位置 通知的执行顺序 没有异常时的执行顺序 出现异常的执行顺序 多个切面的执行顺序 没有异常时： 出现异常时： ...
spring框架中AOP 五种通知类型
fight_man8866的博客
03-11 781
前置通知(@Before)：logStart：在目标方法(div)运行之前运行 后置通知(@After)：logEnd：在目标方法(div)运行结束之后运行（无论方法正常结束还是异常结束） 返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行 异常通知(@AfterThrowing)：logException：在目标方法(div)出现异常以后运行 环...
Spring Aop 五大通知类型的配置和使用
weixin_50800726的博客
05-05 237
SpringAop通知类型 前置通知(Before Advice) 在连接点之前执行的Advice，不过除非它抛出异常，否则没有能力中断执行流。使用 @Before 注解使用这个Advice。 //@Aspect //@Component public class BooksAspects { //前置 //@Before("execution (* com.tong.service.booksService.add())") public void beforeAspecte() {.
Spring AOP（通知、连接点、切点、切面）
qq_41589998的博客
03-12 359
通知（Advice）   切面的工作被称为通知。通知定义了切面是什么以及何时使用。除了描述切面要完成的工作，通知还解决了何时执行这个工作的问题。 5种通知类型： 前置通知（Before）：在目标方法被调用之前调用通知功能后置通知（After）：在目标方法完成之后调用通知，此时不会关心方法的输出是什么返回通知（After-returning）：在目标方法成功执行之后调用通知异常通知（After...
面试官：Spring AOP有哪些通知类型，它们的执行顺序是怎样的？
qfguan的博客
12-03 594
前言 这篇比较简单，但是群友反馈面试被问到了，关键还没答出来，而且还是项目中用的比较多的技术点。还是要在平时开发中有一丢丢好奇心，多点进去看看代码啊！ 通知类型 在基于Spring AOP编程的过程中，基于AspectJ框架标准，spring中定义了五种类型的通知，它们分别是： 前置通知 (@Before) 。 返回通知 (@AfterReturning) 。 异常通知 (@AfterThrowing) 。 后置通知 (@After)。 环绕通知 (@..
java学习和项目总结
最新发布
2301_79390585的博客
05-24 602
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
spring aop 通知类型
05-30
Spring AOP 中的通知类型有以下几种： 1. 前置通知（Before Advice）：在目标方法执行之前执行通知。 2. 后置通知（After Advice）：在目标方法执行之后执行通知，不论目标方法是否发生异常。 3. 返回通知（After...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值