dubbo spi 的应用指南

于 2024-08-30 18:18:53 发布
阅读量519 收藏 6
点赞数 13
文章标签： dubbo java 架构 spring 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44550507/article/details/141691158
版权

文章目录

前言

SPI全称为Service Provider Interface，是一种服务发现机制。在Dubbo中，SPI机制被广泛应用于加载和扩展各种组件，如协议（Protocol）、负载均衡（LoadBalance）、注册中心（Registry）等。Dubbo并未直接使用Java原生的SPI机制，而是对其进行了增强，以满足更复杂和灵活的需求。

Dubbo 加载扩展的整个流程如下：
在这里插入图片描述

一、配置文件目录

  • META-INF/services/：
    用途：这个目录下的SPI配置文件主要用于兼容JDK原生的SPI机制。

  • META-INF/dubbo/：
    用途：这个目录专门用于存放用户自定义的Dubbo SPI配置文件，开发应用的存放目录。格式为文件名为全路径名了，内容采用键值对（Key-Value，简称KV）的格式，其中key被称为扩展名（ExtensionName），value则是对应的具体实现类。
    例如
    目录：META-INF/dubbo/org.apache.dubbo.rpc.Protocol
    内容：http=com.sjl.HttpProtocol

  • META-INF/dubbo/internal/：
    用途：这个目录用于存放Dubbo内部使用的SPI配置文件

二、标准SPI

// "one" 是默认拓展实现类
@SPI("one")
public interface BaseSpi {

    void execute();

}

spi实现

public class OneBaseSpi implements BaseSpi{

    @Override
    public void execute() {
        System.out.println("one base spi");
    }

}

public class TwoBaseSpi implements BaseSpi{

    @Override
    public void execute() {
        System.out.println("two base spi");
    }
    
}

配置
在这里插入图片描述

one=org.sjl.spi.base.OneBaseSpi
two=org.sjl.spi.base.TwoBaseSpi

测试

@Component
public class BaseTest implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args){
        ExtensionLoader<BaseSpi> extensionLoader = ExtensionLoader.getExtensionLoader(BaseSpi.class);
        // 获取key为 one 的拓展实现类
        BaseSpi one = extensionLoader.getExtension("one");
        one.execute();
        // 获取key为 two 的拓展实现类
        BaseSpi two = extensionLoader.getExtension("two");
        two.execute();
        // 获取 spi 注解上的默认拓展实现类
        BaseSpi def = extensionLoader.getDefaultExtension();
        def.execute();
    }

}

测试结果
在这里插入图片描述

三、自适应SPI（Adaptive SPI）

1、@Adaptive说明

1.1、方法级别的注解：

  • @Adaptive 注解标记在接口方法上时，Dubbo 会在初始化扩展点时自动生成一个动态代理类，这个代理类会包含被 @Adaptive 注解修饰的方法的代理实现。这些代理实现会根据运行时传入的参数（URL中的参数）来动态选择并调用合适的实现类。URL可以直接作为入参，或者作为入参的入参如org.apache.dubbo.rpc.Invoker
  • @Adaptive 注解中的 String[] value()
    • 没有填写时，将接口名转换为小写并使用点（.）分隔，然后从 URL 中查找对应的参数值，例如org.sjl.spi.Adaptive.AdaptiveSpi，则对应的key为adaptive.spi
    • 填写时，则通过value的值作为key
      • value数组等于1
        例如@Adaptive(“ADP”)
        则从url的取值为
        url.getParameter(“ADP”);
      • value数组大于1
        例如@Adaptive(“ADP”,“DDD”)
        则从url的取值为
        url.getParameter(“ADP”, url.getParameter(“DDD”));

1.2、 类级别的注解：

  • @Adaptive 注解标记在类上时，该类通常会被直接作为自适应实现类来进行代理。

2、@Adaptive作用在类上

spi接口

@SPI("one")
public interface AdaptiveClassSpi {

    void execute(String name);

}

spi实现类

