spring学习日记-day6-AOP

于 2024-09-02 20:51:43 发布
阅读量818 收藏 3
点赞数 24
分类专栏： spring学习日记 文章标签： spring 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79789506/article/details/141336090
版权

一、学习目标

        面向切面的编程（AOP）通过提供另一种思考程序结构的方式来补充面向对象的编程（OOP）。OOP中模块化的关键单位是类，而AOP中模块化的单位是切面。切面使跨越多种类型和对象的关注点（如事务管理）模块化。

        spring的关键组件之一是AOP框架。虽然Spring IoC容器并不依赖于AOP（意味着如果你不想使用AOP，就不需要使用），但AOP补充了Spring IoC，提供了一个非常有能力的中间件解决方案。  

        AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它旨在提高模块化程度。在AOP中，程序被划分为不同的关注点（或称为切面），这些关注点可以独立地开发、修改和重用。AOP主要用于处理横切关注点（cross-cutting concerns），这些关注点通常跨越多个类或方法，如日志记录、事务管理、安全控制、性能监控等。

二、AOP

        AOP的核心概念

  1. 切面（Aspect）：切面是跨多个类和方法的横切关注点的模块化，如事务管理。切面可以定义切入点、通知（增强）等。

  2. 连接点（Joinpoint）：连接点是程序执行中的一个点，如方法的执行或异常的处理。在Spring AOP中，连接点通常是方法的执行点。

  3. 切入点（Pointcut）：切入点是一组连接点的集合，这些连接点通常与特定的类或方法相关。切入点定义了哪些连接点将被增强（即应用通知）。

  4. 通知（Advice）：通知是切面在特定连接点执行的动作。通知有多种类型，包括前置通知（在方法执行前执行）、后置通知（在方法执行后执行）、环绕通知（在方法执行前后执行，并可以决定方法是否继续执行）、异常通知（在方法抛出异常时执行）和最终通知（无论方法是否成功执行，都会执行）。

  5. 目标对象（Target）：目标对象是被一个或多个切面增强的对象。

  6. 代理（Proxy）：代理是由AOP框架创建的对象，用于实现切面功能的织入。代理对象在目标对象的基础上增加了额外的功能。

  7. 织入（Weaving）：织入是将切面应用到目标对象并创建代理对象的过程。织入可以在编译时、类加载时或运行时进行。

三、三种实现方式

1.搭建测试环境

项目结构：

导入依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.2</version>
        </dependency>
        <dependency>
            <groupId>jakarta.annotation</groupId>
            <artifactId>jakarta.annotation-api</artifactId>
            <version>2.1.1</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

接口类

public interface  blogService {
    public void addBlog();
    public void deletBlog();
    public void  updateBlog();
    public void  query();
}

接口实现类

public class blogServiceImpl implements blogService{
    public void addBlog() {
        System.out.println("增加了一篇博客");
    }

    public void deletBlog() {

    }

    public void updateBlog() {

    }

    public void query() {

    }
}

xml文件中注册bean

<?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">
    <!--注册bean-->
    <bean id="blog" class="com.lzh.service.blogServiceImpl"></bean>
    
</beans>

测试

public class myTest {
    @Test
    public void  test01(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        blogService blog = (blogService) context.getBean("blog");
        blog.addBlog();
    }
}

2.springAPI实现

        通过Spring的AOP功能，实现了在不修改blogServiceImpl类代码的情况下，为其所有方法执行前后添加额外的逻辑。这是通过定义切入点来指定哪些方法会被拦截，并通过定义顾问来指定在这些方法执行前后执行哪些逻辑（即Before和After类中的方法）来实现的。

/**  
 * 实现了Spring AOP的AfterReturningAdvice接口的类，用于在目标方法正常执行完成后执行一些逻辑。  
 * 这个类将作为AOP通知（Advice）使用，在Spring配置中需要被注册为一个Bean，并与切点（Pointcut）关联。  
 */  
public class After implements AfterReturningAdvice {  
  
