AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Spring Aop 底层责任链思路实现-springaopdi-ceng-ze-ren-lian-si-lu-shi-xian

2024-03-27 89
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Spring Aop 底层责任链思路实现-springaopdi-ceng-ze-ren-lian-si-lu-shi-xian

title: Spring Aop 底层责任链思路实现
date: 2023-02-05 18:13:35.713
updated: 2023-02-05 18:13:35.713
url: /archives/springaopdi-ceng-ze-ren-lian-si-lu-shi-xian
categories:
tags: Java | Spring源码

动手AOP责任链实现

简单了解 AOP

Spring 的两个重要特性之一  AOP 面向切面编程

它的作用简单来说就是解耦 可以通过代理类的方式实现在不改变类本身的代码的情况下做到功能上的增强 , 了解它能做些什么我们就可以去思考怎么去实现它 , 这里涉及到责任链模式 (后续在细说) 。

想要去实现简单的aop 我们至少要做到 :

  • 拥有目标类
  • 动态代理目标类
  • 自定义通知方法

在实现aop 之前呢 我们需要简单复习一些前置知识 在复习之前 确认使用的依赖和版本 避免demo出现意外的bug

Java版本 ： 1.8

Maven 版本 : 3.6.x

依赖

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

动态代理(代理目标类)

了解代理，我们需要复习一下代理的知识。

目前来看 代理分为两种 ，用文字就可以很简单的讲述静态代理和动态代理。

  • 静态代理可以实现代理 但是受限制于抽象类，无法去代理抽象类之外的对象
  • 动态代理依赖反射机制 可以实现对任何类的代理

创建目标类

我们就用Userservice 来作为我们的代理目标类

public class UserService {
    
    public Object insert  ()
    {
        System.out.println("==插入用户成功==");
        return "user insert ok";
    }
    
}

创建代理工厂

这里我们使用cglib 来作为动态代理的方式， 其实通过实现动态代理的支持类我们就可以实现简单的 aop 增强 ，

代码案例

public class ProxyFactory implements MethodInterceptor {
    private Object target;
    public UserService getProxy(Object target){
        //被代理对象
        this.target = target;
        //cglib 生成代理对象
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(target.getClass());
        //设置回调
        enhancer.setCallback(this);
        //设置类加载器
        enhancer.setClassLoader(target.getClass().getClassLoader());
        //生成代理对象
        return (UserService)enhancer.create();
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //执行目标方法
        Object result = null;
        try {
            //前置通知
            System.out.println("前置通知");
             result = method.invoke(target, objects);
            //    返回通知
            System.out.println("返回通知");
        } catch (Throwable e) {
            //异常通知
            System.out.println("异常通知");
            throw new RuntimeException(e);
        } finally {
        //    后置通知
            System.out.println("后置通知");
        }
        return result;
    }
}

测试

public class Run {
    public static void main(String[] args) {
        UserService userService = new UserService();
        userService.insert();
        UserService userService1 = new ProxyFactory().getProxy(userService);
        userService1.insert();
    }
}

只要我们在 标有注释的地方添加代码 是不是简单的切面增强就成了 ，这个时候就会有一个需要思考的问题， 想想我们在Spring 中使用的AOP，在标注切面和增强注解的情况下，Spring才帮我们去实现切面增强 。

所以到这里才是刚刚开始 ，我们使用AOP 的本意是什么 解耦 如果想上面案例这样写的话 岂不是掩耳盗铃， 本类解耦了 代理工厂耦合又高了起来 完全没有达到效果 所以接下来 我们要去解决这个问题

  • 提供灵活性
  • 解耦合
  • 是不是可以使用设计模式来解决问题呢

责任链模式

我们希望使用设计模式来增加我们自己demoAOP 的 灵活性，这里简单的介绍一下责任链模式

为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

PS： 递归

那我们实现责任链模式的结构是什么呢？

这里我们实现前置增强来演示 责任链模式的上手思路

责任链

我们用递归的方式来做通知的不断调用

public class Chian {
    //记录index下标
    private int index=  -1;
    private List<BaseAdvice> adviceList;
    public Chian(List<BaseAdvice> adviceList) {
        this.adviceList = adviceList;
    }
    public Object proeccd() throws Throwable{
        if(index == adviceList.size()-1){
            System.out.println("==执行目标方法==");
            return null;
        }
        return  adviceList.get(++index).execute(this);
    }
}

增强通知基类

public abstract class BaseAdvice {
    public abstract Object execute(Chian chian) throws Throwable;
}

前置增强类

public class BeforeAdvice extends BaseAdvice{
    @Override
    public Object execute(Chian chian) throws Throwable {
        /*
        * 只做逻辑增强
        * 如果还有继续调用链的下一个通知
        * */
        System.out.println("前置通知");
        //调用链通知
        return   chian.proeccd();
    }
}

测试

public static void main(String[] args) throws Throwable {
     List<BaseAdvice> adviceList = new ArrayList<>();
    adviceList.add(new BeforeAdvice());
    Chian chian = new Chian(adviceList);
    chian.proeccd();
}

