SpringBoot实现AOP 简单测试切面选择不同连接点

最新推荐文章于 2024-07-05 10:07:39 发布
最新推荐文章于 2024-07-05 10:07:39 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： Spring AOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31615049/article/details/86910028
版权

在AOP中我们使用切点表达式来定义一个切点，他们通常有如下类型

匹配注解 @target限制连接点匹配特定的执行对象，这些对象对应的类要有具体指定类型的注解
匹配注解 @args限制连接点匹配参数为指定注解类型的执行方法
匹配注解 @within限制连接点匹配指定注解所标注的类型
匹配注解 @annotation限制连接点匹配方法上的注解
匹配包或类型 within限制连接点匹配指定的表或类
匹配对象 this限制连接点匹配AOP代理的bean引用为指定类型的类
匹配对象 bean限制连接点匹配一个指定的bean，需要指出bean的名字
匹配对象 target限制连接点匹配目标对象为指定类型的类
匹配参数 args限制连接点匹配参数为指定类型的执行方法
匹配方法 execution()匹配连接点的执行方法

基于几种常用的匹配方式对他们做一个简单的演示

首先我们编写演示demo所需要的基本功能建立我们的maven工程


加入Springboot和aop的相关的pom依赖

这里说明一下：

aop_annotation包存储所有的自定义注解。

aop_aspect存储自定义的切面

login是我们的业务包，用来编写业务实现

AopApplication是我们的测试启动类

两个页面login和main分别代表登录页和主页。

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
</dependencies>

编写基本的登陆Controller

package aop_manage.login;

import aop_manage.aop_annotation.VerifyLogin;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@RequestMapping("login")
@Controller
public class LoginController {
	private static final Logger logger = LoggerFactory.getLogger(LoginController.class);
	private static boolean login = false;

    /**
     * 登陆页面
     */

    @RequestMapping("/loginPage")
    public String loginPage() throws Exception {
        return "login";
    }
    
    /**
     * 访问主页
     */
    @RequestMapping("/doMainIndex")
    public String doMainIndex() throws Exception {
        return "main";
    }
}

下面我们尝试第一种简单的aop实现

一、within作为连接点

使用wihin他可以匹配一个包下的所有类或一个具体的类，使用的时候很简单，只需要增加注解

@Pointcut("within(aop_manage.login.LoginController)") //具体的一个类

或 @Pointcut("within(aop_manage.login.*)")   //通配符匹配的包下所有类

@Aspect
@Component
public class LoginAspectByWithin {
    @Pointcut("within(aop_manage.login.LoginController)")
    public void verifyLoginByWithin(){}

    @Before("verifyLoginByWithin()")
    public void beforeVerifyLoginByWithin(){
        System.out.println("执行校验登陆状态。。。");
    }
}

二、 Bean对象名作为连接点

使用bean的名称作为一个切点，然后织入我们的逻辑，使用的时候也很简单，只需要修改注解为

@Pointcut("bean(loginController)") //这里loginController为LoginController的beanname。他会拦截这个bean的全部方法

@Aspect
@Component
public class LoginAspectByBean {
    @Pointcut("bean(loginController)")
    public void verifyLoginByBean(){}

    @Before("verifyLoginByBean()")
    public void beforeVerifyLoginByBean(){
        System.out.println("执行校验登陆状态。。。");
    }
}

控制台日志不再赘述

三、this和target匹配连接点

使用this或target作为匹配对象的规则时，一般情况下他们是等效的，例如我们增加一点业务场景，编写一个商品服务类，增加新增商品和销售商品的方法。

/**
 * @program: aop_manage.login
 * @description:
 * @author: liujinghui
 * @create: 2019-02-10 16:18
 **/
@Service
public class ProductManage  {
    public void add() {
        System.out.println("添加商品");
    }
    public void sale() {
        System.out.println("卖出商品");
    }
}

之后编写切面

@Aspect
@Component
public class LoginAspectByThis {
    @Pointcut("this(aop_manage.login.ProductManage)")
    public void verifyLoginByThis(){}

