1.5 初探Spring AOP

已于 2023-05-31 10:40:24 修改
阅读量520 收藏 1
点赞数
文章标签： spring java spring boot
于 2023-05-31 09:24:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62492032/article/details/130847266
版权
该文详细介绍了如何使用Spring的AOP功能来实现游吟诗人在骑士执行任务前后唱赞歌的场景。首先展示了通过传统配置方式设置切点和通知，然后转向注解方式实现相同功能，包括自定义注解和切面。最后，文章演示了如何测试这些实现，确保游吟诗人的赞歌在正确的时间响起。
摘要由CSDN通过智能技术生成

一、提出游吟诗人唱赞歌任务

骑士执行任务前和执行任务后，游吟诗人唱赞歌

1、采用传统方式实现

修改day04子包的勇敢骑士类
在这里插入图片描述
修改day04子包里的救美骑士类
在这里插入图片描述
执行测试类 - TestKnight
在这里插入图片描述

二、采用配置方式使用AOP

1、创建本讲所需子包

在net.hf.spring包里创建day05.aop_xml子包
在这里插入图片描述

2、创建杀龙任务类

在aop_xml子包里创建杀龙任务类 - SlayDragonQuest
在这里插入图片描述

package net.hf.spring.day05.aop_xml;

import org.springframework.stereotype.Component;

/**
 * 功能：杀龙任务类
 * 作者：hf
 * 日期：2023年02月22日
 */
@Component
public class SlayDragonQuest {
    public void embark() {
        System.out.println("执行杀龙任务……");
    }
}

3、创建勇敢骑士类

在aop_xml子包里创建勇敢骑士类 - BraveKnight
在这里插入图片描述

package net.hf.spring.day05.aop_xml;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * 功能：勇敢骑士类
 * 作者：hf
 * 日期：2023年02月22日
 */
@Component("RobinHood")
public class BraveKnight {
    @Value("罗宾汉")
    private String name;
    @Autowired
    private SlayDragonQuest slayDragonQuest;

    public void embarkOnQuest() {
        System.out.print("勇敢骑士[" + name + "]");
        slayDragonQuest.embark();
    }
}

4、创建游吟诗人类

在aop_xml子包里创建游吟诗人类 - Minstrel
在这里插入图片描述

package net.hf.spring.day05.aop_xml;

import org.springframework.stereotype.Component;

/**
 * 功能：游吟诗人类
 * 作者：hf
 * 日期：2023年02月22日
 */
@Component
public class Minstrel {
    /**
     * 骑士出发前唱赞歌
     */
    public void singBeforeQuest() {
        System.out.println("啦啦啦，骑士出发了~");
    }

    /**
     * 骑士凯旋时唱赞歌
     */
    public void singAfterQuest() {
        System.out.println("真棒啊！骑士完成了任务~");
    }
}

5、创建Spring配置文件

在resources里创建aop_xml目录，在里面创建spring-config.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:context="http://www.springframework.org/schema/context"
       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/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--组件扫描-->
    <context:component-scan base-package="net.hf.spring.day05.aop_xml"/>

    <!--配置AOP-->
    <aop:config>
        <!--定义切面-->
        <aop:aspect ref="minstrel">
            <!--定义切点-->
            <aop:pointcut id="embark" expression="execution(* net.hf.spring.day05..*.embarkOnQuest(..))"/>
            <!--声明前置通知-->
            <aop:before method="singBeforeQuest" pointcut-ref="embark"/>
            <!--声明后置通知-->
            <aop:after method="singAfterQuest" pointcut-ref="embark"/>
        </aop:aspect>
    </aop:config>
</beans>

6、添加AOP相关依赖

在pom.xml文件里添加AOP相关依赖
在这里插入图片描述

<!--Spring AOP-->                                         
<dependency>                                              
    <groupId>org.springframework</groupId>                
    <artifactId>spring-aop</artifactId>                   
    <version>5.3.25</version>                  
