基于Spring3.0实现AOP的小案例

于 2024-09-29 15:35:55 发布
阅读量235 收藏 3
点赞数 9
分类专栏： Spring 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52937170/article/details/142636277
版权

前言

AOP（Aspect Oriented Programming）即面向切面编程，是一种通过预编译方式和运行期间动态代理实现程序功能统一维护的技术。针对功能增强的描述，可以理解为：“AOP允许在不修改源代码的情况下，通过定义切面（Aspect）和切入点（Pointcut），对目标对象的方法进行功能增强。”

具体来说，AOP能够将业务逻辑中的横切关注点（如日志、安全、事务等）与核心业务逻辑分离，从而降低代码间的耦合度，提高程序的可重用性和开发效率。在Spring框架中，AOP提供了多种增强类型，如前置增强、后置增强、环绕增强、异常抛出增强和引介增强等，这些增强类型可以灵活应用于不同的业务场景，以满足不同的功能需求。

 案例分析

实现手机购买和售卖的案例，利用AOP添加日志功能，显示当前时间等信息。

案例实现

 第一步：创建maven项目，导入相关依赖

pom.xml

这是spring3.0使用AOP的相关依赖，如果使用的是spring5.0以上，导包可能没有这么多，这是我的spring3.0 AOP的最佳实践

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>3.0.5.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>3.0.5.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.6.11</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>3.0.5.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.6.11</version>
    </dependency>

    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>2.1</version>
    </dependency>

第二步：创建service层业务，创建接口和实现类完成基本功能

 

PhoneBiz

public interface PhoneBiz {

    void buyPhone(int num);

    void salePhone(int num) throws OutOfStackException;
}

PhoneBizImpl

public class PhoneBizImpl implements PhoneBiz {
    int num;  //库存
    @Override
    public void buyPhone(int num) {
        System.out.println("手机进货,数量为"+num+"部");
        this.num+=num;
    }

    @Override
    public void salePhone(int num) throws OutOfStackException {
     
        System.out.println("手机销售,数量为"+num+"部");
    }
}

第三步：创建LogAspect切面类和spring的配置文件spring.xml

LogAspect

完成前置通知，在原始方法执行前进行日志输出

public class LogAspect {

    public String currTime(){
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        return sdf.format(new Date());
    }

    /**
     * 前置通知
     * @param jp
     */
    public void before(JoinPoint jp){
        //获得请求方法的参数
        Object[] args= jp.getArgs();
        //获得请求方法名
        String methodName= jp.getSignature().getName();

        if ("buyPhone".equals(methodName)){
            System.out.println("日志:"+currTime()+",即将开始进货操作,数量为"+args[0]+"部");
        }
        if ("salePhone".equals(methodName)){
            System.out.println("日志:"+currTime()+",即将开始销售操作,数量为"+args[0]+"部");
        }
    }

spring.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:p="http://www.springframework.org/schema/p"
       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-3.0.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.0.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">


    <bean id="phoneBiz" class="com.by.service.PhoneBizImpl"></bean>

    <bean id="logAspectBean" class="com.by.util.LogAspect"></bean>

    <aop:config proxy-target-class="true">
        <aop:pointcut id="p1" expression="execution( void *Phone(int))"/>
        <aop:aspect id="logAspect" ref="logAspectBean">
            <aop:before method="before" pointcut-ref="p1"/>
        </aop:aspect>
    </aop:config>


</beans>

 第四步：分别完成最终通知，后置通知，异常通知，环绕通知

LogAspect

 /**
     * 后置通知
     * @param jp
     */
    public void afterReturing(JoinPoint jp){
        //获得请求方法的参数
        Object[] args= jp.getArgs();
        //获得请求方法名
        String methodName= jp.getSignature().getName();

        if ("buyPhone".equals(methodName)){
            System.out.println("日志:"+currTime()+",进货操作结束,数量为"+args[0]+"部");
        }
        if ("salePhone".equals(methodName)){
            System.out.println("日志:"+currTime()+",销售操作结束,数量为"+args[0]+"部");
        }
    }

    /**
     * 异常通知
     * @param jp
     * @param e
     */
    public void afterThrowing(JoinPoint jp,OutOfStackException e){
        String methodName= jp.getSignature().getName();
        System.out.println(currTime()+":"+methodName+"发生异常:"+e.getMessage());

    }

