Spring AOP 编程入门（二）

最新推荐文章于 2024-10-19 14:41:34 发布
最新推荐文章于 2024-10-19 14:41:34 发布
阅读量3.7k 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： Spring Boot 文章标签： aop spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27462223/article/details/106833823

 

         相信大家通过上一篇的Spring AOP 编程入门对AOP 的术语已经有了一定的认知，概念看起来总是有点懵，所以需要慢慢在应用中理解，今天主要是通过一些小例子加深一下aop在实际应用中到底能干嘛。

一、初步认识 Spring AOP

1. Spring AOP 的特点

AOP 框架有很多种, Spring 中的 AOP 是通过动态代理实现的。不同的 AOP 框架支持的连接点也有所区别，例如，AspectJ 和 JBoss,除了支持方法切点，它们还支持字段和构造器的连接点。而 Spring AOP 不能拦截对对象字段的修改，也不支持构造器连接点,我们无法在 Bean 创建时应用通知。

2. Spring AOP 的简单例子

上一篇博客我们也新建了一个小demo,主要是为了弄清楚advice（通知）执行的顺序。

首先先创建一个接口TakeawayService.java:

package com.example.demo.service;

import com.sun.org.apache.xpath.internal.objects.XString;

public interface TakeawayService {
    /**
     * 点餐接口
     * @return
     */
    public String Order();
}

在创建两个类实现TakeawayService.java；

ZSServiceImpl.java:
package com.example.demo.service.impl;

import org.springframework.stereotype.Service;
import com.example.demo.service.TakeawayService;
@Service
public class ZSServiceImpl implements TakeawayService {

    @Override
    public String Order() {
        return "张三点了一份爆浆牛丸";
    }
}

 

WMZServiceImpl.java:
package com.example.demo.service.impl;

import com.example.demo.service.TakeawayService;
import com.example.demo.service.UserService;
import org.springframework.stereotype.Service;

@Service
public class WMZServiceImpl implements TakeawayService {

    @Override
    public String Order()
    {
        return  "王麻子点了一份瓜皮香锅";
    }
}

 测试方法TakeController.java:

package com.example.demo.controller;

import com.example.demo.entity.Response;
import com.example.demo.entity.ResponseResult;
import jdk.internal.org.objectweb.asm.tree.analysis.Value;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.example.demo.service.TakeawayService;
@RestController
@RequestMapping("/api")
public class TakeController {

    /**
     *此处@Autowired 也可替换为 @Resource(name="") name:中填写你想注入的bean对象名称
     * 如：@Resource("WMZServiceImpl")
     * private  TakeawayService wmzService;
     */
    @Qualifier("WMZServiceImpl")//指定注入的bean对象名称
    @Autowired
    private  TakeawayService wmzService;
    @Qualifier("ZSServiceImpl")
    @Autowired
    private  TakeawayService zsService;

    @RequestMapping("/order")
    public ResponseResult Orde()
    {
       String wmz= wmzService.Order();
       String zs=zsService.Order();
        System.out.println(wmz);
        System.out.println(zs);
        return Response.makeOKRsp(wmz+";"+zs);
    }

}

运行结果：

 然后隔了一段时间，产品经理觉得我们可不可以在用户点餐之前整点提示性语言比如,阿里阿塞哟、刷我滴卡、亚麻带类似的，当然其它的暂时也没想到了。那么这个我们怎么办？要么是新定义一个方法，要么就在原来的点餐方法里重写各自的方法，照这样的进度下去东京热不热我不清楚，反正上海今天是真的热。如果用aop 来解决的话就没上面这种难以维护了，让我们先加一个亚麻带。

2.1.引用依赖：


<!--引入AOP依赖-->
   <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
   </dependency>

2.2.新建切面类

按照上一篇通知执行的顺序可知在此场景我们需要用到@Before，新建切面类OrderAop.java:
package com.example.demo.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect // 表示它是一个切面。
@Component //表明它将作为一个Spring Bean 被装配
public class OrderAop {
    /**
     * @description  在连接点执行之前执行的通知
     */
    @Before("execution(public * com.example.demo.service.TakeawayService.*(..)))")
    public void doBefore(){
        System.out.println("阿里阿塞哟！");
    }
}

然后在运行看下结果：

这样就可以完全没有去更改之前的代码，通过aop实现了这个“阿里阿塞哟”。