    /**  
     * 当目标方法正常执行完成后，此方法将被调用。  
     *   
     * @param returnValue 目标方法的返回值。如果目标方法没有返回值（即void类型），则此参数为null。  
     * @param method 被调用的目标方法对象，包含了方法的所有信息（如名称、参数类型等）。  
     * @param args 传递给目标方法的参数数组。如果目标方法没有参数，则此数组为空。  
     * @param target 目标对象实例，即被代理的对象。  
     * @throws Throwable 如果在通知执行过程中发生异常，则此异常将被抛出。  
     *                   注意：如果此通知中抛出了异常，它可能会阻止后续通知（如果有的话）的执行，  
     *                   并且可能会影响到目标方法的返回值（如果目标方法返回void，则不会有影响）。  
     */  
    @Override  
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {  
        // 输出目标方法执行后的相关信息  
        System.out.println("执行了" + target.getClass().getName() // 目标对象的类名  
                + "的" + method.getName() + "方法," // 目标方法的名称  
                + "返回值：" + returnValue); // 目标方法的返回值  
    }  
}

/**  
 * Before类实现了Spring AOP的MethodBeforeAdvice接口，  
 * 用于在目标方法执行之前执行一些前置逻辑。  
 *   
 * 这个类可以被Spring容器管理，并通过AOP配置应用到指定的目标方法上，  
 * 以实现无侵入式的日志记录、安全检查、性能监控等功能。  
 */  
public class Before implements MethodBeforeAdvice {  
  
    /**  
     * before方法会在目标方法执行之前被调用。  
     *   
     * @param method  被调用的目标方法的Method对象，包含方法名、参数类型等信息。  
     * @param args    目标方法执行时传入的参数数组，如果方法没有参数，则为空数组。  
     * @param target  目标对象，即被代理的对象，实际执行方法的那个对象。  
     * @throws Throwable 如果前置逻辑执行中抛出异常，则此异常会被传递给调用者，  
     *                   可能导致目标方法不会被执行。  
     *   
     * 此方法的主要用途是执行一些前置逻辑，如日志记录、权限检查等，  
     * 而不改变目标方法的参数或返回值。  
     */  
    @Override  
    public void before(Method method, Object[] args, Object target) throws Throwable {  
        // 输出目标对象的类名、被调用的方法名以及一个简单的执行通知  
        System.out.println(target.getClass().getName() + "的" + method.getName() + "方法被执行了");  
    }  
}

    <!--注册bean-->
    <bean id="blog" class="com.lzh.service.blogServiceImpl"></bean>
    <bean id="before" class="com.lzh.service.Before"></bean>
    <bean id="after" class="com.lzh.service.After"></bean>
    <!--aop的配置-->
    <!--切入点  expression:表达式匹配要执行的方法-->
     <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.lzh.service.blogServiceImpl.*(..))"/>
        <aop:advisor advice-ref="before" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="after" pointcut-ref="pointcut"/>
    </aop:config>

3.自定义类实现

public class MyPointcut {
    public void before(){
        System.out.println("--before--");
    }
    public void after(){
        System.out.println("--after--");
    }
}

修改xml文件：

    <!--注册bean-->
    <bean id="blog" class="com.lzh.service.blogServiceImpl"></bean>
    <bean id="before" class="com.lzh.service.Before"></bean>
    <bean id="after" class="com.lzh.service.After"></bean>
    <bean id="second" class="com.lzh.config.MyPointcut"></bean>
    <!--aop的配置-->
    <!--aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.lzh.service.blogServiceImpl.*(..))"/>
        <aop:advisor advice-ref="before" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="after" pointcut-ref="pointcut"/>
    </aop:config-->
    <!--aop的配置-->
    <aop:config>
        <aop:aspect ref="second">
            <aop:pointcut id="myPonitcut" expression="execution(* com.lzh.service.blogServiceImpl.*(..))"/>
            <aop:before pointcut-ref="myPonitcut" method="before"/>
            <aop:after pointcut-ref="myPonitcut" method="after"/>
        </aop:aspect>
    </aop:config>

测试结果:

4.注解实现

