spring 入门实战（四） Aop

最新推荐文章于 2023-05-26 15:44:03 发布
最新推荐文章于 2023-05-26 15:44:03 发布
阅读量146 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35794278/article/details/79691395
版权
spring 同时被 2 个专栏收录
16 篇文章 0 订阅
订阅专栏
java
10 篇文章 0 订阅
订阅专栏

spring aop实战

本篇只是用实际案例帮助快速入门，不涉及具体概念

1.0 开发环境
 1.0 开发工具 eclipse
 2.0 jar包  除了Spring jar包外，还需要其他jar包  spring本身并没有提供  我也不知为什么
 https://pan.baidu.com/s/16MTV5K8zG8m9cROC-6G_iQ  提取码：hro2
2.0 搭建主业务模块 Affairs.java
package com.ccut.aop;

import java.io.IOException;

public class Affairs {

    private String message1;
    private String message2;


    public Affairs(){}


    public String getMessage1() {
        return message1;
    }

    public void setMessage1(String message1) {
        this.message1 = message1;
    }

    public String getMessage2() {
        return message2;
    }

    public void setMessage2(String message2) {
        this.message2 = message2;
    }

    public void PersonA(){
        System.out.println("A 这个人说啊："+this.getMessage1());
    }

    public void PersonB(){
        System.out.println("B 这个人说啊："+this.getMessage2());
    }


    public void error(){
        System.out.println("error!!!");
        int i = 10;
        if(i != 1){
            throw new IllegalArgumentException("这是参数异常");
        }

    }



}
3.0 搭建切面功能类Function
package com.ccut.aop;

import org.aspectj.lang.ProceedingJoinPoint;

public class Function {
        private String fmessage;
        private String mmessage;
        public Function(){}
        public String getFmessage() {
            return fmessage;
        }
        public void setFmessage(String fmessage) {
            this.fmessage = fmessage;
        }
        public String getMmessage() {
            return mmessage;
        }
        public void setMmessage(String mmessage) {
            this.mmessage = mmessage;
        }

        public void f(){
            System.out.println(this.getFmessage());
        }

        public void around(ProceedingJoinPoint pj){
            System.out.println("在目标函数之前执行");
            try {
                pj.proceed();
            } catch (Throwable e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                System.out.println("在目标函数之后执行");
            }
        }

        public void m(){
            System.out.println(this.getMmessage());
        }

        public void mess(String msg){
            System.out.println(msg+"  这是返回后的信息");
        }

        public void err(Throwable ex){
            System.out.println("这个错误是："+ex);
        }

}
4.0 搭建测试类 Test.java
package com.ccut.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ccut.aop.Affairs;

public class Test {
    public static void main(String[] args) {

        ApplicationContext applicationContext = 
        new ClassPathXmlApplicationContext("./resources/aop.xml");

        Affairs affairs = (Affairs) applicationContext.getBean("affairs");
        affairs.PersonA();
        affairs.PersonB();

    }
}

上面是公共的，也就是说下面的测试都用的是上面的代码

5.0 编写配置文件aop.xml 位于resources文件夹内（这是整合后的，单个功能的配置文件在后面 暂时不用看这个）
<?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"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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/tx
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <aop:config>
        <aop:aspect id="aspect1" ref="function">
            <aop:pointcut id="personA" expression="execution(* com.ccut.aop.Affairs.PersonA())"/> 
            <aop:pointcut id="personB" expression="execution(* com.ccut.aop.Affairs.PersonB())"/>           
            <!-- <aop:pointcut id="return" expression="execution(* com.ccut.aop.Affairs.*(..))"/>           
            <aop:before pointcut-ref="personA" method="f"/>
            <aop:after method="m" pointcut-ref="personA"/>
            <aop:after-returning method="mess" returning="msg" pointcut-ref="return"/> -->
            <aop:around method="around" pointcut-ref="personB"/>
        </aop:aspect>
    </aop:config>

    <bean id="affairs" class = "com.ccut.aop.Affairs">
        <property name="message1" value="我就是 A 啊  这有什么疑问吗？"/>
        <property name="message2" value="我就是 B 啊  这有什么疑问吗？"/>
    </bean>

    <bean id = "function" class="com.ccut.aop.Function">
        <property name="fmessage" value="我可能在你前面执行！"></property>
        <property name="mmessage" value="我可能在你后面执行呢！"></property>
    </bean>



    </beans>