public class OneAdaptiveClassSpi implements AdaptiveClassSpi{

    public void execute(String name){
        System.out.println("One Adaptive Class Spi");
    }

}

public class TwoAdaptiveClassSpi implements AdaptiveClassSpi{

    public void execute(String name){
        System.out.println("Two Adaptive Class Spi");
    }

}

自定义代理类

@Adaptive
public class AdaptiveClassSpiProxy implements AdaptiveClassSpi {

    private static final ExtensionLoader<AdaptiveClassSpi> extensionLoader = ExtensionLoader.getExtensionLoader(AdaptiveClassSpi.class);

    public void execute(String name) {
        AdaptiveClassSpi adaptiveClassSpi = null;
        if (StringUtils.isBlank(name) || !extensionLoader.hasExtension(name)) {
            adaptiveClassSpi = extensionLoader.getDefaultExtension();
        } else {
            adaptiveClassSpi = extensionLoader.getExtension(name);
        }
        adaptiveClassSpi.execute(name);
    }

}

配置

one=org.sjl.spi.Adaptive.OneAdaptiveClassSpi
two=org.sjl.spi.Adaptive.TwoAdaptiveClassSpi
adaptive=org.sjl.spi.Adaptive.AdaptiveClassSpiProxy

测试

@Component
public class AdaptiveClassSpiTest implements ApplicationRunner {

    private static final ExtensionLoader<AdaptiveClassSpi> adaptiveClassSpi = ExtensionLoader.getExtensionLoader(AdaptiveClassSpi.class);

    @Override
    public void run(ApplicationArguments args) throws Exception {
        AdaptiveClassSpi adaptiveExtension = adaptiveClassSpi.getAdaptiveExtension();
        adaptiveExtension.execute("one");
        adaptiveExtension.execute("two");
    }

}

结果
在这里插入图片描述

3、@Adaptive作用在方法上

spi接口

@SPI("one")
public interface AdaptiveSpi {

    public static final String ADP = "ADP";

    @Adaptive(ADP)
    void execute(URL url);

}

spi实现类

public class OneAdaptiveSpi implements AdaptiveSpi{

    public void execute(URL url){
        System.out.println("One Adaptive Spi");
    }

}

public class TwoAdaptiveSpi implements AdaptiveSpi{

    public void execute(URL url){
        System.out.println("Two Adaptive Spi");
    }

}

配置

one=org.sjl.spi.Adaptive.OneAdaptiveSpi
two=org.sjl.spi.Adaptive.TwoAdaptiveSpi

测试

@Component
public class AdaptiveSpiTest implements ApplicationRunner {

    private static final ExtensionLoader<AdaptiveSpi> extensionLoader = ExtensionLoader.getExtensionLoader(AdaptiveSpi.class);

    @Override
    public void run(ApplicationArguments args) throws Exception {
    	// 获取自适应代理类 AdaptiveSpi$Adaptive
        AdaptiveSpi adaptiveExtension = extensionLoader.getAdaptiveExtension();
        URL url = buildURL();
        // 没有对应ADP参数，则取默认spi
        adaptiveExtension.execute(url);

        URL url1 = buildURL().addParameter(AdaptiveSpi.ADP, "two");
        // 取key为ADP的参数的spi
        adaptiveExtension.execute(url1);
    }

    public static URL buildURL() {
        URL url = new URL(null, "127.0.0.1", 8090);
        return url;
    }
}

生成的代理类

public class AdaptiveSpi$Adaptive implements org.sjl.spi.Adaptive.AdaptiveSpi {
    public void execute(org.apache.dubbo.common.URL arg0) {
        if (arg0 == null) throw new IllegalArgumentException("url == null");
        org.apache.dubbo.common.URL url = arg0;
        String extName = url.getParameter("ADP", "one");
        if (extName == null)
            throw new IllegalStateException("Failed to get extension (org.sjl.spi.Adaptive.AdaptiveSpi) name from url (" + url.toString() + ") use keys([ADP])");
        ScopeModel scopeModel = ScopeModelUtil.getOrDefault(url.getScopeModel(), org.sjl.spi.Adaptive.AdaptiveSpi.class);
        org.sjl.spi.Adaptive.AdaptiveSpi extension = (org.sjl.spi.Adaptive.AdaptiveSpi) scopeModel.getExtensionLoader(org.sjl.spi.Adaptive.AdaptiveSpi.class).getExtension(extName);
        extension.execute(arg0);
    }
}

