Spring AOP开发

最新推荐文章于 2025-03-31 23:50:48 发布
最新推荐文章于 2025-03-31 23:50:48 发布
阅读量333 收藏 2
点赞数 3
文章标签： spring java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51235449/article/details/130541415
版权
文章介绍了如何使用XML配置和注解方式在Spring框架中实现AOP编程，包括前置、后置、环绕和最终增强方法。在Cooker实体类中模拟了厨师烹饪过程，通过抛出数学异常模拟菜做糊的情况。在XML配置中详细设置了切入点和增强方法，而在注解方式中，利用@Aspect和@Pointcut等注解实现相同的功能。最后提供了测试代码来验证AOP的实现。
摘要由CSDN通过智能技术生成

题目要求：设计一个cooker实体类，其中属性name与rank，分别表示厨师的姓名与等级，使用注入赋值，自行设计cook()方法的内容，以cook()方法作为目标方法（即被增强方法）。

  1. 使用前置增强给出“烹饪前请准备食材。。。”的通知；
  2. 后置增强给出“烹饪后请盛入盘中。。。”的通知；
  3. 使用环绕增强实现上述两项功能；
  4. 在cook()方法中设计一种异常（数学异常）来模拟菜做糊了，并会发出“天哪，菜做糊了。。。”的通知；
  5. 使用最终增强来发出“刷洗锅具。。。”的通知。

控制台输出参考示例如图1：

 

1.使用xml配置方式进行AOP编程

1.导入AOP坐标

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <!--         aspectj的织入 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>

2.创建目标接口和目标类

//接口
public interface CookerImpl {
    void cook();
}

import DAO.CookerImpl;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

//目标类
public class Cooker  implements CookerImpl {
    private String name;
    private int rank;

    public Cooker() {
    }

    public Cooker(String name, int rank) {
        this.name = name;
        this.rank = rank;
    }
    @Override
    public void cook(){
        System.out.println("我是厨师"+this.name+"，"+this.rank+"级厨师，现在开始烹饪");
//        System.out.println(1/0);
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getRank() {
        return rank;
    }

    public void setRank(int rank) {
        this.rank = rank;
    }

    @Override
    public String toString() {
        return "Cooker{" +
                "name='" + name + '\'' +
                ", rank=" + rank +
                '}';
    }
}

3.创建切面类（增强方法）

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

//切面类
public class MyAspect {

    //前置增强方法
    public void before(){
        System.out.println("烹饪前准备食材。。。");
    }