可以看出来结果是与之前的代理方法结果是一致的，通过链式调用+递归来完成目标解耦并且增加灵活性

实现AOP

增强实现

四种增强 这里没有实现环绕增强，因为环绕相当于是其他增强的组合

基类

public abstract class BaseAdvice {
    public abstract Object execute(Chian chian) throws Throwable;
}

四种增强类

前置增强

public class BeforeAdvice extends BaseAdvice{
    @Override
    public Object execute(Chian chian) throws Throwable {
        /*
        * 只做逻辑增强
        * 如果还有继续调用链的下一个通知
        * */
        System.out.println("前置通知(责任链)");
        //调用链通知
        return   chian.proeccd();
    }
}

后置增强

public class AfterAdvice extends BaseAdvice{
    @Override
    public Object execute(Chian chian) throws Throwable {
        try {
            return chian.proeccd();
        } finally {
            System.out.println("后置增强");
        }
    }
}

异常处理增强

public  class ThrowAdvice extends  BaseAdvice{
    @Override
    public Object execute(Chian chian) throws Throwable {
        try {
            return chian.proeccd();
        } catch (Throwable e) {
            System.out.println("异常通知");
            throw new RuntimeException(e);
        }
    }
}

返回处理增强通知

public class ReturnAdvice extends BaseAdvice{
    @Override
    public Object execute(Chian chian) throws Throwable {
        //如果没有异常就走返回通知
        Object value = chian.proeccd();
        System.out.println("返回通知");
            return value;
    }
}

责任链实现

用链表+递归实现责任链，用链表数据结构的特点 来节点调节点执行增强

public class Chian {
    //记录index下标
    private int index=  -1;
    private List<BaseAdvice> adviceList;
    //目标方法
    private Method method;
    //方法参数
    private  Object[] args;
    //目标对象
    private  Object target;
    public Chian(List<BaseAdvice> adviceList) {
        this.adviceList = adviceList;
    }
    public Chian(List<BaseAdvice> adviceList, Method method, Object[] args, Object target) {
        this.adviceList = adviceList;
        this.method = method;
        this.args = args;
        this.target = target;
    }
    public Object proeccd() throws Throwable{
        if(index == adviceList.size()-1){
            return method.invoke(args,target);
        }
        return  adviceList.get(++index).execute(this);
    }
}

代理类实现

public class ProxyFactoryAddChian implements MethodInterceptor {
    private Object target;
    private List<BaseAdvice> adviceList;
    public ProxyFactoryAddChian() {
        adviceList = new ArrayList<>();
        adviceList.add(new BeforeAdvice());
        adviceList.add(new ReturnAdvice());
        adviceList.add(new AfterAdvice());
        adviceList.add(new ThrowAdvice());
    }
    public UserService getProxy(Object target){
        //被代理对象
        this.target = target;
        //cglib 生成代理对象
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(target.getClass());
        //设置回调
        enhancer.setCallback(this);
        //设置类加载器
        enhancer.setClassLoader(target.getClass().getClassLoader());
        //生成代理对象
        return (UserService)enhancer.create();
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //在生产代理的时候就把链设置好
        Chian chian = new Chian(adviceList,method,objects,target);
        return chian.proeccd();
    }
}

测试

public class Run {
    public static void main(String[] args) throws Throwable {
        UserService userService = new UserService();
        //userService.insert();
        UserService userService1 = new ProxyFactoryAddChian().getProxy(userService);
        userService1.insert("编程导航小冷Demo");
    }
}

总结

实现增强功能其实我们就是将输出语句的位置都换成想要实现的代码就可以了，可能看起来有些疑问 ，这和spring的AOP并不是完全像，那是因为 AOP 有部分是有ioc的参与的 但是很巧，我们之前实现过ioc

如果这个系列更新的还好的话 之后可以尝试做个小型的Spring。 和小冷一起读spring源码在去根据自己想想怎么用自己的思路去实现。

那么这次的责任链动手实践 我们都学到了什么呢 ？

  • 责任链模式的应用
  • 递归的运用
  • 学习到类优秀框架源码的思路
  • 获得一个半成品的aopdemo

希望大伙可以继续观看小冷的技术文章 一起进步 你们的观看可以给予小冷莫大的鼓励

谢谢观看 请期待下一篇