5.1 我们把上面的配置文件拆开看，以便更好的理解

aop的切入形式有一下几种

<aop:before  method= ''beforemethod'',pointcut-ref="cut1"/>
<aop:after  method= ''aftermethod'',pointcut-ref="cut2"/>
<aop:after-returning method="mess" returning="msg" pointcut-ref="return"/>
<aop:around method="around" pointcut-ref="personB"/>
<aop:after-throwing method="" pointcut-ref="" throwing=""/>
<aop:declare-parents/>这个暂时不解释

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

    <bean id="affairs" class = "com.ccut.aop.Affairs">
        <property name="message1" value="我就是 A 啊  这有什么疑问吗？"/>
        <property name="message2" value="我就是 B 啊  这有什么疑问吗？"/>
    </bean>

    <bean id = "function" class="com.ccut.aop.Function">
        <property name="fmessage" value="我可能在你前面执行！"></property>
        <property name="mmessage" value="我可能在你后面执行呢！"></property>
    </bean>

    </beans>

上面的简化后的配置文件实现了对事物类 和切面类相关参数的注入
执行简化后的配置文件的结果为：
这里写图片描述

5.2.1 下面是把功能类的某一方法切入到切入点前面执行的aop.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"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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/tx
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <aop:config>
        <aop:aspect id="aspect1" ref="function">

            <aop:pointcut id="personA" expression="execution(* com.ccut.aop.Affairs.PersonA())"/>   
            <!-- 下面是以后要改动的代码↓↓↓↓↓↓↓↓-->         
            <aop:before pointcut-ref="personA" method="f"/>
            <-- 上面是以后要改动的代码↑↑↑↑↑↑↑-->
        </aop:aspect>
    </aop:config>

    <bean id="affairs" class = "com.ccut.aop.Affairs">
        <property name="message1" value="我就是 A 啊  这有什么疑问吗？"/>
        <property name="message2" value="我就是 B 啊  这有什么疑问吗？"/>
    </bean>

    <bean id = "function" class="com.ccut.aop.Function">
        <property name="fmessage" value="我可能在你前面执行！"></property>
        <property name="mmessage" value="我可能在你后面执行呢！"></property>
    </bean>

    </beans>

执行结果：
这里写图片描述

5.2.2 把指定方法放在切入点后面执行

配置文件对应位置改为

<aop:after method="m" pointcut-ref="personA"/>

结果为：
这里写图片描述

5.2.3 在指定方法结束时候执行

配置文件如下

<aop:config>
        <aop:aspect id="aspect1" ref="function">        
            <aop:pointcut id="return" expression="execution(* com.ccut.aop.Affairs.*(..))"/>        

        <aop:after-returning method="mess" returning="msg" pointcut-ref="return"/>

        </aop:aspect>
    </aop:config>

测试类：

package com.ccut.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ccut.aop.Affairs;

public class Test {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("./resources/aop.xml");

        Affairs affairs = (Affairs) applicationContext.getBean("affairs");
        affairs.PersonA();
        affairs.PersonB();

        affairs.getMessage1();


    }
}

结果：
这里写图片描述

5.2.4 抛出异常后执行 aop:after-throwing 这个方法不能完全处理异常 最终还是会交给jvm

配置文件：
把上面的 < aop:after-returning method=”mess” returning=”msg” pointcut-ref=”return”/> 替换为下面的

     <aop:after-throwing method="err" throwing="ex" pointcut-ref="return"/>

主方法中的affairs.getMessage1();改为下面

affairs.error();

结果：
这里写图片描述

5.2.5 环绕通知增强 aop:around