    /**
     * 后置通知,发生异常也会执行
     * @param jp
     */
    public void after(JoinPoint jp){
        String methodName= jp.getSignature().getName();

        if ("buyPhone".equals(methodName)){
            System.out.println("日志:"+currTime()+",进货操作完毕,发生异常也会执行");
        }
        if ("salePhone".equals(methodName)){
            System.out.println("日志:"+currTime()+",销售操作完毕,发生异常也会执行");
        }
    }

    /**
     * 环绕通知
     * @param pjp
     * @return
     * @throws Throwable
     */
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        String methodName=  pjp.getSignature().getName();
        System.out.println(methodName+"方法开始执行:");
        long begin= System.currentTimeMillis();

        try {
            return pjp.proceed();
        } finally {
            long end= System.currentTimeMillis();
            System.out.println(methodName+"方法执行完毕,耗时"+(end-begin)+"毫秒");
        }

    }


    public String currTime(){
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        return sdf.format(new Date());
    }

spring.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:p="http://www.springframework.org/schema/p"
       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-3.0.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.0.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">


    <bean id="phoneBiz" class="com.by.service.PhoneBizImpl"></bean>

    <bean id="logAspectBean" class="com.by.util.LogAspect"></bean>

    <aop:config proxy-target-class="true">
        <aop:pointcut id="p1" expression="execution( void *Phone(int))"/>
        <aop:aspect id="logAspect" ref="logAspectBean">
            <aop:before method="before" pointcut-ref="p1"/>
            <aop:after-returning method="afterReturing" pointcut-ref="p1"/>
            <aop:after-throwing method="afterThrowing" pointcut-ref="p1" throwing="e"/>
            <aop:after method="after" pointcut-ref="p1"/>
            <aop:around method="around" pointcut-ref="p1"/>
        </aop:aspect>
    </aop:config>


</beans>

注意：如果要完成异常通知，需要预先自定义一个异常类。

package com.by.util;

/**
 * 库存异常类
 */
public class OutOfStackException extends Exception {

    public OutOfStackException(String message) {
        super(message);
    }
}

在PhoneBizImpl中新增判断语句

  @Override
    public void salePhone(int num) throws OutOfStackException {
        if (this.num<num){
            throw  new OutOfStackException("库存不足,需要"+num+"部,只有"+this.num+"部");
        }
        System.out.println("手机销售,数量为"+num+"部");
    }

 

第五步：将配置文件配置AOP的操作改为注解实现

将spring.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:p="http://www.springframework.org/schema/p"
       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-3.0.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.0.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <context:component-scan base-package="com.by"/>
    <!--启用注解aop-->
    <aop:aspectj-autoproxy/>


<!--    <bean id="phoneBiz" class="com.by.service.PhoneBizImpl"></bean>-->

<!--    <bean id="logAspectBean" class="com.by.util.LogAspect"></bean>-->

<!--    <aop:config proxy-target-class="true">-->
<!--        <aop:pointcut id="p1" expression="execution( void *Phone(int))"/>-->
<!--        <aop:aspect id="logAspect" ref="logAspectBean">-->
<!--            <aop:before method="before" pointcut-ref="p1"/>-->
<!--            <aop:after-returning method="afterReturing" pointcut-ref="p1"/>-->
<!--            <aop:after-throwing method="afterThrowing" pointcut-ref="p1" throwing="e"/>-->
<!--            <aop:after method="after" pointcut-ref="p1"/>-->
<!--            <aop:around method="around" pointcut-ref="p1"/>-->
<!--        </aop:aspect>-->
<!--    </aop:config>-->




</beans>

 在PhoneBizImpl实现类中：

@Component(value = "phoneBiz")
public class PhoneBizImpl implements PhoneBiz {
...}

 在LogAspect中使用注解：

/**
 * 通知类
 */
@Aspect
@Component
public class LogAspect {

