010Spring之AOP

最新推荐文章于 2024-08-26 11:16:12 发布
最新推荐文章于 2024-08-26 11:16:12 发布
阅读量65 收藏
点赞数
分类专栏： java框架ssm 文章标签： spring java aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44835120/article/details/117674671
版权
本文详细讲解了AOP的概念，包括面向切面编程的原理，如何使用JDK和CGLIB动态代理实现AOP，以及AspectJ的注解和XML配置方式。通过实例演示，展示了如何在Spring框架中配置通知和切点，提升代码复用和灵活性。
摘要由CSDN通过智能技术生成

1、AOP相关概念

1、什么是AOP

（1）面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
（2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能
（3）使用登录例子说明AOP
在这里插入图片描述

2、AOP底层原理

1、AOP底层使用动态代理

有两种情况动态代理

1、第一种有接口情况，使用JDK动态代理

⚫创建接口实现类代理对象，增强类的方法
在这里插入图片描述
使用Proxy类里面的方法创建代理对象
在这里插入图片描述
调用newProxyInstance方法
在这里插入图片描述

方法有三个参数：
第一参数，类加载器
第二参数，增强方法所在的类，这个类实现的接口，支持多个接口
第三参数，实现这个接口InvocationHandler，创建代理对象，写增强的部分
环境搭建
复制demo4重命名为demo5，删除原有的包，保留项目结构如下：
在这里插入图片描述
（1）创建接口，定义方法

package com.francis.spring5.mapper;

/**
 * @author Francis
 * @create 2021-06-07-21:36
 */
public interface UserMapper {
    public int add(int a,int b);
    public String update(String name);
}

（2）创建接口实现类，实现方法

package com.francis.spring5.mapper;

/**
 * @author Francis
 * @create 2021-06-07-21:37
 */
public class UserMapperImpl implements UserMapper{
    @Override
    public int add(int a, int b) {
        return a+b;
    }

    @Override
    public String update(String name) {
        return name;
    }
}

（3）创建代理类

package com.francis.spring5.mapper;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * @author Francis
 * @create 2021-06-07-21:42
 */
public class UserMapperProxy implements InvocationHandler {
    /**1、把需要创建的代理对象传入
     * 有参构造器传入
     */
   private Object object;

    public UserMapperProxy(Object object) {
        this.object = object;
    }

    //增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法之前执行
        System.out.println("增强的方法之前执行"+method.getName()+"传递的参数："+args);

        //被增强的方法执行
        Object result = method.invoke(object, args);

        //方法之后执行
        System.out.println("方法之后执行"+object);
        return result;
    }
}

（4）使用Proxy类创建接口代理对象

package com.francis.spring5.mapper;

import org.junit.Test;

import java.lang.reflect.Proxy;

/**
 * @author Francis
 * @create 2021-06-07-21:45
 */
public class JDKProxyTest {

    @Test
    public void jdkProxyTest(){
        Class [] interfaces={UserMapper.class};
        UserMapperImpl userMapper = new UserMapperImpl();

        UserMapper mapper =(UserMapper) Proxy.newProxyInstance(JDKProxyTest.class.getClassLoader(),
                interfaces,new UserMapperProxy(userMapper) );
        int result = mapper.add(1, 2);
        System.out.println(result);
    }
}

在这里插入图片描述

2、第二种没有接口情况，使用CGLIB动态代理

⚫创建子类的代理对象，增强类的方法
在这里插入图片描述

3、AOP术语

1、连接点

类里面可以被增强的方法，叫做连接点

2、切入点

真正被增强的方法叫做切入点

3、通知
1、通知的含义

实际增强的逻辑部分成为通知，我们也成为增强

2、通知有多种类型

（1）前置通知
在切入点之前执行
（2）后置通知
在切入点之后执行
（3）环绕通知
在切入点前后都执行
（4）异常通知
发生异常时执行，类似于try catch里的catch部分
（5）最终通知
无论如何最终都执行，类似于try catch finally里的finally部分。

4、切面

是一个动作，把通知应用到切入点的过程（即通知与切入点绑定的过程）

4、环境准备

1、Spring框架一般都是基于AspectJ实现AOP操作