    //后置增强方法
    public void afterReturn()  {
        System.out.println("烹饪后请盛入盘中。。。");
    }
    //环绕通知
    //需要一个切点对象(Proceeding:执行 JoinPoint：连接点)  正在执行的切点 = 切点
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("烹饪前准备食材。。。");
        Object proceed = pjp.proceed(); //执行切点方法(抛出异常)
        System.out.println("烹饪后请盛入盘中。。。");
        return proceed;
    }
    //最终增强方法
    public void after(){
        System.out.println("刷洗锅具。。。");
    }
    //异常
    public void afterThrowing(){
        try{
            System.out.println("天哪，菜做糊了。。。");
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

4.配置beans.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: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 id="cooker" class="pojo.Cooker">
                <constructor-arg name="name" value="铁根" />
                <constructor-arg name="rank" value="4"/>
        </bean>
        <bean id="myAspect" class="pojo.MyAspect"></bean>
        <aop:config>
                <!--引用myAspect的Bean为切面对象-->
<!--                <aop:aspect ref="myAspect">-->
<!--                        &lt;!&ndash;配置Cooker的cook方法执行时要进行myAspect的before方法前置增强&ndash;&gt;-->
<!--                        <aop:before method="before" pointcut="execution(public void pojo.Cooker.cook())"/>-->
<!--                </aop:aspect>-->
<!--                <aop:aspect ref="myAspect">-->
<!--                        &lt;!&ndash;配置Cooker的cook方法执行时要进行myAspect的afterReturn方法后置增强&ndash;&gt;-->
<!--                        <aop:after method="afterReturn" pointcut="execution(public void pojo.Cooker.cook())"/>-->
<!--                </aop:aspect>-->
                <aop:aspect ref="myAspect">
                        <!--配置Cooker的cook方法执行时要进行myAspect的after方法最终增强-->
                        <aop:after-returning method="after" pointcut="execution(public void pojo.Cooker.cook())"/>
                </aop:aspect>
                <aop:aspect ref="myAspect">
                        <!--配置Cooker的cook方法执行时要进行myAspect的afterThrowing方法异常增强-->
                        <aop:after-throwing method="afterThrowing" pointcut="execution(* pojo.Cooker.cook())"/>
                </aop:aspect>
                <aop:aspect ref="myAspect">
                        <!--配置Cooker的cook方法执行时要进行myAspect的around方法环绕增强-->
                        <aop:around method="around" pointcut="execution(public void pojo.Cooker.cook())"/>
                </aop:aspect>
        </aop:config>
</beans>

 5.测试

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@ContextConfiguration("classpath:beans.xml")
public class AOPTest {
    @Autowired
    CookerImpl cooker;

    @Test
    public void AopTest() {
        cooker.cook();
    }
}

学习链接

(5条消息) 16. 用XML 配置的方式 进行 AOP 切面编程_咸瑜的博客-CSDN博客 

 2.使用注解方式方式进行AOP编程

1.导包

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <!--         aspectj的织入 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.19</version>
        </dependency>

接口和实现类和上面的一样 

2.切面类

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

@Component
@Aspect
//切面类
public class MyAspect {
    @Pointcut("execution(* pojo.Cooker.cook())")
    public void pointcut(){}

    //前置增强方法
    @Before("pointcut()")
    public void before(){
        System.out.println("烹饪前准备食材。。。");
    }

    //后置增强方法
    @AfterReturning("pointcut()")
    public void afterReturn()  {
        System.out.println("烹饪后请盛入盘中。。。");
    }
    //环绕通知
    //需要一个切点对象(Proceeding:执行 JoinPoint：连接点)  正在执行的切点 = 切点
//    @Around("pointcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("烹饪前准备食材。。。");
        Object proceed = pjp.proceed(); //执行切点方法(抛出异常)
        System.out.println("烹饪后请盛入盘中。。。");
        return proceed;
    }
    //最终增强方法
    @After("pointcut()")
    public void after(){
        System.out.println("刷洗锅具。。。");
    }
    //异常
    @AfterThrowing("pointcut()")
    public void afterThrowing(){
        try{
            System.out.println("天哪，菜做糊了。。。");
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

 3.配置文件

<?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"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <bean id="cooker" class="pojo.Cooker">
        <constructor-arg name="name" value="铁根" />
        <constructor-arg name="rank" value="4"/>
    </bean>
    <!-- 开启注解扫描：指定扫描哪个包下的注解 -->
    <context:component-scan base-package="DAO,pojo"/>
    <!-- 开启 AOP 注解方式 -->
    <aop:aspectj-autoproxy />
</beans>

 我看了很多文章的内容，可能会出现以下错误,

Caused by: org.xml.sax.SAXParseException; lineNumber: 25; columnNumber: 9; cvc-complex-type.2.3: 元素 ‘beans’ 必须不含字符 [子级], 因为该类型的内容类型为“仅元素”。

 原因是你导入的包context和beans.xml文件中的引用不相同，只需要把以下内容删除，在自动扫描的那里自动加载就可以了，也有可能是其他原因，

 4.测试

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;


@RunWith(SpringRunner.class)
@ContextConfiguration("classpath:beans.xml")
public class AOPTest {
    @Autowired
    CookerImpl cooker;

    @Test
    public void AopTest() {
        cooker.cook();
    }
}

 学习链接放下：

(5条消息) Aop编程——注解方式_枫叶的博客-CSDN博客 

(5条消息) Spring 通过注解方式实现AOP切面编程_白天的猫头鹰的博客-CSDN博客 

三七²
关注
用注解的方式进行SpringAOP开发
03-27
本篇我们将深入探讨如何使用注解的方式来实现Spring AOP开发。 ### 一、注解基础 在Spring AOP中，主要使用以下几种注解： 1. `@Aspect`：定义一个切面类，切面是AOP的核心，包含通知（advisors）和切点...
Spring AOP开发所需相关jar包
11-23
com.springsource.net.sf.cglib-2.2.0.jar com.springsource.org.aopalliance-1.0.0.jar com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar spring-aspects-5.2.6.RELEASE.jar
实验八. Spring AOP开发
dsbss的博客
06-01 127
1. 掌握Spring AOP的基本原理与概念2. 掌握XML配置方式进行AOP编程的方法2. 掌握注解方式进行AOP编程的方法。
java设计模式--命令模式
wuyundong123的博客
09-11 143
基本概念 将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象； 命令模式也支持可撤销的操作，命令模式通过这种封装的方式实现将客户端和接收端解耦； 痛点：解决「请求者」与「执行者」之间的耦合 举个栗子 一个面馆子里来个一位客人，客人在菜单上写了「鱼香肉丝盖饭」并交给了服务员，服务员把菜单拿到后堂，交给了大厨！！！ 其中，订单就起解耦的作用！！！ 基本结构图： ...
Java设计模式实现烹饪助手程序
Well~
02-07 863
Java设计模式实现烹饪助手程序 一． 程序设计目标和使用说明 1、程序设计目标     该程序在eclipse4.6.3版本中完成，用的是jdk1.7。     该程序的设计目的是为了学习java设计模式，应用其中的几个模式编写一个程序，在编写程序的过程中亲身实践相应设计模式，学习体会。     该程序的设计目标是完成一个采购食材的基本流程。程序根据用户选择的菜单，给出需要
采用xml配置方式进行配置AOP编程
weidianlun的博客
03-25 1228
1.//验证切面优先级，数越小优先级越高 @Order(2) 2. /*定义一个方法， 声明切入点表达式，一般地。该方法中再不需要添加其他代码,这就 * 相当于一个常量其他切点需要的时候。我们只需要在切点生命出引用该方法即可. * 在其他切点类中我们也可以应用这个方法。引用格式就是在需要的切入点加上:类名+此方法名 * 如果两个类不在同一个包下。我们还需要加入此类的全类名 * eg：
Spring AOP 详解
2301_80035594的博客
10-19 5852
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
Spring AOP
2301_76161469的博客
11-04 4699
AOP（Aspect-Oriented Programming，面向切面编程）：是一种软件开发的编程范式，旨在将横切关注点（cross-cutting concerns）与核心业务逻辑分离，以提高代码的模块化性、可维护性和复用性
Spring之AOP注解开发
楠黎倾风的博客
11-25 1万+
Spring之AOP注解开发
Spring AOP的注解式开发实现
dawn191228的博客
09-07 1600
import comSystem . out . println("业务层：Hello World！");} }System . out . println("业务层：Hello World！");} }import orgSystem . out . println("业务层：Hello World！");} }System . out . println("业务层：Hello World！");} }Service;@Service。
自定义注解 + Spring AOP
weixin_50871837的博客
07-16 1897
使用@interface自定义注解时，自动继承了 java.lang.annotation.Annotation 接口，由编译程序自动完成其他细节。在定义注解时，不能继承其他的注解或接口。@interface 用来声明一个注解，其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称，返回值类型就是参数的类型（返回值类型只能是 基本类型、Class、String、enum）。可以通过default来声明参数的默认值。public @interface 注解名{注解体}
掌握Spring AOP：开发中的切面编程与案例分析
热门推荐
张彦峰的博客
05-12 166万+
本文介绍了 Spring AOP（面向切面编程） 的基本理论和实际应用。首先，详细解释了 AOP 中的关键概念，如连接点、切点、通知等，并通过切点表达式和正则规则的使用，展示了如何在不同场景下灵活应用 AOP。接着，结合多个实际开发案例，讲解了如何使用 AOP 实现方法自动打印、mock 赋能干预、业务处理和异步操作等功能。最后，文章总结了 AOP 的开发注意事项及最佳实践，帮助开发者避免常见的陷阱并提高代码的可维护性和扩展性。
用xml配置的方式进行SpringAOP开发
03-27
本篇文章主要讲解如何通过XML配置来实现Spring AOP的开发。 首先，了解AOP的基本概念。AOP通过“切面”（Aspect）来封装横切关注点，切面由“通知”（Advice）和“连接点”（Join Point）组成。通知是在特定连接点...
spring AOP开发需要的包
10-18
spring 实现AOP不仅仅需要自己的jar包，还需要第三方的jar，分别是 aspectjrt.jar,aspectjweaver.jar,aopalliance-1.0.jar,将这三个jar包放入项 目中就可以spring的aop编程了。...都是用于开发Spring AOP的包
spring AOP开发的补充依赖包
07-21
spring官方下载包之外的必备补充依赖包，包括com.springsource.net.sf.cglib-2.2.0.jar, com.springsource.org.aopalliance-1.0.0.jar, com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar, commons-logging-...
SkyWalking+Springboot实战
乄bluefox - CSDN博客
03-29 910
主要讲解如何在Linux上部署SkyWalking和怎么去在代码中添加自定义去监控接口，还有一些自己操作的时候遇到的bug，并且附上解决办法,自我感觉算是比较完善的博客了
基于SpringBoot和Vue的SQL TO API平台的设计与实现
zcs2312852665的博客
03-28 783
在当今数字化飞速发展的时代，数据的价值愈发凸显，高效的数据交互与共享成为企业和组织提升竞争力的关键因素。传统的数据库操作方式，往往需要专业的数据库知识和复杂的 SQL 语句，这在一定程度上限制了数据的广泛应用和快速开发。为了打破这一壁垒，实现 SQL 数据与外部系统的便捷交互，基于 Spring Boot 和 Vue 构建的 SQL TO API 平台应运而生。Spring Boot 作为一款轻量级的 Java 开发框架，以其高效、便捷的特性，极大地简化了后端开发流程，提高了开发效率和代码的可维护性。
springboot mybatis（不是mybatis-plus）多租户
qq_39763510的博客
03-31 100
由于原系统中引用了pagehelper-spring-boot-starter，并且PageInterceptor初始化比较晚，影响自定义多租户拦截器。需要把自定义拦截器的初始化放到最后，spring容器就绪后，初始化自定义mybatis拦截器。
【 ＜二＞ 丹方改良：Spring 时代的 JavaWeb】之 Spring Boot 中的安全性：使用 Spring Security 实现认证与授权
最新发布
FoyoDesigner的博客
03-31 637
今儿个咱唠唠 Spring Boot 里头的安全性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值