    /**
     * 前置通知
     * @param jp
     */
    @Before("p1()")
    public void before(JoinPoint jp){
        //获得请求方法的参数
        Object[] args= jp.getArgs();
        //获得请求方法名
        String methodName= jp.getSignature().getName();

        if ("buyPhone".equals(methodName)){
            System.out.println("日志:"+currTime()+",即将开始进货操作,数量为"+args[0]+"部");
        }
        if ("salePhone".equals(methodName)){
            System.out.println("日志:"+currTime()+",即将开始销售操作,数量为"+args[0]+"部");
        }
    }

    /**
     * 后置通知
     * @param jp
     */
    @AfterReturning("execution( void *Phone(int))")
    public void afterReturing(JoinPoint jp){
        //获得请求方法的参数
        Object[] args= jp.getArgs();
        //获得请求方法名
        String methodName= jp.getSignature().getName();

        if ("buyPhone".equals(methodName)){
            System.out.println("日志:"+currTime()+",进货操作结束,数量为"+args[0]+"部");
        }
        if ("salePhone".equals(methodName)){
            System.out.println("日志:"+currTime()+",销售操作结束,数量为"+args[0]+"部");
        }
    }

    /**
     * 异常通知
     * @param jp
     * @param e
     */
    @AfterThrowing(pointcut = "execution( void *Phone(int))",throwing = "e")
    public void afterThrowing(JoinPoint jp,OutOfStackException e){
        String methodName= jp.getSignature().getName();
        System.out.println(currTime()+":"+methodName+"发生异常:"+e.getMessage());

    }

    /**
     * 后置通知,发生异常也会执行
     * @param jp
     */
    @After("execution( void *Phone(int))")
    public void after(JoinPoint jp){
        String methodName= jp.getSignature().getName();

        if ("buyPhone".equals(methodName)){
            System.out.println("日志:"+currTime()+",进货操作完毕,发生异常也会执行");
        }
        if ("salePhone".equals(methodName)){
            System.out.println("日志:"+currTime()+",销售操作完毕,发生异常也会执行");
        }
    }

    /**
     * 环绕通知
     * @param pjp
     * @return
     * @throws Throwable
     */
    @Around("execution( void *Phone(int))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        String methodName=  pjp.getSignature().getName();
        System.out.println(methodName+"方法开始执行:");
        long begin= System.currentTimeMillis();

        try {
            return pjp.proceed();
        } finally {
            long end= System.currentTimeMillis();
            System.out.println(methodName+"方法执行完毕,耗时"+(end-begin)+"毫秒");
        }

    }

    @Pointcut("execution( void *Phone(int))")
    public void p1(){}



    public String currTime(){
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        return sdf.format(new Date());
    }
}

总结

以上是基于spring3.0使用AOP实现日志记录功能的小案例