结果
在这里插入图片描述

三、激活SPI（Activate SPI）

Dubbo 的激活点机制基于 @Activate 注解完成，可以用于实现根据条件加载多个 SPI 激活点实现类。

  • @Activate 注解：
    • String[] group() default {}：
      • getActivateExtension 接口传入的 group 参数为 null 或者 length==0，表示不限制 group；
      • @Activate 注解中的参数 groups 是否包含传入的限制参数 group，如果包含，则允许加载当前的 SPI 实现。
    • String[] value() default {}：
      • @Activate 注解没有 value() 属性，则默认所有值不包括空；
      • URL#getParameters() 中的一个参数名，则认为默认是允许当前的 SPI 实现加载的
    • int order() default 0;
      • 表示加载顺序，数字越小越靠前
        spi接口
@SPI
public interface ActivateSpi {

    void execute();

}

spi实现

@Activate(value = "one",group = {"active","active2"}, order = 1)
public class OneActivateSpi implements ActivateSpi{

    @Override
    public void execute() {
        System.out.println("One Activate Spi");
    }
}

@Activate(value = "two",group = "active", order = 2)
public class TwoActivateSpi implements ActivateSpi{

    @Override
    public void execute() {
        System.out.println("Two Activate Spi");
    }
}

@Activate(group = "active", order = 3)
public class ThreeActivateSpi implements ActivateSpi{

    @Override
    public void execute() {
        System.out.println("Three Activate Spi");
    }
}

@Activate(order = 4, value = "four")
public class FourActivateSpi implements ActivateSpi{

    @Override
    public void execute() {
        System.out.println("Four Activate Spi");
    }
}

配置

one=org.sjl.spi.Activate.OneActivateSpi
two=org.sjl.spi.Activate.TwoActivateSpi
three=org.sjl.spi.Activate.ThreeActivateSpi
four=org.sjl.spi.Activate.FourActivateSpi

测试

@Component
public class ActiveSpiTest implements ApplicationRunner {

    private static final ExtensionLoader<ActivateSpi> extensionLoader = ExtensionLoader.getExtensionLoader(ActivateSpi.class);

    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("仅指定 group");
        String group = "active";
        // 只会获取到仅设置了group为active 且 value值不填写的
        List<ActivateSpi> activateSpiList = extensionLoader.getActivateExtension(buildURL(), new String[]{}, group);
        activateSpiList.forEach(ActivateSpi::execute);

        System.out.println("指定 group 和 value");
         // 获取到仅设置了group为active 且 value值不填写的或者value为one的
        List<ActivateSpi> activateSpiList1 = extensionLoader.getActivateExtension(buildURL(), new String[]{"one"}, group);
        activateSpiList1.forEach(ActivateSpi::execute);

        System.out.println("指定 value");
        // 获取到设置了group的所有值或者不设置  且 value需要等于four或者不填的
        List<ActivateSpi> activateSpiList2 = extensionLoader.getActivateExtension(buildURL(), new String[]{"four"}, null);
        activateSpiList2.forEach(ActivateSpi::execute);

    }

    public static URL buildURL() {
        URL url = new URL(null, "127.0.0.1", 8090);
        return url;
    }
}

测试结果
在这里插入图片描述

四、Dubbo AOP

AOP 增强，通常以Wrapper结尾，且需要实现如下协议

  • wrapper 类也必须实现 SPI 接口
  • wrapper 类必须有一个含有单个 SPI 参数的构造器

针对上面的 AdaptiveSpi ，我们增加AOP强化功能
增强类