文章标签：
Java
Spring
设计模式
Maven
关键词：
Spring AOP
aop责任链
Cool架构
目录
相关文章
互联网课堂
|
2月前
|
XML Java 数据安全/隐私保护
Spring Aop该如何使用
本文介绍了AOP（面向切面编程）的基本概念和术语，并通过具体业务场景演示了如何在Spring框架中使用Spring AOP。文章详细解释了切面、连接点、通知、切点等关键术语，并提供了完整的示例代码，帮助读者轻松理解和应用Spring AOP。
互联网课堂
56 2
Spring Aop该如何使用
一位隐者
|
2月前
|
监控 安全 Java
什么是AOP？如何与Spring Boot一起使用？
什么是AOP？如何与Spring Boot一起使用？
一位隐者
61 5
潇洒洒
|
2月前
|
Java 开发者 Spring
深入解析：Spring AOP的底层实现机制
在现代软件开发中，Spring框架的AOP（面向切面编程）功能因其能够有效分离横切关注点（如日志记录、事务管理等）而备受青睐。本文将深入探讨Spring AOP的底层原理，揭示其如何通过动态代理技术实现方法的增强。
潇洒洒
72 8
游客fmoyiwnvddywe
|
2月前
|
Java 开发者 Spring
Spring AOP 底层原理技术分享
Spring AOP（面向切面编程）是Spring框架中一个强大的功能，它允许开发者在不修改业务逻辑代码的情况下，增加额外的功能，如日志记录、事务管理等。本文将深入探讨Spring AOP的底层原理，包括其核心概念、实现方式以及如何与Spring框架协同工作。
游客fmoyiwnvddywe
67 6
张志凌
|
2月前
|
XML 监控 安全
深入调查研究Spring AOP
【11月更文挑战第15天】
张志凌
47 5
最好zzz
|
2月前
|
Java 开发者 Spring
Spring AOP深度解析：探秘动态代理与增强逻辑
Spring框架中的AOP（Aspect-Oriented Programming，面向切面编程）功能为开发者提供了一种强大的工具，用以将横切关注点（如日志、事务管理等）与业务逻辑分离。本文将深入探讨Spring AOP的底层原理，包括动态代理机制和增强逻辑的实现。
最好zzz
46 4
砖业洋__
|
3月前
|
存储 缓存 Java
Spring高手之路23——AOP触发机制与代理逻辑的执行
本篇文章深入解析了Spring AOP代理的触发机制和执行流程，从源码角度详细讲解了Bean如何被AOP代理，包括代理对象的创建、配置与执行逻辑，帮助读者全面掌握Spring AOP的核心技术。
砖业洋__
55 3
Spring高手之路23——AOP触发机制与代理逻辑的执行
进步`于辰
|
2月前
|
Java Spring
[Spring]aop的配置与使用
本文介绍了AOP（面向切面编程）的基本概念和核心思想。AOP是Spring框架的核心功能之一，通过动态代理在不修改原代码的情况下注入新功能。文章详细解释了连接点、切入点、通知、切面等关键概念，并列举了前置通知、后置通知、最终通知、异常通知和环绕通知五种通知类型。
进步`于辰
42 1
杀死一只知更鸟debug
|
4月前
|
设计模式 Java 测试技术
spring复习04,静态代理动态代理,AOP
这篇文章讲解了Java代理模式的相关知识，包括静态代理和动态代理（JDK动态代理和CGLIB），以及AOP（面向切面编程）的概念和在Spring框架中的应用。文章还提供了详细的示例代码，演示了如何使用Spring AOP进行方法增强和代理对象的创建。
杀死一只知更鸟debug
47 1
spring复习04,静态代理动态代理,AOP
蓝易云
|
2月前
|
安全 Java 测试技术
Java开发必读，谈谈对Spring IOC与AOP的理解
Spring的IOC和AOP机制通过依赖注入和横切关注点的分离，大大提高了代码的模块化和可维护性。IOC使得对象的创建和管理变得灵活可控，降低了对象之间的耦合度；AOP则通过动态代理机制实现了横切关注点的集中管理，减少了重复代码。理解和掌握这两个核心概念，是高效使用Spring框架的关键。希望本文对你深入理解Spring的IOC和AOP有所帮助。
蓝易云
44 0

热门文章

最新文章

  • 1
    Spring Cloud Alibaba：一站式微服务解决方案
  • 2
    详解Spring Batch：在Spring Boot中实现高效批处理
  • 3
    从单体到微服务：如何借助 Spring Cloud 实现架构转型
  • 4
    深入 Spring Cloud Gateway 过滤器
  • 5
    使用 Spring Boot 执行数据库操作：全面指南
  • 6
    什么是JWT？如何使用Spring Boot Security实现它？
  • 7
    Spring MVC中的请求映射：@RequestMapping注解深度解析
  • 8
    【SpringFramework】Spring初体验
  • 9
    利用Spring Cloud Gateway Predicate优化微服务路由策略
  • 10
    京东面试：聊聊Spring事务？Spring事务的10种失效场景？加入型传播和嵌套型传播有什么区别？
  • 1
    Spring高手之路18——从XML配置角度理解Spring AOP
    101
  • 2
    AOP&事务
    58
  • 3
    Spring 项目如何使用AOP
    73
  • 4
    Spring5深入浅出篇:基于注解实现的AOP
    235
  • 5
    【AOP入门案例深解析】
    77
  • 6
    Spring AOP的切点是通过使用AspectJ的切点表达式语言来定义的。
    80
  • 7
    自定义注解,aop实现注解锁
    54
  • 8
    如何在Spring AOP中定义和应用通知？
    67
  • 9
    在Spring框架中，IoC和AOP是如何实现的？
    90
  • 10
    【Spring系列笔记】AOP
    107

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第四阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)