    @Before("verifyLoginByThis()")
    public void beforeVerifyLoginByThis(){
        System.out.println("this...");
    }
}

这个时候运行程序，我们发现ProductManage所有方法都进行了增强，调用ProductManage的任何方法。当我页面访问增加商品逻辑时，控制台打印如下

同理将上述ProductManage进行改造，让它实现自ProductManageInterface接口。同时我们将this改造成Target，我们看看效果

public interface ProductManageInterface {
    public void add();
    public void sale();
}

@Service
public class ProductManage implements ProductManageInterface {
    @Override
    public void add() {
        System.out.println("添加商品");
    }

    @Override
    public void sale() {
        System.out.println("卖出商品");
    }
}
@Aspect
@Component
public class LoginAspectByTarget {
    @Pointcut("target(aop_manage.login.ProductManageInterface)")
    public void verifyLoginByTarget(){}

    @Before("verifyLoginByTarget()")
    public void beforeVerifyLoginByTarget(){
        System.out.println("Target...");
    }
}

这次我们的切面中切点是一个接口，那么预想一下该接口中所有的方法都会被代理。

同理，交换一下位置的话他们的作用也是一样的。

四、@annotation匹配连接点

这个匹配方式是检查所有带有你规定注解的方法作为连接点。

定义一个注解类，比如我们要实现校验登陆状态的逻辑，那么我们可以定义一个注解，把它加载我们希望校验登陆状态的方法上。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface VerifyLogin {
}

继续改造我们的Controller，增加@VerifyLogin 注解

    /**
     * 访问主页
     */
    @VerifyLogin
    @RequestMapping("/doMainIndex")
    public String doMainIndex() throws Exception {
        productManage.add();
        productManage.sale();
        return "main";
    }

编写我们的切面 

    @Pointcut("@annotation(aop_manage.aop_annotation.VerifyLogin)")
    public void verifyLoginByAnnotation(){
        System.out.println("登陆校验切点");
    }
    /**
     * 你想要在什么时候植入 5种
     */
    @Before("verifyLoginByAnnotation()")
    public void beforeCheck(){
        System.out.println("使用注解方式校验方法执行校验登陆状态。。。");
    }

五、arg匹配连接点

arg就是参数匹配，当参数符合指定类型时去代理执行方法。继续改造我们的Controller，增加两个不同参数的方法，我们只对这个Controller的String类型的参数做匹配

    /**
     * 访问主页
     */
    @RequestMapping("/doMainIndex")
    public String doMainIndex(String id) throws Exception {
        System.out.println("执行访问主页方法"+id);
        return "main";
    }
    /**
     * 退出主页
     */
    @RequestMapping("/doQuit")
    public String doQuit(int id) throws Exception {
        System.out.println("执行退出主页方法"+id);
        return "main";
    }

编写切面类

@Aspect
@Component
public class LoginAspectByArg {
    @Pointcut("args(String) && within(aop_manage.login.LoginController)")
    public void verifyArgByArg(){}

    @Before("verifyArgByArg()")
    public void beforeVerifyArgByArg(){
        System.out.println("发现参数为String的类型。。。。");
    }
}

可以看到 args(String) && within(aop_manage.login.LoginController) 表示对第一个参数为String并且文件时LoginController的方法做织入。如果匹配多个参数可以用args（String,Long,Double）

所以当我分别在浏览器输入不同参数时，可以看到只有String参数的方法被增强。

六、execution匹配连接点

重点放在最后，execute作为使用最多的表达式，它的操作还是很灵活的。它的规则如下

execution(<可见性修饰符> <返回值类型> <方法全限定名>(<参数>) <异常>)  

其中可见性修饰符和异常不是必须的，其余是必须的。

先上一个例子@Pointcut("execution( * aop_manage.login.LoginController.doMainIndex(String))")

第一个*表示任意的返回值类型，然后我们定义了全限定类名和方法名，之后的String表示String参数，如果是(..)则表示任意参数