public class AdaptiveSpiWrapper implements AdaptiveSpi {

    private AdaptiveSpi adaptiveSpi;

    public AdaptiveSpiWrapper(AdaptiveSpi adaptiveSpi){
        this.adaptiveSpi = adaptiveSpi;
    }

    @Override
    public void execute(URL url) {
        System.out.println("@AOP(order = 100)");
        adaptiveSpi.execute(url);
    }

}

public class AdaptiveSpiWrapper2 implements AdaptiveSpi {

    private AdaptiveSpi adaptiveSpi;

    public AdaptiveSpiWrapper2(AdaptiveSpi adaptiveSpi){
        this.adaptiveSpi = adaptiveSpi;
    }

    @Override
    public void execute(URL url) {
        System.out.println("@AOP(order = -100)");
        adaptiveSpi.execute(url);
    }

}

配置

  • 配置的先后顺序，代表AOP的先后顺序
one=org.sjl.spi.Adaptive.OneAdaptiveSpi
two=org.sjl.spi.Adaptive.TwoAdaptiveSpi
wrapper2=org.sjl.spi.aop.AdaptiveSpiWrapper2
wrapper=org.sjl.spi.aop.AdaptiveSpiWrapper

测试

@Component
public class AdaptiveSpiTest implements ApplicationRunner {

    private static final ExtensionLoader<AdaptiveSpi> extensionLoader = ExtensionLoader.getExtensionLoader(AdaptiveSpi.class);

    @Override
    public void run(ApplicationArguments args) throws Exception {
        AdaptiveSpi adaptiveExtension = extensionLoader.getAdaptiveExtension();
        URL url = buildURL();
        // 此时的链路为 AdaptiveSpiWrapper2 -> AdaptiveSpiWrapper -> OneAdaptiveSpi
        adaptiveExtension.execute(url);

        URL url1 = buildURL().addParameter(AdaptiveSpi.ADP, "two");
        // 此时的链路为 AdaptiveSpiWrapper2 -> AdaptiveSpiWrapper -> TwoAdaptiveSpi
        adaptiveExtension.execute(url1);
    }

    public static URL buildURL() {
        URL url = new URL(null, "127.0.0.1", 8090);
        return url;
    }
}

结果
在这里插入图片描述

五、Dubbo IOC

Dubbo IOC 的实现机制

  • setter 方法注入依赖。
  • 注入为spring bean 或者 自适应扩展点

针对上面的代码，在OneBaseSpi 依赖注入 AdaptiveSpi

public class OneBaseSpi implements BaseSpi{

    private AdaptiveSpi adaptiveSpi;

    public void setAdaptiveSpi(AdaptiveSpi adaptiveSpi) {
        this.adaptiveSpi = adaptiveSpi;
    }

    @Override
    public void execute() {
        adaptiveSpi.execute(buildURL());
        System.out.println("one base spi");
    }

    public static URL buildURL() {
        URL url = new URL(null, "127.0.0.1", 8090);
        return url;
    }

}

配置保存不变

one=org.sjl.spi.base.OneBaseSpi

测试

@Component
public class BaseTest implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args){
        ExtensionLoader<BaseSpi> extensionLoader = ExtensionLoader.getExtensionLoader(BaseSpi.class);
        BaseSpi one = extensionLoader.getExtension("one");
        one.execute();
    }

}

结果
在这里插入图片描述