配置文件：

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

    <aop:config>
        <aop:aspect id="aspect1" ref="function">

            <aop:pointcut id="personB" expression="execution(* com.ccut.aop.Affairs.PersonB())"/>           
            <aop:around method="around" pointcut-ref="personB"/>
        </aop:aspect>
    </aop:config>

    <bean id="affairs" class = "com.ccut.aop.Affairs">
        <property name="message1" value="我就是 A 啊  这有什么疑问吗？"/>
        <property name="message2" value="我就是 B 啊  这有什么疑问吗？"/>
    </bean>

    <bean id = "function" class="com.ccut.aop.Function">
        <property name="fmessage" value="我可能在你前面执行！"></property>
        <property name="mmessage" value="我可能在你后面执行呢！"></property>
    </bean>



    </beans>

测试类：

package com.ccut.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ccut.aop.Affairs;

public class Test {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("./resources/aop.xml");

        Affairs affairs = (Affairs) applicationContext.getBean("affairs");
        affairs.PersonA();
        affairs.PersonB();
    }
}

结果：
这里写图片描述

这里注意 环绕通知方法重点一定要有下面这个形参ProceedingJoinPoint pj 如果没有 pj.proceed();这个代码
则被切入的函数不会执行

 public void around(ProceedingJoinPoint pj){
            System.out.println("在目标函数之前执行");
            try {
                pj.proceed();
            } catch (Throwable e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                System.out.println("在目标函数之后执行");
            }
        }

这里的< aop:declare-parents/>这个暂时不解释