VaporGas
关注
专栏目录
SpringAOP详解三种实现方式及其使用案例
qq_46993700的博客
06-04 3815
文章目录一、AOP（一）什么是AOP（二）AOP与代理模式（三）AOP在Spring中的作用（四）使用Spring实现AOP（重点）（五）Spring中的事务（六）Spring的事务传播级别二、整合Mybatis案例 一、AOP （一）什么是AOP AOP（Aspect Oriented Programming）意为：面向切面编程，体现了横切的思想，意思是在添加某项功能的时候，是以切面插入的方式实现的，对原有的代码不会产生改变。通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的
Spring AOP案例
qq_43905485的博客
07-27 134
IDEA下新建maven项目 项目目录 2.编写Func类，其中随便添加两个方法 package com.aop; public class Func { public void add(){ System.out.println("做点事情吧"); } public void test(){ System.out.println("这是一个测试方法"); } } 3.编写FuncPlus类，这是对Func类中方法的增强类 packa.
Spring源码系列： AOP实现
Zong_0915的博客
03-29 1775
Spring源码系列： AOP实现前言一. AOP的使用二. AOP的实现2.1 创建AnnotationAwareAspectJAutoProxyCreator2.1.1 注册或升级AnnotationAwareAspectJAutoProxyCreator2.1.2 处理 proxy-target-class 以及 expose-proxy 属性2.2 AnnotationAwareAspectJAutoProxyCreator的作用2.3 获取增强器2.3.1 获取增强器findCandidateAd
Spring 基于XML配置的AOP入门案例
xqsy2008的专栏
04-23 389
AOP是Aspect Oriented Programing的简称--面向切面编程。在软件开发中，分布于应用中多处的功能被称为横切关注点。通常这些横切关注点从概念上是与应用的业务逻辑相分离（但是往往直接嵌入到应用的业务逻辑之中）。将这些横切关注点与业务逻辑相分离正是面向切面编程（AOP）所要解决的。 AOP术语 通知（Advice） 包含5种类型：Before(在方法被调用之前调用通知)、Af
最简单的SpringAop 小案例
weixin_30951743的博客
09-19 259
网盘下载地址： 链接：https://pan.baidu.com/s/1Z-em-1ouWyXeMP3JW0IbCg 提取码：0o4o 1、目录结构： 2、配置文件 applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://...
Spring aop实现声明式事务
m_q_x的博客
09-08 809
1.  声明式事务 事务分为：编程式事务，声明式事务 编程式事务:程序员通过自己写的代码来控制事务机制 声明式事务：是基于spring aop来实现的，通知！ 案例驱动：添加的同时，删除一条数据。 @Override    public int addUser(User user) {       int res = userMapper.addUser(us
Spring AOP详解（示例）
xiaoxsen的博客
08-14 2367
一、什么是AOP 　　AOP(Aspect-Oriented Programming), 即 面向切面编程, 它与 OOP( Object-Oriented Programming, 面向对象编程) 相辅相成, 提供了与 OOP 不同的抽象软件结构的视角.在 OOP 中, 我们以类(class)作为我们的基本单元, 而 AOP 中的基本单元是 Aspect(切面)。 二、AOP的优点 　　它
java spring aop实例_Spring AOP+AspectJ注解实例
weixin_39669761的博客
02-24 141
常见AspectJ的注解：@Before–方法执行前运行@After–运行在方法返回结果后@AfterReturning–运行在方法返回一个结果后，在拦截器返回结果。@AfterThrowing–运行方法在抛出异常后，@Around–围绕方法执行运行，结合以上这三个通知。注意SpringAOP 中没有 AspectJ 支持，请阅读内置 SpringAOP 例子。1. 目录...
Spring AOP+AspectJ注解实例
qq_41950429的博客
04-12 235
spring AOP+Aspect 用来实现拦截方法。 常见AspectJ的注解： @Before – 方法执行前运行 @After – 运行在方法返回结果后 @AfterReturning – 运行在方法返回一个结果后，在拦截器返回结果。 @AfterThrowing – 运行方法在抛出异常后。 @Around – 围绕方法执行运行，结合以上这三个通知。 1、pom.xml中的配置 &lt...
深入学习Spring IOC和AOP 实例代码
心猿意码
01-31 306
这次主要是通过Spring官网的文档学习,使用的代码也是官网提供的代码,并且把代码放到本地运行和学习,博客记录一下学习心得. 官网文档地址: https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-basics IOC IOC控制反转, 当一个了类需要注入其他类的对象的时候, 对象不需要自己手动创建引用类的对象, 执行需要从Spring IOC 容器获取,把创建对象的控制权交给容器. Bean
Spring3.0MVC注解+SringJdbcDaoSupport案例
03-06
总结来说，这个案例涵盖了Spring 3.0中的关键组件，包括Spring MVC的注解驱动开发，`SpringJdbcDaoSupport`的数据库操作，以及AOP的声明式事务管理。通过学习和实践这个案例，开发者可以深入了解Spring框架的使用，...
spring3.0学习
05-01
标题 "spring3.0学习" 暗示我们将探讨Spring框架的第三个主要版本，这是一个广泛使用的Java企业级应用开发框架。Spring 3.0引入了许多新特性，改进了已有的功能，增强了对现代Web应用程序的支持。 Spring框架的核心...
Struts1.2+Spring 3.0 案例，java代码
03-08
总的来说，这个案例展示了如何将Struts1.2的MVC能力与Spring 3.0的DI和AOP特性相结合，以构建一个灵活、可扩展的Java Web应用程序。开发者可以从中学习到如何配置和调和这两个框架，理解它们如何协同工作来处理HTTP...
Spring Boot 学习和使用
cesske的博客
09-24 1090
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
工厂模式的介绍及实现
户伟伟的博客
09-25 117
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 431
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
智能BI平台项目
2302_79400545的博客
09-22 238
BI商业智能：数据可视化、报表可视化系统。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 907
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 744
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值