// 使用@Aspect注解定义一个切面类，用于在指定的方法执行前后或周围进行增强处理  
@Aspect  
public class AnnotationPointcut {  
  
    // 使用@Before注解定义一个前置增强，该增强会在指定方法执行前执行  
    // "execution(* com.lzh.service.blogServiceImpl.*(..))"是切点表达式，表示匹配com.lzh.service.blogServiceImpl包下所有类的所有方法  
    @Before("execution(* com.lzh.service.blogServiceImpl.*(..))")  
    public void before(){  
        System.out.println("---before---"); // 在匹配的方法执行前打印信息  
    }  
  
    // 使用@After注解定义一个后置增强，该增强会在指定方法执行后执行（无论方法是否抛出异常）  
    @After("execution(* com.lzh.service.blogServiceImpl.*(..))")  
    public void after(){  
        System.out.println("---after---"); // 在匹配的方法执行后打印信息  
    }  
  
    // 使用@Around注解定义一个环绕增强，该增强可以在方法执行前后进行自定义处理  
    // 环绕增强需要接收一个ProceedingJoinPoint类型的参数，用于控制目标方法的执行  
    @Around("execution(* com.lzh.service.blogServiceImpl.*(..))")  
    public Object around(ProceedingJoinPoint jp) throws Throwable {  
        System.out.println("环绕前"); // 在目标方法执行前打印信息  
        System.out.println("签名:"+jp.getSignature()); // 打印目标方法的签名信息  
  
        // 通过jp.proceed()执行目标方法，并获取其返回值  
        // 注意：如果目标方法抛出异常，这里也会抛出相同的异常  
        Object proceed = jp.proceed();  
  
        System.out.println("环绕后"); // 在目标方法执行后打印信息  
        System.out.println(proceed); // 打印目标方法的返回值  
  
        // 返回目标方法的执行结果  
        return proceed;  
    }  
}

    <!--注册bean-->
    <bean id="blog" class="com.lzh.service.blogServiceImpl"></bean>
    <bean id="before" class="com.lzh.service.Before"></bean>
    <bean id="after" class="com.lzh.service.After"></bean>
    <bean id="second" class="com.lzh.config.MyPointcut"></bean>
    <!--aop的配置-->
    <!--aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.lzh.service.blogServiceImpl.*(..))"/>
        <aop:advisor advice-ref="before" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="after" pointcut-ref="pointcut"/>
    </aop:config-->
    <!--aop的配置-->
    <!--aop:config>
        <aop:aspect ref="second">
            <aop:pointcut id="myPonitcut" expression="execution(* com.lzh.service.blogServiceImpl.*(..))"/>
            <aop:before pointcut-ref="myPonitcut" method="before"/>
            <aop:after pointcut-ref="myPonitcut" method="after"/>
        </aop:aspect>
    </aop:config-->
    <bean id="annotationPointcut" class="com.lzh.config.AnnotationPointcut"/>
    <aop:aspectj-autoproxy/>