你可拉倒吧
关注
专栏目录
Spring 入门到实战
06-13
在Spring中配置Bean、自动装配、Bean之间的关系（依赖、继承）、Bean的作用域、使用外部属性文件、SpEL、...AOP使用JdbcTemplate和JdbcDaoSupport、Spring的声明式事务、事务的属性、使用XML文件的方式配置事务整合应用
全套Spring Security入门到项目实战课程
03-21
### Spring Security 全套入门到项目实战课程知识点详解 #### 一、Spring Security 概述 **1.1 Spring Security 介绍** - **定义**: Spring Security 是一款基于 Spring 框架的身份认证(Authentication)与用户...
记一次Spring的aop代理Mybatis的DAO所遇到的问题
weixin_30852367的博客
08-29 634
由来 项目中需要实现某个订单的状态改变后然后推送给第三方的功能，由于更改状态的项目和推送的项目不是同一个项目，所以为了不改变原项目的代码，我们考虑用spring的aop来实现。 项目用的是springmvc + spring + mybatis 的架构，我们知道spring实现了两种代理方式：JDK动态代理和CGLB动态代理。所以spring对接口和类都可以实现代理。所以只需要考虑在DAO接口...
Java：65-Spring实战以及AOP介绍
qq_59609098的博客
04-23 1030
Spring实战以及AOP介绍 转账案例： 需求： 使用spring框架整合DBUtils技术，实现用户转账功能 基础功能： 步骤分析： /* 1. 创建java项目，导入坐标 2. 编写Account实体类 3. 编写AccountDao接口和实现类 4. 编写AccountService接口和实现类 5. 编写spring核心配置文件 6. 编写测试代码 */ 创建java项目，导入坐标： <dependencies> <dependency> <
Spring从入门到实战 AOP
quanquanya的博客
06-27 255
AOP AOP：Aspect Oriented Programming面向切面编程 优点 降低模块之间的耦合度 使系统更容易扩展 更好的代码复用 非业务代码更集中，不分散，便于统一管理 业务代码更加简洁纯粹，不掺杂其他代码的影响 AOP是对面向对象编程的一个补充，在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面编程。将不同方法的同一个位置抽象成一个切面对象，对该切面对象进行编程就是AOP。 如何使用 创建Maven工程，pom.xml添加 <depe
Spring Aop 面向切面编程 入门实战
pingzhuyan的博客
08-14 453
创建注解类型，应用于切入点表达式的定义详细解释在代码中 基本每行我都写注释了/*** 自定义注解 时间输出(简单)*//*** 操作信息* @return*//*** value 默认值 可以不写* @return*/}
Spring AOP 入门、实现原理及实践案例
一名Java语言狂热分子。
05-26 1656
Spring 是目前 Java 领域最为流行的开发框架之一，它提供了很多方便快捷的功能，其中之一就是 AOP（Aspect Oriented Programming），即面向切面编程。本文将详细介绍 Spring AOP 的实现原理、核心概念以及在实际应用中的使用案例。
panda白话 - Spring AOP 入门+实战
FightingITPanda的博客
05-21 198
Spring 两大🐮特性：IOC 、AOP 面试必问😄 基本上大家都是对IOC理解比较深刻，Spring通过IOC容器帮我们管理bean嘛 AOP其实使用也很广泛，只是你没咋关注过 因为基本属于框架级的，基本配置一次就不用管了，那起码要看懂呀， let`s go~~ AOP 定义： Oriented Object Progamming (面向切面编程) 概念： 连接点 - joint point 切入点 - point cut 通知 - advice 织入 - weaving 切面.
SpringAop 项目日志埋点实战
zhouhouxing
06-04 692
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习..
spring入门实战&源码解读(2)：spring AOP入门实战
weixin_42488772的博客
02-12 159
一、AOP的相关概念 1.1AOP概述 1.1.1什么是AOP AOP：全称是Aspect Oriented Programming，即面向切面编程，通过预编译的方式和运行期动态代理实现程序功能的统一维护的一种技术。简单来说就是把程序的重复代码抽取出来，在需要执行的时候，使用动态代理技术，在不修改源码的基础上，对我们已有的方法进行增强。 1.1.2 AOP的使用及优势 问题：在传统的业务处理代码中，通常会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但是如果要
spring 入门实战（五） aop基于注解的使用
靠脑袋是真滴记不住啊！！！！！！！！
03-26 210
1.0 开发环境 同上一篇文章 Spring 入门实战（四） aop 2.0 准备工作 由于本篇还是基于aop的 所以我们还是基于上节的代码 做一些相应改动即可 2.1 主业务模块 Affairs.java 同上一篇文章 2.2 切面功能类 Function.java package com.ccut.aop; import org.aspectj.lang.P...
2024 Java Spring框架入门心得与实战经验分享.zip
03-01
内容概要：这篇文章是一篇关于Java Spring框架的入门心得和实战经验分享。作者以通俗易懂的语言，介绍了Spring框架的核心概念，如IoC（控制反转）、AOP（面向切面编程）等，并分享了自己在实际项目中使用Spring框架...
spring入门到精通.txt
03-20
根据提供的文件信息“spring入门到精通”，我们可以详细探讨Spring框架的核心概念、应用场景以及学习路径等内容。 ### Spring框架简介 Spring框架是由Rod Johnson创建的一个开源框架，最初是为了解决企业级应用...
基于matlab平抑风电波动的电-氢混合储能容量优化配置【含Matlab源码 期】.zip
09-27
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
dynamic_unet-0.0.2-py3-none-any.whl
最新发布
09-27
dynamic_unet-0.0.2-py3-none-any.whl
基于Java语言的动态二维码生成与绘制设计源码
09-27
该项目是一款基于Java语言的动态二维码生成与绘制设计源码，包含126个文件，包括64个JAR包、24个PNG图片、17个GIF动画、10个XML配置、7个Java源文件、2个Markdown文件、1个Idea项目配置文件和1个JPG图片文件。该项目通过图像生成动态二维码，适用于需要动态二维码绘制的场景。
go1.23.1.linux-amd64.tar.gz
09-27
golang linux amd63 sdk
JavaScript高分作品《微信小程序-图书馆管理系统》+源代码+文档说明
09-27
<项目介绍> - 微信小程序—图书馆管理系统 - 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 --------
Spring入门：依赖注入与AOP实战
本章的目标是深入理解并掌握Spring框架中的两个核心概念：依赖注入（Dependency Injection, DI）和面向方面编程（Aspect-Oriented Programming, AOP）。首先，依赖注入是Spring的核心特性，它通过将组件的创建过程与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值