彻底弄懂Spring中的AOP（XML+注解）

最新推荐文章于 2023-01-06 08:43:14 发布
最新推荐文章于 2023-01-06 08:43:14 发布
阅读量299 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41842236/article/details/105990597
版权

文章目录

一、AOP简介

1、AOP基本概念

在这里插入图片描述

简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

2、AOP的作用及优势

作用：在程序运行期间，不修改源码对已有方法进行增强。
优势：减少重复代码；提高开发效率；维护方便

3、AOP 的实现方式

使用动态代理技术

4、AOP相关术语

（1）Joinpoint(连接点)

所谓连接点是指那些被拦截到的点。在 Spring 中,这些点指的是方法,因为 Spring 只支持方法类型的连接点。

（2）Pointcut(切入点)

所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。

注意：所有的切入点都是连接点，但是所有的连接点不一定都是切入点。

（3）Advice(通知/增强)

所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

（4）Introduction(引介)

引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。

（5）Target(目标对象)

代理的目标对象。

（6）Weaving(织入)

是指把增强应用到目标对象来创建新的代理对象的过程。
Spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

（7）Proxy（代理）

一个类被 AOP 织入增强后，就产生一个结果代理类。

（8）Aspect(切面)

是切入点和通知（引介）的结合。

5、学习 Spring 中的 AOP 要明确的事

a、开发阶段（我们做的）
编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。
把公用代码抽取出来，制作成通知。（开发阶段最后再做）
在配置文件中，声明切入点与通知间的关系，即切面。

b、运行阶段（Spring 框架完成的）
Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

6、关于代理的选择

在 Spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

二、基于XML的AOP配置

1、添加依赖

		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>

2、IAccountService.java

public interface IAccountService {
    /**
     * 模拟保存账户
     */
    void saveAccount();

    /**
     * 模拟更新账户
     * @param i
     */
    void updateAccount(int i);

    /**
     * 模拟删除账户
     * @return
     */
    int deleteAccount();
}

3、AccountServiceImpl.java

public class AccountServiceImpl implements IAccountService {
    public void saveAccount() {
        System.out.println("执行了保存");
    }

    public void updateAccount(int i) {
        System.out.println("执行了更新" + i);
    }

    public int deleteAccount() {
        System.out.println("执行了删除");
        return 0;
    }
}

4、Logger.java

public class Logger {
    /**
     * 用于打印日志，计划让其在切入点方法执行之前执行（切入点方法即业务层方法）
     */
    public void printLog() {
        System.out.println("Logger类中的printLog方法开始记录日志了......");
    }
}

5、bean.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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--配置Spring的IoC，把accountService对象注入到容器中-->
    <bean id="accountService" class="com.uos.service.impl.AccountServiceImpl"></bean>

    <!--通知bean-->
    <bean id="logger" class="com.uos.utils.Logger"></bean>
    <aop:config>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置通知的类型，并将建立通知的方法和切入点方法进行关联-->
            <aop:before method="printLog" pointcut="execution(* com.uos.service.impl.*.*(..))"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

在这里插入图片描述
在这里插入图片描述

6、AopTest.java

public class AopTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService accountService = (IAccountService) applicationContext.getBean("accountService");
        accountService.saveAccount();
    }
}

7、运行结果

在这里插入图片描述

三、基于注解的AOP

本案例基于XML的AOP的案例进行配置。

1、添加@Service注解

在这里插入图片描述

2、配置切面类

@Component("logger")
@Aspect     //表示当前类是一个切面类
public class Logger {
    @Pointcut("execution(* com.uos.service.impl.*.*(..))")
    public void pt1(){};
    /**
     * 前置通知
     */
    //@Before("pt1()")
    public void beforePrintLog() {
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了......");
    }
    /**
     * 后置通知
     */
   // @AfterReturning("pt1()")
    public void afterPrintLog() {
        System.out.println("后置通知Logger类中的afterPrintLog方法开始记录日志了......");
    }
    /**
     * 异常通知
     */
  //  @AfterThrowing("pt1()")
    public void throwingPrintLog() {
        System.out.println("异常通知Logger类中的throwingPrintLog方法开始记录日志了......");
    }
    /**
     * 最终通知
     */
  //  @After("pt1()")
    public void finalPrintLog() {
        System.out.println("最终通知Logger类中的finalPrintLog方法开始记录日志了......");
    }
    /**
     * 环绕通知
     */
    @Around("pt1()")
    public Object aroundPrintLog(ProceedingJoinPoint pjp) {
        Object rtValue = null;
        try {
            // 得到方法执行所需的参数
            Object[] args = pjp.getArgs();
            System.out.println("Logger类中的aroundPrintLog方法开始记录日志了......前置");

            // 明确调用业务层方法
            rtValue= pjp.proceed(args);

            System.out.println("Logger类中的aroundPrintLog方法开始记录日志了......后置");
            return rtValue;
        } catch (Throwable t) {
            System.out.println("Logger类中的aroundPrintLog方法开始记录日志了......异常");
            throw new RuntimeException(t);
        } finally {
            System.out.println("Logger类中的aroundPrintLog方法开始记录日志了......最终");
        }

    }
}

3、bean.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"
       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">

    <!--告知Spring创建容器时需要扫描的包-->
    <context:component-scan base-package="com.uos"></context:component-scan>
    <!--配置Spring开启注解AOP的支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