</dependency>                                             
<!--AspectJ支持-->                                          
<dependency>                                              
    <groupId>aspectj</groupId>                            
    <artifactId>aspectjrt</artifactId>                    
    <version>1.5.4</version>                              
</dependency>                                             
<dependency>                                              
    <groupId>org.aspectj</groupId>                        
    <artifactId>aspectjweaver</artifactId>                
    <version>1.9.19</version>                              
    <scope>runtime</scope>                                
</dependency>

注意：添加新的依赖之后，记得更新
在这里插入图片描述

7、创建测试类 - TestKnight

在test/java里创建net.hf.spring.day05.aop_xml包，在包里创建TestKnight类
在这里插入图片描述

package net.hf.spring.day05.aop_xml;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 功能：测试骑士类
 * 作者：hf
 * 日期：2023年02月22日
 */
public class TestKnight {
    private ClassPathXmlApplicationContext context; // 基于类路径XML配置文件的应用容器

    @Before 
    public void init() {
        // 基于Spring配置文件创建应用容器
        context = new ClassPathXmlApplicationContext("aop_xml/spring-config.xml");        
    }
    
    @Test
    public void testBraveKnight() {
        // 根据名称从应用容器里获取勇敢骑士对象
        BraveKnight braveKnight = (BraveKnight) context.getBean("RobinHood");
        // 勇敢骑士执行任务
        braveKnight.embarkOnQuest();
    }

    @After 
    public void destroy() {
        // 关闭应用容器
        context.close();        
    }
}

运行testBraveKinght()方法，查看结果
在这里插入图片描述

三、采用注解方式使用AOP

1、创建子包

在net.hf.spring包里创建day05.aop_annotation子包
在这里插入图片描述

2、创建杀龙任务类

在aop_annotation子包里创建杀龙任务类 - SlayDragonQuest
在这里插入图片描述

package net.hf.spring.day05.aop_annotation;

import org.springframework.stereotype.Component;

/**
 * 功能：杀龙任务类
 * 作者：hf
 * 日期：2023年02月28日
 */
@Component
public class SlayDragonQuest {
    public void embark() {
        System.out.println("执行杀龙任务……");
    }
}

3、创建勇敢骑士类

在aop_annotation子包里创建勇敢骑士类 - BraveKnight
在这里插入图片描述

package net.hf.spring.day05.aop_annotation;

import net.hf.spring.day05.aop_xml.SlayDragonQuest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * 功能：勇敢骑士类
 * 作者：hf
 * 日期：2023年02月28日
 */
@Component("RobinHood")
public class BraveKnight {
    @Value("罗宾汉")
    private String name;
    @Autowired
    private SlayDragonQuest slayDragonQuest;

    /**
     * 勇敢骑士执行杀龙任务
     */
    @Action(name = "动作拦截器")
    public void embarkOnQuest() {
        System.out.print("勇敢的[" + name + "]");
        slayDragonQuest.embark();
    }
}

4、创建游吟诗人切面

在aop_annotation子包里创建游吟诗人切面 - MinstrelAspect
在这里插入图片描述

package net.hf.spring.day05.aop_annotation;

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

/**
 * 功能：游吟诗人切面类
 * 作者：hf
 * 日期：2023年02月28日
 */
@Aspect // 声明为切面类
@Component("minstrel") // 声明为Spring组件
public class MinstrelAspect {
    // 注解声明切入点
    @Pointcut("execution(* net.h分、
    .spring.day05..*.embarkOnQuest(..))")
    public void embark() {
    }

    // 注解声明前置通知
    @Before("embark()")
    public void singBeforeQuest(JoinPoint joinPoint) {
        System.out.println("啦啦啦，骑士出发了~");
    }

    // 注解声明后置通知
    @After("embark()")
    public void singAfterQuest(JoinPoint joinPoint) {
        System.out.println("真棒啊！骑士完成了任务~");
    }
}

切面类与切面配置文件的对应关系
在这里插入图片描述

5、创建Spring配置类

在aop_annotation子包里创建Spring配置类 - SpringConfig
在这里插入图片描述