（1）AspectJ不是Spring组成部分，独立AOP框架，一般把AspectJ和Spirng框架一起使用，进行AOP操作

2、基于AspectJ实现AOP操作

（1）基于xml配置文件实现
（2）基于注解方式实现（推荐使用）

3、在项目工程里面引入AOP相关依赖

在这里插入图片描述
首先了解一下切入点表达式
（1）切入点表达式的作用：指定哪个类的哪个方法被增强
（2）语法结构：
execution([权限修饰符] [返回类型] [类全路径] [方法名称] ([参数列表]) )
在这里插入图片描述

5、使用AspectJ实现AOP

1、基于注解方式实现（推荐使用）
1、创建被增强的类
package com.francis.spring5.annotation_aop;

import org.springframework.stereotype.Component;

/**
 * @author Francis
 * @create 2021-06-08-11:06
 * 被增强的类
 */
@Component
public class User {
    public void add(){
        System.out.println
                ("user`s add");
    }
}
2、创建增强的类
package com.francis.spring5.annotation_aop;

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

/**
 * @author Francis
 * @create 2021-06-08-11:07
 * 增强的类
 * @Aspect 标志位增强类
 */
@Component
@Aspect
public class UserProxy {
    //配置为前置通知
    @Before(value = "execution(* com.francis.spring5.annotation_aop.User.add(..))")
    public void  before(){
        System.out.println
                ("before method");
    }
    //配置为最终通知，在方法执行之后执行，无论是否发生异常都会执行
    @After(value = "execution(* com.francis.spring5.annotation_aop.User.add(..))")
    public void  after(){
        System.out.println
                ("after method");
    }
    //配置为后置通知，在方法返回结果之后执行，发生异常就不会执行
    @AfterReturning(value = "execution(* com.francis.spring5.annotation_aop.User.add(..))")
    public void  afterReturning(){
        System.out.println
                ("afterReturning method");
    }
    //配置为异常通知
    @AfterThrowing(value = "execution(* com.francis.spring5.annotation_aop.User.add(..))")
    public void  afterThrowing(){
        System.out.println
                ("afterThrowing method");
    }
    //配置为环绕通知
    @Around(value = "execution(* com.francis.spring5.annotation_aop.User.add(..))")
    public void  around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println
                ("环绕之前");
        proceedingJoinPoint.proceed();
        System.out.println
                ("环绕之后");

    }

}
3、进行通知的配置

（1）在spring的配置文件中，开启注解扫描
（2）使用注解创建User和UserProxy对象
（3）在增强的类上面添加注解@Aspect
（4）在配置文件中开启生成代理对象

<?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: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.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--    开启组件臊面-->
    <context:component-scan base-package="com.francis.spring5.annotation_aop"/>
<!--    开启生成代理对象-->
    <aop:aspectj-autoproxy/>

</beans>

测试没有异常的情况
在这里插入图片描述
测试有异常的情况
在这里插入图片描述
细节加强
（1）重用切入点
上面的例子中，每个通知的切入点表达式都是一样了，为了减少代码冗余，我们可以通过配置公共切入点。
在这里插入图片描述

package com.francis.spring5.annotation_aop;

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

/**
 * @author Francis
 * @create 2021-06-08-11:07
 * 增强的类
 * @Aspect 标志位增强类
 */
@Component
@Aspect
public class UserProxy {
    /**
     * 定义公共切入点
     */
    @Pointcut(value = "execution(* com.francis.spring5.annotation_aop.User.add(..))")
    public void pointcutDemo(){

    }
    //配置为前置通知
    @Before(value = "pointcutDemo()")
    public void  before(){
        System.out.println
                ("before method");
    }
    //配置为最终通知，在方法执行之后执行，无论是否发生异常都会执行
    @After(value = "execution(* com.francis.spring5.annotation_aop.User.add(..))")
    public void  after(){
        System.out.println
                ("after method");
    }
    //配置为后置通知，在方法返回结果之后执行，发生异常就不会执行
    @AfterReturning(value = "pointcutDemo()")
    public void  afterReturning(){
        System.out.println
                ("afterReturning method");
    }
    //配置为异常通知
    @AfterThrowing(value = "pointcutDemo()")
    public void  afterThrowing(){
        System.out.println
                ("afterThrowing method");
    }
    //配置为环绕通知
    @Around(value = "pointcutDemo())")
    public void  around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println
                ("环绕之前");
        proceedingJoinPoint.proceed();
        System.out.println
                ("环绕之后");

    }

}