@Aspect
@Component
public class LoginAspectByExecution {
    @Pointcut("execution( public * aop_manage.login.LoginController.doMainIndex(Integer))")
    public void verifyLoginByExecution(){}

    @Before("verifyLoginByExecution()")
    public void beforeVerifyLoginByExecution(){
        System.out.println("LoginAspectByExecution...");
    }
}

 

LJHSkyWalker
关注
专栏目录
springboot切片测试_Springboot 中使用单元测试
weixin_28916817的博客
12-31 950
一、测试 TestingSpringboot测试支持由两个模块提供;spring-boot-test 包含核心项目，而spring-boot-test-autoconfigure支持测试的自动配置。大多数开发人员只使用spring-boot-starter-test就可以。它可以导入Spring Boot测试模块以及JUnit，AssertJ，Hamcrest和其他一些有用的库。二、测试范围依...
【SpringBoot】切面AOP概念及简单实例
龙套的博客
06-26 586
文章目录理解AOP1、什么是AOP2、 AOP的体系和概念概念简解AOP实例相关注解1、@Pointcut2、@Around3、@Before4、@After5、@AfterReturning6、@AfterThrowing 理解AOP 1、什么是AOP AOP（Aspect Oriented Programming），面向切面思想，是Spring的三大核心思想之一（另外两个：IOC-控制反转、DI-依赖注入）。 那么AOP为何那么重要呢？在我们的程序中，经常存在一些系统性的需求，比如权限校验、日志记录、统
.Net中的AOP系列之《单元测试切面》
weixin_33882443的博客
10-23 228
返回《.Net中的AOP》系列学习总目录 本篇目录 使用NUnit编写测试 编写和运行NUnit测试 切面的测试策略 Castle DynamicProxy测试 测试一个拦截器 注入依赖 PostSharp测试 对PostSharp切面进行单元测试 注入依赖 PostSharp和测试的问题 小结 本节的源码本人已托管于Coding上：点击查看。 本系列的实验环境：VS ...
Spring注解AOP及单元测试junit(6)
dcj8867的博客
03-10 545
2019-03-10/20:19:56 演示:将xml配置方式改为注解方式 静态以及动态代理推荐博客:https://blog.csdn.net/javazejian/article/details/56267036 junit单元测试jar包:https://share.weiyun.com/5pKuXVL 1.注解配置业务类 　　使用@Component("s") ...
【Spring Boot AOP介绍】
最新发布
武帝为此的博客
07-05 1319
Spring AOP 是 Spring 框架的一部分，提供了简单易用的 AOP 功能。Spring AOP 使用动态代理实现运行时织入，并支持基于注解和基于 XML 的配置方式。Spring AOP 主要用于处理方法级别的横切关注点，适用于大多数企业应用场景。切点定义了切面织入的具体位置，可以通过@Pointcut注解来定义。Pointcut;@Pointcut注解定义了一个名为的切点，该切点匹配包中的所有方法执行。
springboot AOP 切面编程测试
yuexinning_xu的专栏
08-29 202
Pointcut 切点 Before 进入切点方法前执行 afterThrowing 方法返回之后执行 AfterReturning 方法抛出异常时执行 package com.modules.aop; import java.lang.ann...
spring aop 切面测试
weixin_30439131的博客
01-21 329
spring 配置 aop <aop:config> <aop:aspect id="asp1" ref="monitorApi"> <!-- 配置一个切入点,相当于@Pointcut --> <aop:pointcut expression="e...
Spring boot中使用aop详解
热门推荐
tianyaleixiaowu的专栏
04-27 2万+
aop是spring的两大功能模块之一，功能非常强大，为解耦提供了非常优秀的解决方案。 现在就以springboot中aop的使用来了解一下aop。 一：使用aop来完成全局请求日志处理 创建一个springboot的web项目，勾选aop，pom如下： <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="htt
8.Spring AOP切面配置 && 单元测试
扛麻袋的少年的博客
07-08 5265
1.xml配置切面 ①定义一个Service方法 /** * 用户Service */ @Service public class UserService { private final static Logger LOG = Logger.getLogger(UserService.class); public void add(User user){ ...
springboot-mybatis整合多数据源方式之一AOP法
04-03
springboot-mybatis整合多数据源方式之一aop法，动态切换数据源，在sprintboot 1.5.9下测试通过
springboot aop 一个切面多个切点，对不同的切点做不同的逻辑处理并指定逻辑处理的优先级，通过@AfterThrowing来捕捉异常，以及代码执行过程说明
还在活水泥的未来包工头
03-24 2050
在每个Around Advice中，我们都可以实现不同的处理逻辑，并且通过try-catch语句捕捉异常，以确保程序的正确性和稳定性。最后，通过@AfterThrowing注解，我们可以捕捉异常，并实现异常处理逻辑。如果任何一个方法抛出异常，都会被@AfterThrowing Advice捕捉到，并执行其中的异常处理逻辑。如果目标方法抛出异常，会被try-catch语句捕捉，并执行其中的异常处理逻辑。如果目标方法抛出异常，会被try-catch语句捕捉，并执行其中的异常处理逻辑。
SpringBoot整合aop面向切面编程过程解析
08-24
SpringBoot整合AOP面向切面编程过程解析 AOP（Aspect Oriented Programming），即面向切面编程，是一种编程技术，通过预编译方式和运行期动态代理实现程序功能的统一维护。AOP是Spring框架中的一个重要内容，它通过...
springboot-AOP实现多数据源动态切换（Druid连接池）
12-25
- **AOP切面配置**：实现一个AOP切面，用来在方法执行前切换数据源。这个切面可以利用ThreadLocal变量来存储当前线程所使用的数据源标识，确保在同一个线程内，对数据库的操作使用相同的连接。具体实现中，需要定义...
springboot配置aop切面日志打印过程解析
08-25
Spring Boot 配置 AOP 切面日志打印过程解析 本文主要介绍了 Spring Boot 配置 AOP 切面日志打印过程解析，通过示例代码详细讲解了 AOP 的概念、相关概念、AOP 代理、织入等知识点，并提供了实际的代码示例。 一、...
SpringBoot-AOP面向切面编程-实战
ZhAoYaJ的博客
01-05 2279
SpringBoot集成AOP之列文虎克
SpringBoot实现AOP详解
m0_67401660的博客
08-02 821
先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。//该注解只能用在类上，作用代表当前类是一个切面类，等价于spring.xml中的。//表示当前的类是一个配置类。...
springmvc中aop对controller切面编程
pbsqllihao的博客
11-24 750
springmvc中aop对controller切面编程
SpingBoot整合AOP教程详解
猿小许的博客
02-25 535
说起spring，我们知道其最核心的两个功能就是AOP（面向切面）和IOC（控制反转），这边文章来总结一下SpringBoot如何整合使用AOP。
【SpringBoot】【1】解决不同包结构下，同样的类名冲突的问题
aizhu4795的博客
05-30 2356
前言： 问题来源：参考博客的博主的情况是合并项目导致的冲突，我是不同的人写代码，命名重复了，改名又不好改（采取的改名方案是一方的代码加个前缀单词，看着挺累赘的） 报错原因：spring提供两种beanName生成策略，基于注解的sprong-boot默认使用的是AnnotationBeanNameGenerator，它生成beanName的策略就是，取当前类名（不是全限定类名）作为b...
springboot aop切类
09-16
在Spring Boot中，可以通过引入spring-boot-starter-aop依赖来实现AOP切面。AOP的切点是指被拦截到的点，在Spring中，这些点指的是方法，因为Spring只支持方法类型的连接点（被代理对象的所有方法）。所以你可以在Spring Boot项目中添加以下依赖来使用AOP功能： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 这样，你就可以在你的代码中定义切面类，并使用注解来指定切点和切面逻辑。这样，当程序执行到指定的切点时，切面逻辑就会被执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值