package net.hf.spring.day05.aop_annotation;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * 功能：Spring配置类
 * 作者：hf
 * 日期：2023年02月28日
 */
@Configuration // 声明为Spring配置类
@ComponentScan("net.hf.spring.day05.aop_annotation") // 组件扫描
@EnableAspectJAutoProxy // 启用Spring对AspectJ的支持
public class SpringConfig {
}

6、创建骑士测试类

在test/java/的aop_annotation子包里创建测试类 - TestKnight
在这里插入图片描述

package net.hf.spring.day05.aop_annotation;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * 功能：测试骑士类
 * 作者：hf
 * 日期：2023年02月28日
 */
public class TestKnight {
    private AnnotationConfigApplicationContext context; // 基于注解配置类的应用容器

    @Before
    public void init() {
        // 基于注解配置类创建应用容器
        context = new AnnotationConfigApplicationContext(SpringConfig.class);
    }

    @Test
    public void testBraveKnight() {
        // 根据名称从应用容器里获取勇敢骑士对象
        BraveKnight knight = (BraveKnight) context.getBean("RobinHood");
        // 勇敢骑士执行任务
        knight.embarkOnQuest();
    }

    @After
    public void destroy() {
        // 关闭应用容器
        context.close();
    }
}

7、测试勇敢骑士，查看效果

运行测试方法 - testBraveKnight()
在这里插入图片描述

四、实现注解式拦截

1、创建注解接口

在aop_annotation子包里创建注解接口 - Action
在这里插入图片描述

package net.hf.spring.day05.aop_annotation;

import java.lang.annotation.*;

/**
 * 功能：动作注解接口
 * 作者：hf
 * 日期：2023年02月28日
 */
@Target(ElementType.METHOD) // 声明拦截目标 - 方法
@Retention(RetentionPolicy.RUNTIME) // 保留策略 - 运行时
@Documented // 注解文档化
public @interface Action {
    String name();
}
（1）@Target({ElementType.TYPE}) 注解

ElementType 这个枚举类型的常量提供了一个简单的分类：注解可能出现在Java程序中的语法位置（这些常量与元注解类型(@Target)一起指定在何处写入注解的合法位置）

（2）@Retention({RetentionPolicy.Runtime}) 注解

RetentionPolicy这个枚举类型的常量描述保留注解的各种策略，它们与元注解(@Retention)一起指定注释要保留多长时间

（3）@Documented注解

Documented注解表明这个注解是由 javadoc记录的，在默认情况下也有类似的记录工具。 如果一个类型声明被注解了文档化，它的注解成为公共API的一部分。

2、修改勇敢骑士类

勇敢骑士类
在这里插入图片描述

package net.hf.spring.day05.aop_annotation;

import net.hf.spring.day05.aop_xml.SlayDragonQuest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * 功能：勇敢骑士类
 * 作者：hf
 * 日期：2023年02月28日
 */
@Component("RobinHood")
public class BraveKnight {
    @Value("罗宾汉")
    private String name;
    @Autowired
    private SlayDragonQuest slayDragonQuest;

    /**
     * 勇敢骑士执行杀龙任务
     */
    @Action(name = "动作拦截器")
    public void embarkOnQuest() {
        System.out.print("勇敢的[" + name + "]");
        slayDragonQuest.embark();
    }
}

3、修改游吟诗人切面

游吟诗人切面类
在这里插入图片描述

package net.hf.spring.day05.aop_annotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 功能：游吟诗人切面类
 * 作者：hf
 * 日期：2023年02月28日
 */
@Aspect // 声明为切面类
@Component("minstrel") // 声明为Spring组件
public class MinstrelAspect {
    // 注解声明切入点
    @Pointcut("@annotation(net.hf.spring.day05.aop_annotation.Action)")
    public void embark(){
    }