（2）多个增强类对同一个方法进行增强，设置通知的优先级
在这里插入图片描述

package com.francis.spring5.annotation_aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * @author Francis
 * @create 2021-06-08-13:29
 * @Order(1) 数字越小，优先级越高
 */
@Aspect
@Component
@Order(1)
public class PersonProxy {
    @Before(value = "execution(* com.francis.spring5.annotation_aop.User.add(..))")
    public void person(){
        System.out.println("这是person的before增强");
    }
}
2、基于xml配置文件实现
1、创建增强类及被增强类
package com.francis.spring5.xml_aop;

/**
 * @author Francis
 * @create 2021-06-08-13:40
 */
public class Book {
    public void buy(){
        System.out.println("book的buy方法");
    }
}

package com.francis.spring5.xml_aop;

/**
 * @author Francis
 * @create 2021-06-08-13:42
 */
public class BookProxy {
    public void before(){
        System.out.println("代理类的before增强方法");
    }
}
2、在配置文件中创建对象并配置切面
<?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 https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="book" class="com.francis.spring5.xml_aop.Book"/>
    <bean id="bookProxy" class="com.francis.spring5.xml_aop.BookProxy"/>
    <!--配置aop增强-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="buyPointcut" expression=
        "execution(* com.francis.spring5.xml_aop.Book.buy(..))"/>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--增强作用在具体方法上-->
            <aop:before method="before" pointcut-ref="buyPointcut"/>
         </aop:aspect>

    </aop:config>
</beans>

  @Test
    public void annoTest1(){
        ApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
        Book book = context.getBean("book", Book.class);
        book.buy();
    }

在这里插入图片描述
完全注解开发
用配置类来代替配置文件，这里直接给出配置类
在这里插入图片描述

package com.francis.spring5.common.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @author Francis
 * @create 2021-06-08-13:59
 */