然后又隔了几天，这个产品经理啊又开始搞事了，说什么今天天气不错，或者今年是张san的本命年，更有甚者是说zs最近心情不好，所以咱们要临时取消zs的‘阿里阿塞哟’，只通知wmz,这个时候不要慌，Spring AOP 所支持的 AspectJ 切点指示器完全能实现这个变态要求。

2.3. Spring AOP 所支持的 AspectJ 切点指示器

网上找了一张图，大家伙讲究看下，更详细的说明可以自己再找找博文资料之类。

修改OrderAop.java:

package com.example.demo.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect // 表示它是一个切面。
@Component //表明它将作为一个Spring Bean 被装配
public class OrderAop {
    /**
     * @description  在连接点执行之前执行的通知
     * 全匹配
     * execution(public * com.example.demo.service.TakeawayService.*(..)))
     * 只匹配zs within 限定该切点仅匹配的包 bean 在切点中选择
     * execution(public * com.example.demo.service.TakeawayService.Order(..)) && within(com.example.demo.service.impl.*) && bean(ZSServiceImpl)
     */
    @Before("execution(public * com.example.demo.service.TakeawayService.Order(..)) && within(com.example.demo.service.impl.*) && bean(ZSServiceImpl)")
    public void doBefore(){
        System.out.println("阿里阿塞哟！");
    }
}

此时，切面只会对 ZSServiceImpl.java 这个类生效，执行结果：

切面就是这么社会，所以我以后再也不怕产品经理让我改亚麻带了。 

3. Spring AOP 中5 种通知类型

上一篇博客已经有描述过具体是那五种通知，以及各自的执行顺序这里就不再加以描述了,就只贴一张网图当做复习了。

图看着像是有重影，但是碍于本人比较懒，所以就懒得找别的图了。

3.1.  通知执行顺序

再次修改切面类OrderAop.java:

package com.example.demo.aop;

import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * 饿鸟嘛配送
 **/
@Aspect
@Component
public class EatAop {

    /**
    *@description 定义切入点，切入点为com.example.demo.controller.AopController中的所有函数
    *@description 通过@Pointcut注解声明频繁使用的切点表达式
    * */
    @Pointcut("execution(public * com.example.demo.controller.AopController.*(..)))")
    public void EatAop()
    {

    }
    /**
     * @description  在连接点执行之前执行的通知
     */
    @Before("EatAop()")
    public void doBeforeEat(){
        System.out.println("饿鸟嘛配送员登录接单系统为接单做准备！");
    }

    /**
     * @description  在连接点执行之后执行的通知（返回通知和异常通知的异常）
     */
    @After("EatAop()")
    public void doAfterEat(){
        System.out.println("饿鸟嘛配送员为今天的外卖单量感到异常吃惊！");
    }

    /**
     * @description  在连接点执行之后执行的通知（返回通知）
     */
    @AfterReturning("EatAop()")
    public void doAfterReturningEat(){
        System.out.println("返回的通知：饿鸟嘛配送员接单完毕，并会心一笑百媚生！");
    }

    /**
     * @description  在连接点执行之后执行的通知（异常通知）
     */
    @AfterThrowing("EatAop()")
    public void doAfterThrowingGame(){
        System.out.println("异常通知：服务错误，请联系饿鸟嘛系统管理员！");
    }

}

修改ZSServiceImpl.java:

package com.example.demo.service.impl;

import org.springframework.stereotype.Service;
import com.example.demo.service.TakeawayService;
@Service
public class ZSServiceImpl implements TakeawayService {

    @Override
    public String Order() {
        System.out.println("zs爆浆牛丸");
        return "张三点了一份爆浆牛丸";
    }
}

修改 WMZServiceImpl.java:

package com.example.demo.service.impl;

import com.example.demo.service.TakeawayService;
import com.example.demo.service.UserService;
import org.springframework.stereotype.Service;

@Service
public class WMZServiceImpl implements TakeawayService {

    @Override
    public String Order()
    {
        System.out.println("wmz瓜皮香锅");
        return  "王麻子点了一份瓜皮香锅";
    }
}

 运行结果如下：

3.2. SpringAOP增强处理 @around

@Around的作用

既可以在目标方法之前织入增强动作，也可以在执行目标方法之后织入增强动作；
可以决定目标方法在什么时候执行，如何执行，甚至可以完全阻止目标目标方法的执行；
可以改变执行目标方法的参数值，也可以改变执行目标方法之后的返回值； 当需要改变目标方法的返回值时，只能使用Around方法；