@青春之路
关注
专栏目录
基于 XML 的 AOP 开发入门
QAQ
01-13 166
一、步骤 (下面演示我用的applicationContext-aop.xml啥名都行的，测试对应起来就行) ① 导入 AOP 相关坐标（在pom.xml） <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.
SpringMvc+Spring+Mybatis+Maven+注解方式=整合
08-22
- 接着，在Spring的配置文件（如：applicationContext.xml）中，配置Spring的核心组件，如Bean的定义、AOP的配置等。 - 使用Spring MVC的注解，比如@Controller、@Service、@Repository，将Java类标记为特定的角色，...
xml方式实现aop
qq_33755492的博客
08-06 256
pom.xml配置： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven
Java Spring AOP用法
weixin_30617737的博客
09-04 242
Java Spring AOP用法 Spring AOP Java web 环境搭建 Java web 项目搭建 Java Spring IOC用法 spring提供了两个核心功能，一个是IoC(控制反转)，另外一个便是Aop(面向切面编程)，IoC有助于应用对象之间的解耦，AOP则可以实现横切关注点（如日志、安全、缓存和事务管理）与他们所影响的对象之间的解耦。 1.简介 AOP主要包含...
Spring 在xml中配置AOP
m0_50163856的博客
04-21 163
定义切面对象： public class MyAspect { public void myBefore(){ System.out.println("myBefore"); } public void myAfter(){ System.out.println("myAfter"); } public void myAfterReturning(){ System.out.println("myAfterRetu
基于 XML 的 AOP 开发
Tang_cancan的博客
11-24 356
快速入门 六个步骤： ①导入 AOP 相关坐标 <!--导入spring的context坐标，context依赖aop--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> &lt...
SpringAOP中的注解配置详解
08-25
本文将详细介绍SpringAOP中的注解配置详解，包括使用注解实现SpringAOP的功能、XML配置等方面的内容。 一、使用注解实现SpringAOP的功能 在SpringAOP中，注解是实现AOP功能的主要方式之一。通过使用注解，开发者...
Spring+SpringMvc+MybatisPlus+Aop（自定义注解）动态切换数据源
12-25
本项目“Spring+SpringMvc+MybatisPlus+Aop（自定义注解）动态切换数据源”正是针对这一需求提供的一种解决方案。下面将详细介绍这个项目中的关键技术点和实现原理。 首先，Spring框架是Java企业级应用开发的核心...
Spring AOP 实现详解：XML、XML+注解、纯注解方式
1. 纯XML方式：这是早期Spring AOP的主要配置方式，所有的配置都在XML文件中完成。首先，需要引入`spring-aop`和`aspectjweaver`依赖。在服务类如`TransferServiceImpl`中，可以定义一个具体的方法，例如`transfer`...
spring中aop的xml配置方法实例详解
08-29
在Spring框架中，实现AOP有两种主要方式：XML配置和AspectJ注解。本文主要讨论的是XML配置方式。在XML配置中，你需要在Spring配置文件中定义目标对象、切面类以及具体的切点和通知。 首先，创建目标对象。在例子中...
Spring 基于XML配置的AOP框架详细讲解
代码人生的博客
11-09 1518
学习Spring中的AOP，就是通过配置的方式（有基于XML配置的， 以及基于注解配置的），来实现相关的拦截切入功能。对原有的操作进行加强，但不影响原本的操作。 1.理解：Aop进行的加强就是如此，你仅仅是想要查询用户，但是在你进行的过程中我对你的过程进行的扩充操作。（小编个人的理解） 2.必须的jar包 3.大致分为两类进行学习 （1）前置，后置，异常，最终 前置通知：在切入点方法执行之前执行 后置通知：在切入点方法正常执行之后执行。它和异常通知永远只能执行一个 异..
Spring AOP使用（XML配置方式和注解方式）
qq_44735982的博客
07-16 205
Aop切面学习
AOP
m0_37708405的博客
07-15 1006
    AOP相关概念【场景描述】         结合前面的编码实操，已经解决了最初需求，推而广之，我们将纵向的从上到下的主要业务逻辑成为主线关注，如上面对User的CRUD操作；将增加日志记录、安全检查等横向性的问题，可以喝主线业务分离分开的称为(参考代理模式篇)横切性关注点AOP编程也就是基于上述描述推演开来。1)       横切性关注点我们加在主线业务前后的这些内容称为“横切性关注点”。...
Spring的AOP面向切面编程
Smile2you的博客
08-09 214
什么是AOP？ 1.AOP概念介绍 　　所谓AOP，即Aspect orientied program,就是面向方面(切面)的编程。 　　　功能： 让关注点代码与业务代码分离！ 关注点:          　重复代码就叫做关注点； 业务代码： 　　　　核心业务的代码 业务代码与关注点代码分离，好处？             　　 --&gt; 关注点代码写一次即可；      ...
Spring Aop xml配置和注解配置
Big Data
06-20 445
1、创建目标类 /** * @author 作者 Your-Name: * @version 创建时间：2019年5月31日 上午10:35:08 * 类说明 */ package com.sumeng.aop; /** * @author Administrator * */ public class UserInfo { public void add(){...
通过xml配置aop过程
qq_45888932的博客
01-17 526
使用xml配置aop
15，Spring - aop（基于xml实现aop）
最新发布
w7635122886的博客
01-06 222
基于xml实现aop
spring框架实现aop编程 基于XML使用aop:config标签配置方式实现AOP编程并且测试
_纳川
10-18 281
在Spring框架实现AOP编程可以通过面实现spring提供给我们的接口（MethodBeforeAdvice，ThrowsAdvice，AfterReturningAdvice，MethodInterceptor）去声明声明我们想要的切面，实现AOP编程，这种方法需要给每一个目标对象在xml文件中配置一次， <!-- 配置目标对象 --> <bean id="produc...
Spring之基于XML配置AOP
积跬步，至千里。
08-22 979
Spring AOP即面向切面编程，底层基于动态代理（JDK + CGLIB）实现，要应用于日志记录，性能统计，安全控制,事务处理等方面，实现公共功能性的重复使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值