DEARM LINER
关注
  • 13
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Apache Dubbo SPI 扩展模块指南
gitblog_01123的博客
08-07 399
Apache Dubbo SPI 扩展模块指南 dubbo-spi-extensionsApache Dubbo SPI Extensions项目地址:https://gitcode.com/gh_mirrors/du/dubbo-spi-extensions 本指南旨在帮助开发者深入了解并快速上手 Apache Dubbo SPI Extensions 项目。我们将从该项目的基础结构入手，逐步...
Dubbo SPI机制详解
weixin_39082432的博客
05-09 1890
什么是SPI？ 扩展点 Dubbo作用灵活的框架，并不会强制所有用户都一定使用Dubbo提供的某些架构。例如注册中心（Registry），Dubbo提供了zk和redis，但是如果我们更倾向于其他的注册中心的话，我们可以替换掉Dubbo提供的注册中心。针对这种可被替换的技术实现点我们称之为扩展点，类似的扩展点有很多，例如Protocol，Filter，Loadbalance等等。 Wrapper Dubbo在加载某个接口的扩展类时候，如果某个实现中有一个拷贝类构造函数，那么该接口实现就是该接口的包装类，
Dubbo学习笔记（四）——负载均衡与SPI机制
2301_81298401的博客
12-20 900
目录一、SPI 是什么？二、Dubbo SPI三、dubbo负载均衡策略四、详解dubbo负载均衡实现原理4.1 环境搭建4.2 代码执行流程分析参考文章：阿里面试真题：Dubbo的SPI机制_三太子敖丙博客-CSDN博客dubbo（二）dubbo spi机制_dubbo spi-CSDN博客核心技术概念-SPI (baidu.com)Dubbo源码解析-——SPI机制_dubbo的spi-CSDN博客Dubbo负载均衡的源码流程(2022.5.30)_dubbo3 负载均衡调用时机源码-CSDN博客Jav
Dubbo 技术学习指南：深度探索分布式服务框架的精髓
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
04-21 2万+
Dubbo技术栈深度广博，学习过程中应理论与实践相结合，通过动手搭建示例项目、参与真实项目开发，逐步将所学知识转化为实际生产力。随着对Dubbo理解的加深，您将能更好地驾驭这一强大的分布式服务框架，为构建高效、稳定、易维护的微服务体系打下坚实基础。
dubbo-用户指南
02-01
《Dubbo用户指南》是针对Java开发者的一份详尽教程，它主要涵盖了如何使用Dubbo这一高性能、轻量级的分布式服务框架。Dubbo由阿里巴巴开源，旨在解决大型分布式系统中的服务治理问题，提高系统的可扩展性和灵活性。...
dubbo官方权威指南，非扫描版
01-21
《Dubbo官方权威指南》是一本深度解析Dubbo框架的权威著作，旨在帮助开发者深入了解和高效使用这个流行的Java微服务框架。Dubbo是由阿里巴巴开源的一个高性能、轻量级的服务治理框架，它专注于服务调用、服务注册与...
Dubbo用户指南
04-04
【Dubbo用户指南】是针对阿里巴巴开源的分布式服务框架Dubbo的重要参考资料，它详细阐述了如何使用和配置Dubbo来构建高性能、高可用的服务。在阿里巴巴宣布不再维护官方网站后，这个PDF版本的用户指南显得尤为珍贵，...
dubbo开发者指南(非扫描有完整目录).pdf
09-19
对于监控中心和注册中心的扩展，Dubbo也提供了一套完整的开发和使用指南，方便用户对服务的使用情况进行监控和管理。 文档还涉及了与日常开发紧密相关的各种组件和工具的使用，如Maven的使用、开发指南的翻译工作、...
dubbo开发指南
12-21
Dubbo致力于让分布式应用开发更加简单，它通过封装底层网络通信细节，让开发者更专注于业务逻辑的开发。Dubbo主要包含以下几个核心功能： 1. 高性能RPC远程服务调用：Dubbo支持多种协议，如Hessian、JSON-RPC、XML-...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 3477
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 3475
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 3824
linux上datax 安装以及使用
《深入理解 Java 中的适配器模式》
最新发布
面团到油条的成长日记
08-29 1952
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
操作系统原子操作
zzt_is_me的博客
08-28 2072
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 1701
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 1199
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于jenkins部署maven项目
静水深流
08-26 1968
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
死锁及其产生条件
秋夫人
08-26 841
死锁是指两个或多个线程（或进程）互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。这是并发编程中的一个常见问题，可能会导致系统部分或完全停止响应。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值