    // 注解声明前置通知
    @Before("embark()")
    public void singBeforeQuest(JoinPoint joinPoint) {
        // 获取方法签名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        // 获取被拦截的方法
        Method method = signature.getMethod();
        // 获取注解式拦截
        Action action = method.getAnnotation(Action.class);
        // 提示用户被拦截了
        System.out.println("[" + action.name() + "]拦截了[" + method.getName() + "]: 拦截前~");

        System.out.println("啦啦啦，骑士出发了~");
    }

    // 注解声明后置通知
    @After("embark()")
    public void singAfterQuest(JoinPoint joinPoint) {
        // 获取方法签名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        // 获取被拦截的方法
        Method method = signature.getMethod();
        // 获取注解式拦截
        Action action = method.getAnnotation(Action.class);
        // 提示用户被拦截了
        System.out.println("[" + action.name() + "]拦截了[" + method.getName() + "]: 拦截后~");

        System.out.println("真棒啊！骑士完成了任务~");
    }
}

4、测试勇敢骑士

运行测试方法testBraveKnight()，查看效果
在这里插入图片描述

5、修改救美骑士类

救美骑士类 - RescueDamselKnight
在这里插入图片描述

package net.hf.spring.day05.aop_annotation;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * 功能：救美骑士类
 * 作者：hf
 * 日期：2023年02月28日
 */
@Component
public class RescueDamselKnight {
    @Value("格拉海德")
    private String name;
    @Autowired
    private RescueDanselQuest rescueDamselQuest;

    @Action(name = "狂飙拦截器")
    public void embarkOnQuest() {
        System.out.print("救美骑士[" + name + "]");
        rescueDamselQuest.embark();
    }
}

6、测试救美骑士

运行测试方法testRescueDamselKnight()，查看效果
在这里插入图片描述