切面类OrderAop.java新增以下方法：

 /**
     * @description 定义增强
     * @param pj
     */
    @Around("point()")
    public void doAround(ProceedingJoinPoint pj) {
        try {
            System.out.println("Around 调用方法前 ");
            pj.proceed();
            System.out.println("Around 调用方法后");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

运行结果：

 结果显而易见，值得注意的是 @Around 修饰的环绕通知类型，是将整个目标方法封装起来了，在使用时，我们需要调用 ProceedingJoinPoint 的 proceed() 方法。 如果没有调用 该方法，执行结果为 ：

 

所以，如果不调用该对象的 proceed() 方法，表示原目标方法被阻塞调用。

3.3  通过注解处理通知中的参数

上面的例子，我们要进行增强处理的目标方法没有参数，在有参数的情况，并且在增强处理中使用该参数。
下面我们给接口增加一个参数，表示购买所花的金钱。通过AOP 增强处理，如果sz下单超过了了 4396元，就可以赠送一份鲜果饮汇源牌饮料。

代码修改如下：

TakeawayService.java
package com.example.demo.service;

import com.sun.org.apache.xpath.internal.objects.XString;

public interface TakeawayService {
    /**
     * 点餐接口
     * @return
     */
    public String Order(double price);
}

ZSServiceImpl.java
package com.example.demo.service.impl;

import org.springframework.stereotype.Service;
import com.example.demo.service.TakeawayService;
@Service
public class ZSServiceImpl implements TakeawayService {

    @Override
    public String Order(double price) {
        System.out.println("zs爆浆牛丸:"+price);
        return "张三点了一份爆浆牛丸";
    }
}

 

WMZServiceImpl.java

package com.example.demo.service.impl;

import com.example.demo.service.TakeawayService;
import com.example.demo.service.UserService;
import org.springframework.stereotype.Service;

@Service
public class WMZServiceImpl implements TakeawayService {

    @Override
    public String Order(double price)
    {
        System.out.println("wmz瓜皮香锅:"+price);
        return  "王麻子点了一份瓜皮香锅";
    }
}

 TakeController.java

package com.example.demo.controller;

import com.example.demo.entity.Response;
import com.example.demo.entity.ResponseResult;
import jdk.internal.org.objectweb.asm.tree.analysis.Value;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.example.demo.service.TakeawayService;
@RestController
@RequestMapping("/api")
public class TakeController {

    /**
     *此处@Autowired 也可替换为 @Resource(name="") name:中填写你想注入的bean对象名称
     * 如：@Resource("WMZServiceImpl")
     * private  TakeawayService wmzService;
     */
    @Qualifier("WMZServiceImpl")//指定注入的bean对象名称
    @Autowired
    private  TakeawayService wmzService;
    @Qualifier("ZSServiceImpl")
    @Autowired
    private  TakeawayService zsService;

    @RequestMapping("/order")
    public ResponseResult Orde()
    {
       String wmz= wmzService.Order(12);
        System.out.println(wmz);
       String zs=zsService.Order(4396);
        System.out.println(zs);
        return Response.makeOKRsp(wmz+";"+zs);
    }

}

OrderAop.java
package com.example.demo.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect // 表示它是一个切面。
@Component //表明它将作为一个Spring Bean 被装配
public class OrderAop {

    /**
     *@description 定义切入点，切入点为execution(public * com.example.demo.service.TakeawayService.*(..)))中的所有函数
     *@description 通过@Pointcut注解声明频繁使用的切点表达式
     * */
    @Pointcut("execution(public * com.example.demo.service.TakeawayService.Order(double)) && args(price) && bean(ZSServiceImpl)")
    public void point(double price)
    {

    }

    /**
     * @description  在连接点执行之前执行的通知
     * 全匹配
     * execution(public * com.example.demo.service.TakeawayService.*(..)))
     * 只匹配zs within 限定该切点仅匹配的包 bean 在切点中选择
     * execution(public * com.example.demo.service.TakeawayService.Order(..)) && within(com.example.demo.service.impl.*) && bean(ZSServiceImpl)
     */
  /*  @Before("point()")
    public void doBefore(){
        System.out.println("阿里阿塞哟！");
    }
*/
    /**
     * @description  在连接点执行之后执行的通知（返回通知和异常通知的异常）
     */
   /* @After("point()")
    public void doAfter(){
        System.out.println("after！");
    }
*/

   /**
     * @description  在连接点执行之后执行的通知（返回通知）
     */
   // @AfterReturning("point()")
   // public void doAfterReturning(){

   //     System.out.println("返回通知：AfterReturning");
  //  }

    /**
     * @description  在连接点执行之后执行的通知（异常通知）
     */
    //@AfterThrowing("point()")
    //public void doAfterThrowing(){
      //  System.out.println("异常通知：AfterThrowing");
   // }


    /**
     * @description 定义增强
     * @param pj
     */
    @Around("point(price)")
    public String doAround(ProceedingJoinPoint pj,double price) {
        try {
            System.out.println("Around 调用方法前 ");
            pj.proceed();
            if(price>=4396)
            {
                System.out.println("zs下单超过了4399，赠送一份鲜果饮汇源牌饮料");
                return "爆浆牛丸和饮料";
            }
            System.out.println("Around 调用方法后");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return "爆浆牛丸";
    }

}

运行结果：

我们 可以看到，结果和预想的一致。因时间关系本人临时有事处理，决定吧原本今天 的XML 配置文件声明切面，放在明天另写一篇。

小结

 spring aop 的简单运用今天就到这儿了，下次再见铁汁们！

源码：https://github.com/LeeCurtain/demo.git

Spring AOP快速入门详解
流楚丶格念的博客
07-24 1919
AOP(AspectOrientedProgramming)面向切面编程，一种编程范式，指导开发者如何组织程序结构OOP(ObjectOrientedProgramming)面向对象编程作用在不惊动原始设计的基础上为其进行功能增强。简单的说就是在不改变方法源代码的基础上对方法进行功能增强。相当于给一个函数附加功能，例如给吕布的大招加上技能前特效摇摆与技能后特效唱歌，那么吕布再摁下大招，先会摇摆一下，再跳大，跳完大技能还没结束，还得唱个歌。Spring理念无入侵式/无侵入式。.........
Spring: AOP 面向切面编程——实现通知的三种方法
weixin_30914981的博客
08-14 459
通知： 　　前置通知：运行目标方法前时，运行的通知； 　　后置通知：运行目标方法后时，运行的通知； 　　异常通知：运行目标方法发生异常时，运行的通知； 　　环绕通知：在环绕通知中可以定义，前置通知、后置通知、异常通知和最终通知，比较全面； 　　最终通知：运行方法后，都会运行的通知； 让我们用一张图来更加好的理解这几个通知： 一、通过接口实现通知 　　前置通知：继承Me...
SpringAop业务逻辑简单讲解（存取钱案例 三）
m0_55955242的博客
07-09 295
使用代理通知完善业务逻辑 1.首先还是BankDao接口 package com.xiao.dao; public interface BankDao { // 存钱 public void saveMoney(); // 取钱 public void withdrawMoney(); // 转帐 public void transfer(); } 2.实现接口 package com.xiao.dao.daoImp; import com.xia
SpringBoot - 利用自定义注解@ResponseResult和ResponseBodyAdvice接口进行统一响应处理
你今天真好看呀
10-25 2429
*** 此注解用于返回值包装，将返回值包装成{@link com.hh.vo.ApiResponse}对象}实现ResponseBodyAdvice接口，其实是对加了@RestController(也就是@Controller+@ResponseBody)注解的处理器将要返回的值进行增强处理。此接口对添加了@Controller和@ResponseBody的类织入一个通知 (增强功能)/*** 返回值统一处理类。
统一返回封装类ResponseResult
qq_43049583的博客
08-07 756
统一返回封装类ResponseResult
Spring AOP基础
小百的博客
03-21 1721
最近在项目中看到关于AOP的使用JDK动态代理去实现的，记录一下，在简书看到了一张图 简书原文地址
SpringSpring Aop基础入门
09-26
本篇文档将以“Spring AOP基础入门”为主题，深入浅出地介绍Spring AOP的基础知识，并通过基于XML的练习加深理解。 首先，需要了解的是Spring AOP的核心概念。在AOP中，核心概念包括切面（Aspect）、通知（Advice）...
Spring Aop基础入门
09-26
在了解Spring AOP的基础入门知识前，我们首先需要明确AOP（面向切面编程）的定义。AOP是一种编程范式，旨在将横切关注点（cross-cutting concerns）从业务逻辑代码中分离出来，以减少代码之间的耦合。在Spring框架中...
Spring AOP 详解
最新发布
2301_80035594的博客
10-19 6246
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
Spring AOP入门Demo分享
08-28
Spring AOP（面向切面编程）是Spring框架的重要组成部分，它提供了在不修改源代码的情况下，对现有代码进行扩展和增强的功能。AOP的主要目的是解耦关注点，将横切关注点（如日志、事务管理、安全检查等）从核心业务...
Spring AOP 切入点表达式说明
Geoffrey's blog
07-15 324
execution: 匹配方法的执行(常用) execution(表达式) 表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数)) 写法说明： 全匹配方式： public void org.hodge.service.impl.CustomerServiceImpl.saveCustomer() ...
java spring 环绕通知 ProceedingJoinPoint 执行proceed方法的作用是什么
热门推荐
ITCBL
01-26 4万+
java spring 环绕通知 ProceedingJoinPoint 执行proceed方法的作用是什么 ? 环绕通知 ProceedingJoinPoint执行proceed方法的作用是让目标方法执行，这也是环绕通知和前置、后置通知方法的一个最大区别。 简单理解，环绕通知=前置+目标方法执行+后置通知，proceed方法就是用于启动目标方法执行的. ...
ProceedingJoinPoint
weixin_45822542的博客
06-24 895
方法，可以控制目标方法的执行，并在方法执行前后执行自定义操作。在你的 Spring Boot 主类中启用 AOP 支持。，这在日志记录、事务管理、安全控制等方面非常有用。切面将拦截方法调用，并输出方法名称、参数和结果。定义一个简单的服务类，该类的方法将被切面增强。下面是一个使用 Spring AOP 和。中引入了Spring AOP 的依赖。方法，可以继续执行目标方法，而在。方法调用之前和之后执行自定义逻辑。的子接口，它提供了一个。创建一个切面类，并使用。启动应用程序后，当调用。
Spring（九）SpringAOP
起舞的风的博客
04-24 238
1、AOP 1.1、什么是AOP AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同...
SpringAOP中的JointPoint和ProceedingJoinPoint使用总结
huluwa10526的博客
12-09 4915
一、Joint Point JointPoint是程序运行过程中可识别的点，这个点可以用来作为AOP切入点。JointPoint对象则包含了和切入相关的很多信息。比如切入点的对象，方法，属性等。我们可以通过反射的方式获取这些点的状态和信息，用于追踪tracing和记录logging应用信息。 二、Pointcut pointcut 是一种程序结构和规则，它用于选取join point并收集这些point的上下文信息。 pointcut通常包含了一系列的Joint Point，我们可以通过pointcut来同
Restful API返回统一响应体
bossaiaboy的专栏
03-20 1万+
参考文档： https://github.com/kuitos/kuitos.github.io/issues/9 对于客户端开发或者网站开发而言，调用接口返回有统一的响应体，可以针对性的设计界面，代码结构更加清晰，层次也更加分明。 所以需要调用api时，要求返回结构的数据实体。以下就分享以下我的实现方法； 1、建立统一数据结构类@JsonInclude(JsonInclude.Inclu
后端异常统一处理解决方案--无需controller单独对每个方法捕获
laoyog
02-19 5469
代码在最后，欢迎批评与改正！ 在项目中，特别是前后端分离的项目，后台往往需要向前端返回统一的json数据格式，如 public Result findAll{ try{ //业务代码... return new Result("200","操作成功",json数据); }catch(Exception e){ ...
Spring AOP讲解（Pointcut、Before、Around、AfterReturning、After）
qq_28834355的博客
08-24 5154
AOP依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> @Pointcut 定义切入点，有以下2种方式： 方式一：设置为注解@LogFilter1标记的方法，有标记的方法触发该AOP，没有标记就没有。 @Aspect @C
Spring AOP详解一文搞懂@Aspect、@Pointcut、@Before、@Around、@After、@AfterReturning、@AfterThrowing
u011047968的专栏
02-20 2万+
文章目录1、AOP是什么2、AOP中注解的含义3、Pointcut切入点的语法4、AOP代码实现 1、AOP是什么 AOP：Aspect Oriented Programming，翻译过来就是大名鼎鼎的“面向切面编程”，它是对面向对象的一种补充和完善。 AOP的使用场景一般有：数据源切换、事务管理、权限控制、日志打印等。根据它的名字我们不难理解，它的实现很像是将我们要实现的代码切入业务实现的逻辑中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值