@Configuration
@ComponentScan(basePackages = {"com.francis.spring5.annotation_aop"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AopConfig {
}
曳空@竹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringAOP(图文详解)
lhj520cb的博客
07-16 4万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
spring之AOP（动态代理）
09-06
在Spring框架中，AOP（面向切面编程）是一种强大的设计模式，它允许开发者将关注点分离，将横切关注点（如日志、事务管理、权限检查等）与核心业务逻辑解耦。AOP的核心概念是切面、通知、连接点、切入点和织入。在...
细说Spring——AOP详解（AOP概览）
热门推荐
啦啦啦的博客
05-30 53万+
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而...
Spring之AOP的详细讲解
tq02的博客
04-09 3474
本文讲解的是SpringAOP，将切点、切面、通知点，逐步剖析，代码举例，配合理解！
Spring之AOP注解开发
楠黎倾风的博客
11-25 1万+
Spring之AOP注解开发
Spring之AOP日志记录
积跬步，至千里。
10-17 1488
在Java中，可以使用注解和切面技术来实现AOP（Aspect Oriented Programming）。AOP是一种编程范式，它通过将应用程序分解为关注点的模块来提高代码的可维护性和重用性。注解可以用于标记程序元素，例如类、方法和字段，以便切面可以识别和操作这些元素。
Spring之aop注解实现
qq_47455973的博客
02-28 3746
Spring中的AOP1.什么是AOP2.怎么实现AOP# 2.1AOP相关的注解介绍# 2.2实现AOP的xml配置# 2.3实现AOP# 2.4对相同切入点的公共化# 2.5设置多个增强类的优先级 1.什么是AOP Aop是java的spring框架中的一种特性，aop是面向切面编程的缩写，那什么是面向切面编程呢？ 面向切面编程就是，在不对源码进行修改的情况下对源码所实现的功能进行增强。 举例说明 原本一个程序可以实现用户登入的功能，然后我想在这个功能的基础上，加入一个新的功能，就是对用户等级的判断，按
Spring框架之AOP详解
qq_45515347的博客
09-05 1990
Spring AOP 详解，并实现demo
Spring之AOP适配器模式
波波烤鸭的博客
03-06 8363
  Spring架构中涉及了很多设计模式，本文来介绍下Spring中在AOP实现时Adapter模式的使用。AOP本质上是Java动态代理模式的实现和适配器模式的使用，关于这两种设计模式的具体介绍烦请参考我之前的文章 Java代理模式 Java适配器模式(adapter) 文章目录Spring中适配器模式一、AOP案例1.相关依赖2.创建目标对象3.创建通知4.配置文件5.测试二、适配器应用解...
SpringAOP学习--SpringAOP简介及原理
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
spring源码分析之Aop
Evan's Blog ٩(๑❛ᴗ❛๑)۶
11-01 2158
今天读spring源码，读到aop相关内容，在此记录一下，以便以后复习和查阅。 一、spring如何实现Aop 这里简单的说下原理，spring实例化bean要经历一套完整的生命周期，在这个过程中会对要实例化的bean进行各种各样的处理，例如先new对象、进行属性注入、处理循环依赖、处理生命周期回调、实现Aop等等。这些操作实际都是通过spring的后置处理器，也就是通过BeanPostP...
开发工具 spring-aop-4.3.6.RELEASE
05-31
开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE...
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
spring-aop-5.2.0.RELEASE-API文档-中文版.zip
07-13
赠送jar包：spring-aop-5.2.0.RELEASE.jar； 赠送原API文档：spring-aop-5.2.0.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.2.0.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.2.0.RELEASE.pom；...
spring-aop-5.0.10.RELEASE-API文档-中文版.zip
04-23
赠送jar包：spring-aop-5.0.10.RELEASE.jar； 赠送原API文档：spring-aop-5.0.10.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.0.10.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.0.10.RELEASE....
Spring&SpringBoot
qq_53429120的博客
08-21 1104
Bean代指那些被IoC容器管理的对象Before(前置通知):目标对象的方法调用之前触发After(后置通知):目标对象的方法调用之后触发AfterReturning(返回通知):目标对象方法调用返回完成，在返回结果值之后触发AfterThrowing(异常通知):目标对象方法运行中抛出异常后触发Aroud()环绕通知:在任意的目标对象的方法调用前后触发，甚至不调用目标对象的方法。
springboot中interceptor拦截器匹配URL源码
SmileAssassn的博客
08-23 273
看到在这里出现了拦截器，那么就在这个类里面往上找，打断点慢慢找，看看是在哪一步出现了拦截器。最后找到这里进行了拦截器的匹配模式。上一篇文章我们找到了filter过滤器的匹配源码，这次我们来找一下interceptor的匹配源码。直接源码里面备注里面就有写，那么两个都打上断点，调试一下即可。也可以用我之前写的文章，通过反编译jar包搜关键字的方式。接着翻调用链，看看从哪里开始出现拦截器的。同样先打断点看一下调用链。
Springboot 图片
jonathan_joestar的博客
08-21 284
所以 url是这个的时候 http://127.0.0.1:9100/api/staticfiles/image/dd56a59d-da84-441a-8dac-1d97f9e42090.jpeg。因为 server.servlet.context-path: /api。配置代码的前面的 /api 是不要写的。Springboot 图片。
Spring IoC&DI
最新发布
2301_79288225的博客
08-26 163
我们发现了⼀个规律，通⽤程序的实现代码，类的创建顺序是反的，传统代码是 Car 控制并创建了Framework，Framework 创建并创建了 Bottom，依次往下，⽽改进之后的控制权发⽣的反转，不再是使⽤⽅对象创建并控制依赖对象了，⽽是把依赖对象注⼊将当前对象中，依赖对象的控制权不再由当前类控制了.在上⾯的程序中, 我们是根据轮⼦的尺⼨设计的底盘，轮⼦的尺⼨⼀改，底盘的设计就得修改. 同样因为我们是根据底盘设计的⻋⾝，那么⻋⾝也得改，同理汽⻋设计也得改, 也就是整个设计⼏乎都得改。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值