没123456
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
企业级信息系统开发讲课笔记1.5 初探Spring AOP
howard2005的专栏
02-21 1032
1. 理解AOP与OOP的关系； 2. 掌握采用配置方式使用AOP； 3. 掌握采用注解方式使用AOP
初探spring aop内部实现 java
04-30
Spring AOP（面向切面编程）是Spring框架中的一个重要组件，它允许我们在不修改源代码的情况下，对程序的行为进行统一的管理和控制。本篇文章将深入探讨Spring AOP的内部实现，以及如何通过源代码理解其DataSource...
JAVA企业级开发 1.5 初探Spring AOP
zl202111的博客
05-31 276
Spring AOP
1.3 初探Spring AOP
howard2005的专栏
04-24 340
本次课，我们深入了解了Spring框架中的AOP（面向切面编程）概念，它是一种编程范式，用于处理那些在多个类中重复出现、与业务逻辑无关的横切关注点，如日志记录、事务管理等。AOP与OOP（面向对象编程）是互补的，OOP通过封装、继承和多态性来组织代码，而AOP则关注程序内部的横向关系。
初探Spring AOP
Coder的不平凡
04-21 1022
我们知道Spring有两个重要的特性：IOC和AOP ，大学期间只是对Spring有一个粗浅的认识，认为spring就是配置类，建立bean，然后就可以调用类的方法。直到慢慢了解才知道Spring还有很深的东西，Spring的强大。         这篇博文主要讲述Spring AOP 的 hijack（拦截） 功能，主要描述为当我们在执行一个类的方法的时候我们可以在方法执行前和执行后增加额外的
spring aop 初探
htydowd的博客
06-28 1080
JDK动态代理的 InvocationHandler 的实现类为 JdkDynamicAopProxy，其增强功能由 advised 完成。获取 注解的value值，通常返回的是 标记有 @Pointcut 注解的 方法名。针对每个bean，找到所有 没有标记 @Pointcut 注解的方法。对每个方法查找对应的切面，标记 标记 @Around等注解的方法。第一部分，直接查找所有的 Advisor类型的bean。根据切面的类型，返回不同的Advice类型的对象。第二个参数，调用的代理的接口中的方法。
spring源码学习，其十一：初探springAOP
heroboxbo的博客
04-15 92
一、切面aspect:将横切关注点逻辑进行模块化封装的实体对象 就类似与ServiceAspect类，注意切面是实体类对象 二、通知Advice:如果把aspect比作class的话，那么Advice好比class里面的方法，还定义了织入逻辑的时机。 三、连接点JoinPoint:允许Advice使用的地方,一个概念 springAOP默认只支持方法级别的JoinPoint 四、切入点PointCut:定义一系列规则对JoinPoint进行筛选 五、目标对象Target:符合PointC
【Spring杂烩】初探Spring的AOP方案 | Spring AOP
长路漫漫的歇脚处
01-16 709
探讨Spring中Aop的实现机制 Filter、Intercepter、Aop的介绍和区别 Jdk动态代理和Cglib动态代理的区别 Aop的前置知识
Spring初探之AOP简单理解
lks1139230294的博客
03-06 303
AOP简介 AOP意为面向切面编程，通过预编译方式和运行期间通过动态代理实现程序功能的统一维护的技术。利用AOP可以对业务逻辑的各个部分进行隔离，从而使业务逻辑各部分之间的耦合度降低，提高程序的可重用性。 AOP与代理模式 Spring中的AOP本质上也就是使用了动态代理模式，只不过在动态代理模式的实现上进行了封装，简化了动态代理模式的步骤。 动态代理模式的实现步骤： 1）声明接口：注册需要被监听...
SpringAOP-1.初探SpringAOP
gq0811的博客
06-16 128
想对spring的AOP原理做一些深入了解，就先做了一些aop配置，从应用层面对切面有所感知。 基本概念： 1.Joinpoint(连接点):连接点就是你要拦截的点，spring只支持方法类型的连接点。所以连接点实际中就是某一个业务类的方法。 2.Pointcut(切入点):切入点是一种“位置”定义，是对连接点的描述，把一或多个连接点定义为一个切入点。 3.Advice(通知)：切面中定...
spring 初探
03-18
标题中的“spring 初探”表明我们即将探讨的是Spring框架的基础知识。Spring是Java企业级应用开发中最常用的一个开源框架，由Rod Johnson发起，旨在简化应用程序的开发，提高组件之间的解耦。 首先，Spring框架的...
spring+mybatis初探
08-02
首先，Spring框架的核心特性包括依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）。依赖注入允许开发者通过配置文件或注解来管理对象间的依赖关系，从而降低了代码的耦合度...
spring-framework-0.9.1.zip
07-06
《Spring Framework 0.9.1：初探与解析》 Spring Framework，作为Java开发领域中的一个里程碑式框架，自其诞生以来就以其强大的企业级应用支持和灵活的编程模式深受开发者喜爱。本文将深入探讨Spring Framework ...
dubbo和springcloud有什么异同？
yszbrzdd的博客
08-15 485
Dubbo主要关注于高效的 RPC 调用和服务治理。提供了一个综合的微服务解决方案，涵盖了从服务注册到配置管理的广泛功能。它们可以根据具体需求和现有技术栈选择使用，也可以结合使用，例如在 Spring Cloud 环境中集成 Dubbo 作为 RPC 框架。
SpringBoot：将单体项目拆分成微服务项目
最新发布
安晴晚风的博客
08-15 611
SpringBoot：将单体项目拆分成微服务项目
SpringBoot的使用的注解以及监控监控和lombok使用
luosuss的博客
08-14 942
我们可以进入源码查看。
Java面试题-JavaEE&框架&中间件（一）
qq_51598807的博客
08-12 961
SELECT 列名 FROM 表1 JOIN 表2 ON 条件 WHERE 条件 GROUP BY 列名 HAVING 条件 ORDER BY 列名 LIMITSpring是一个开源的轻量级控制反转和面向切面编程的容器框架。轻量级是说它开发使用简单，功能强大。控制反转是指将对象的创建，初始化，销毁等工作，以及依赖关系维护交给ioc容器，方便解耦合，降低维护难度。面向切面编程是指将相同的逻辑横向抽取出来，可以对一些通用业务如事务，日志进行集中管理。1）IOC控制反转，把对象的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值