长风青萍
关注
  • 24
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring学习日记-day5-代理模式
2301_79789506的博客
09-01 770
/实现旅游功能//spot为旅游目的地，实现旅游功能System.out.println("接待游客");//实现旅游功能。
Spring学习日记：Aop五种增强+注解开发Ioc/Aop
m0_74777020的博客
08-22 2523
自述：此篇文章主要记录了本人学习Spring的日常，在CSDN上发表，一是为了方便今后回顾，二也是想分享给有需要的人。
学习spring-AOP
foldingairplane的博客
10-03 92
AOP作为Spring与IOC一样重要的核心点，学好AOP对系统的管理会有很大的好处，AOP(Aspect-Oriented Programming, 面向切面编程): 是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充。定义是这样的，但是确实还是不知道AOP到底是干什么又该怎么样，所以直接看代码来回答问题吧！ ...
spring学习笔记 -- day08 基于XML的Spring中的AOP
wingzhezhe的博客
08-16 209
一、搭建AOP环境 1、创建项目，导入jar包 2、导入spring核心配置文件约束 <!-- 导入约束： 导入beans和aop两个约束 --> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instan
实习日记--day3
qq_40115021的博客
06-27 432
完整增删改查程序demo和SSM框架基础完整增删改查程序demo工程目录实体类dao层工具类SSM框架基础 完整增删改查程序demo 把简单的事情做好，就是不简单。 增删改查应该算是数据库里最最基本的操作了，虽然简单，但是如果能熟练掌握这四个操作，绝对能应付很大一部分的工作需求。这里给出的一个demo基本没有什么实用性可言，但是其中代码的编排还是值得借鉴学习的，废话不多说，直接整活。 工程目录 完...
2022-9-21 第七小组 学习日记 (day76)Spring框架
weixin_56982770的博客
09-23 168
DI：称作依赖注入，和控制反转一个概念，具体的讲，当一个角色需要另外一个角色协助的时候，在传统的程序设计中，通常有调用者来创建被调用者的实例。AOP：Spring对面向切面编程提供了强有力的支持，通过它让我们将业务逻辑从应用服务（如事务管理）中分离出来，实现了高内聚开发(所谓高内聚是指一个软件模块是由相关性很强的代码组成，只负责一项任务，也就是常说的单一责任原则。Spring是一个全新的框架，需要导入许多资源包，看起来繁琐，实际上有迹可循，Springle现在市面上应用广泛，学会了今后将有广大的前景。
【javaweb】学习日记Day13 - AOP 事务管理 切入点 连接点
weixin_61639349的博客
10-29 450
AOP spring事务管理 切入点 等
Spring--08基于注解的AOP配置
Ur_Eyes_的博客
08-09 114
项目需求 通过日志记录每次accountService业务的执行状况 为切入点配置前置通知，异常通知，后置通知，最终通知，环绕通知 项目说明 项目使用基于注解的方式配置aop 项目不涉及数据库操作，不涉及事务控制，只是简单的关于aop的使用 不涉及真正的日志管理，只是简单模拟日记记录的运行方式 项目简单演示了前置通知，异常通知，后置通知，最终通知和环绕通知 基于注解配置aop会出现几个通知顺序出现异常，环绕通知没有这个问题 编写pom文件 使用aop时需要导入AspectJ坐标 <?x
实习日记08/11day25 理解JavaWeb-理解Spring
qq_43285863的博客
08-17 210
总览
Java的新项目学成在线笔记-day1(一）
czbkzmj的博客
12-17 2036
受互联网+概念的催化，当今中国在线教育市场的发展可谓是百花齐放、如火如荼。 按照市场领域细分为：学前教 育、K12教育、高等教育、留学教育、职业教育、语言教育、兴趣教育以及综合平台，其中，职业教育和语言教育 的市场优势突出。 根据Analysys易观发布的数据显示，预计2019年中国互联网教育市场交易规模将达到3718亿元 人民币，未来三年互联网教育市场规模保持高速增长。  学成在线借鉴了MOOC...
实训日记（四）——ssm框架搭建
qq_40689705的博客
06-28 1018
实习第四天 上午老师简单复习了一下ssm框架，然后开始带我们一步一步实践。老师带我们学完了查询，后面的增删改需要我们自己编写。下午我们就在这自己编写增删改。 目录 ssm框架 增删查改实践 一、ssm框架 SSM（Spring+SpringMVC+MyBatis）框架集由Spring、MyBatis两个开源框架整合而成（SpringMVC是Spring中的部分内容）。常作为数据源较简单的web...
系统用户行为日志记录
jceator123的博客
03-31 8566
http://hi.baidu.com/xbnh0217/item/fd78f92a010dedc1ef10f1a7 man1900.iteye.com/blog/648107 blog.csdn.net/kimylrong/article/details/7639346 http://blog.csdn.net/javazhichizhe/article/details/6468687...
[转]高负载并发网站架构分析
热门推荐
bluehire的专栏
12-23 2万+
由于自己正在做一个高性能大用户量的论坛程序，对高性能高并发服务器架构比较感兴趣，于是在网上收集了不少这方面的资料和大家分享。希望能和大家交流 msn: defender_ios@hotmail.com ——————————————————————————————————————— ? 初创网站与开源软件 6 ? 谈谈大型高负载网站服务器的优化心得! 8 ? Lighttpd+Squid+Apach
springboot + mybatis批量更新
weixin_43833540的博客
08-27 654
【代码】springboot + mybatis批量更新。
redis能正常访问，但是springboot编译报错
生而为人我很抱歉
08-27 729
因为你在自定义的 @Configuration 类中没有明确指定配置属性的绑定，或者这个类的加载顺序影响了 Spring Boot 的属性绑定过程。你可以尝试在 MyConf 类上加上 @Order 注解来调整加载顺序，或者确保 MyConf 类不会干扰到 Redis 配置的加载。你可以在 MyConf 类上使用 @ConditionalOnProperty 注解，确保在特定条件下才加载这个配置类，以避免在 Redis 配置加载之前进行不必要的初始化。
高级java每日一道面试题-2024年8月28日-框架篇[Spring篇]-Spring 框架是什么?
最新发布
qq_43071699的博客
08-28 787
1. 定义与起源Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。它由Rod Johnson最早提出，目的是解决企业级应用开发的复杂性，简化Java开发。2. 核心特性控制反转（IoC）：也称为依赖注入（DI），是Spring框架的核心。它将对象的创建和依赖关系的管理交给了容器，降低了代码间的耦合度。面向切面编程（AOP）：Spring提供了丰富的AOP支持，允许开发者将横切关注点（如日志、事务管理等）从业务逻辑中分离出来，形成可重用的功能组件。
【精品】计算机毕业设计之：springboot游戏分享网站（源码+文档+辅导）
程序员阿龙的博客
08-27 2063
博主介绍： ✌我是阿龙，一名专注于Java技术领域的程序员，全网拥有10W+粉丝。作为CSDN特邀作者、博客专家、新星计划导师，我在计算机毕业设计开发方面积累了丰富的经验。同时，我也是掘金、华为云、阿里云、InfoQ等平台的优质作者。通过长期分享和实战指导，我致力于帮助更多学生完成毕业项目和技术提升。 技术范围： 我熟悉的技术领域涵盖SpringBoot、Vue、SSM、HLMT、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、小程序、安卓app、大数据、物联网、机器学习等方
SpringBoot项目集成数据脱敏（密码加密）功能
pengpm的博客
08-27 1230
敏感数据加解密前端传输敏感数据加解密数据库获取的敏感数据加解密。
spring-aop-4.3.4jar包
11-19
spring-aop-4.3.4.jar是Spring框架中的一个核心jar包，用于实现面向切面编程（AOP）。AOP是一种程序设计思想，通过在程序运行期间动态地将代码织入到现有的类和方法中，来实现一些跨越多个组件的功能，如日志记录、事务管理、安全检查等。spring-aop-4.3.4.jar包提供了一个简单而强大的AOP框架，使开发者可以更方便地实现面向切面编程。 在使用spring-aop-4.3.4.jar包时，我们可以使用注解或XML配置来定义切面（Aspect）和通知（Advice），并将它们织入到目标对象中。切面定义了在何处、何时将通知应用到目标对象的条件，而通知定义了需要执行的逻辑。通过这种机制，我们可以在不修改原有业务逻辑代码的情况下，实现诸如性能监控、异常处理、安全检查等功能。 spring-aop-4.3.4.jar包还提供了对AOP代理的支持，包括基于JDK动态代理和基于CGLIB的代理模式。这使得我们不仅可以代理接口类型的目标对象，还能代理普通的类。此外，spring-aop-4.3.4.jar还支持多种通知类型，包括前置通知、后置通知、环绕通知和异常通知，以满足不同的切面需求。 总的来说，spring-aop-4.3.4.jar是Spring框架中非常重要的一个jar包，它为开发者提供了强大的AOP功能，帮助我们更好地实现面向切面编程，提高了代码的可维护性和扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值