Dubbo-Java SPI与Dubbo SPI

最新推荐文章于 2023-12-29 21:43:24 发布
最新推荐文章于 2023-12-29 21:43:24 发布
阅读量439 收藏 4
点赞数 2
分类专栏： Dubbo 文章标签： Dubbo SPI ExtensionLoader IOC AOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hosaos/article/details/102753458
版权

文章目录

什么是SPI

SPI全称Service Provider Interface，在面向的对象的设计里，不同模块之间推崇面向接口编程，不建议在模块中对实现类进行硬编码。一旦代码里涉及具体的实现类，就违反了可拔插的原则，如果需要替换一种实现，就需要修改代码。SPI使得程序能在ClassPath路径下的META-INF/services文件夹查找接口的实现类，自动加载文件里所定义的实现类。

使用场景

  • 数据库驱动java.sql.Driver，Mysql，Oracle都有自己的驱动实现jar包，只需引入不同的jar包即可加载不同的数据库驱动，例如mysql-connector-java中，其META-INF/services下制定了mysql驱动的实现类
    在这里插入图片描述

  • Dubbo中针对Java SPI做了一层封装，Dubbo SPI更加灵活、高效。如Dubbo SPI使用在根据URL中指定的协议(dubbo、thrift、redis)来动态指定协议，根据URL中指定loadBalance算法来指定特定的负载均衡实现

下面以实例来说明JAVA SPI使用及Dubbo SPI原理

Java SPI

假设定义一个接口ISpiDemoService如下

public interface ISpiDemoService {
    void sayHello();
}

Demo

定义两个实现类

JavaSpiImp1

public class JavaSpiImp1 implements ISpiDemoService {
    @Override
    public void sayHello() {
        System.out.println("java spi implemention 111");
    }
}

JavaSpiImp2

public class JavaSpiImp2 implements ISpiDemoService {
    @Override
    public void sayHello() {
        System.out.println("java spi implemention 222");
    }
}

在META-INF/services下新建文件(名称为接口全限定名)，文件内容为接口实现类全限定名
在这里插入图片描述
调用java.util.ServiceLoader#load(java.lang.Class)加载实现类，并测试输出
在这里插入图片描述

缺点

默认加载了所有实现类(然后通过迭代器访问provider实现类)，实际上程序了不一定能用到所有的实现，也不能方便的获取某一个实现类。如果能实现按需加载能减少一定程度的资源浪费
在这里插入图片描述

Dubbo SPI

Java SPI 实现类配置不同，Dubbo SPI 是通过键值对的方式进行配置，这样我们可以按需加载指定的实现类

Demo

ISpiDemoService接口上加上@SPI注解
在这里插入图片描述

配置文件中加入key-value格式的配置，key自定义，value为实现类的全路径
在这里插入图片描述
通过ExtensionLoader.getExtensionLoader(ISpiDemoService.class)得到特定接口的类加载器，再通过extensionLoader.getExtension(key)获取特定的实现类
在这里插入图片描述

Dubbo SPI优点

  1. 能够实现按需加载，JDK SPI仅仅通过接口类名获取所有实现，在通过迭代器获取指定实现，而ExtensionLoader则通过接口类名和key值获取一个实现
  2. 支持AOP(将实现类包装在Wrapper中，Wrapper中实现公共增强逻辑)
  3. 支持IOC(能够通过set方法注入其他扩展点)

按需加载，上面的Demo例子里已经体现过了，下面针对AOP、IOC特性分析Dubbo是如何实现的，先了解下Dubbo中类加载的过程

ExtensionLoader.getExtension

首先从ExtensionLoader.getExtension入手看下实现类的加载过程，dubbo中会对SPI中加载的Class及Class的实例进行缓存，其中cachedInstances就是实例的缓存

public T getExtension(String name) {
        if (name == null || name.length() == 0)
            throw new IllegalArgumentException("Extension name == null");
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        //先尝试从缓存中获取实现类实例
        Holder<Object> holder = cachedInstances.get(name);
        if (holder == null) {
            cachedInstances.putIfAbsent(name, new Holder<Object>());
            holder = cachedInstances.get(name);
        }
        Object instance = holder.get();
        //双重检查锁定
        if (instance == null) {
            synchronized (holder) {
                instance = holder.get();
                if (instance == null) {
                	//调用createExtension创建拓展对象
                    instance = createExtension(name);
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }

逻辑比较简单、缓存里找不到对应拓展实现类，就调用createExtension创建一个，下面进入到了createExtension方法

//缓存了 Class及对应的实例
private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();

private T createExtension(String name) {
		//第一步先获取拓展类的Class对象
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null) {
            throw findException(name);
        }
        try {
        	//尝试从缓存中获取
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
            	//反射创建Class对应实例instance
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            //向实例instance中注入其依赖的对象
            injectExtension(instance);
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            //遍历wrapper，向wrapper包装类中注入依赖的对象(将实例本身注入到包装类中)
            if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
                for (Class<?> wrapperClass : wrapperClasses) {
                    instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                }
            }
            return instance;
        } catch (Throwable t) {
            throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
                    type + ")  could not be instantiated: " + t.getMessage(), t);
        }
    }

看到这里基本扩展类的加载流程就清晰了，分为几个关键步骤

  1. getExtensionClasses()先从resource目录下读取指定位置的配置文件中的拓展类的定义，转化为Class，代码如下:

同样的，针对Class也做了缓存，先从缓存中获取Class。loadDirectory方法从指定位置"META-INF/services/"，
“META-INF/dubbo/”，"META-INF/dubbo/internal/"中加载拓展类配置

private Map<String, Class<?>> getExtensionClasses() {
        Map<String, Class<?>> classes = cachedClasses.get();
        if (classes == null) {
            synchronized (cachedClasses) {
                classes = cachedClasses.get();
                if (classes == null) {
                    classes = loadExtensionClasses();
                    cachedClasses.set(classes);
                }
            }
        }
        return classes;
    }

    /**
     * synchronized in getExtensionClasses
     * */
    private Map<String, Class<?>> loadExtensionClasses() {
        cacheDefaultExtensionName();

        Map<String, Class<?>> extensionClasses = new HashMap<>();
        loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName());
        loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
        loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName());
        loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
        loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName());
        loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
        return extensionClasses;
    }
  1. 获取到实现类Class后，判断缓存中是否有Class对应的实例，如果没有，则反射生成一个实例
  2. 调用injectExtension注入依赖
  3. 往Wrapper中注入依赖

injectExtension方法是实现IOC依赖注入的关键，往Wrapper中注入依赖，通过Wrapper包装实例，从而在Wrapper的方法中进行方法增强是实现AOP的关键，下面分别分析

IOC

看下injectExtension的实现，其核心思想是遍历其Set方法，从Set方法中取出属性的变量名，从ExtensionFactory中获取依赖对象的实例，再反射调用set方法注入依赖

private T injectExtension(T instance) {

        if (objectFactory == null) {
            return instance;
        }

        try {
        	//遍历所有方法
            for (Method method : instance.getClass().getMethods()) {
            	//不是set方法 continue
                if (!isSetter(method)) {
                    continue;
                }
                //如果方法包含DisableInject注解，不进行注入
                if (method.getAnnotation(DisableInject.class) != null) {
                    continue;
                }
                Class<?> pt = method.getParameterTypes()[0];
                //判断set方法中的类型参数是否是原始类型，如果是原始类型，不进行注入
                if (ReflectUtils.isPrimitives(pt)) {
                    continue;
                }
                try {
                	//获取注入的属性名，比如 setName 方法对应属性名 name
                    String property = getSetterProperty(method);
                    //从objectFactory获取依赖的对象
                    Object object = objectFactory.getExtension(pt, property);
                    if (object != null) {
                    	//反射调用set方法进行注入
                        method.invoke(instance, object);
                    }
                } catch (Exception e) {
                    logger.error("Failed to inject via method " + method.getName()
                            + " of interface " + type.getName() + ": " + e.getMessage(), e);
                }

            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return instance;
    }

AOP

实现AOP的关键是ExtensionLoader#createExtension实际返回的是Wrapper类(存在对应Wrapper类的情况下)

Set<Class<?>> wrapperClasses = cachedWrapperClasses;
 if (CollectionUtils.isNotEmpty(wrapperClasses)) {
 	//遍历Wrapper类型的Class
     for (Class<?> wrapperClass : wrapperClasses) {
     	//首先反射调用Wrapper的构造方法，创建一个Wrapper类，往Wrapper类中注入依赖
         instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
     }
 }

以ProtocolListenerWrapper为例，其内部包含Protocol实例，其export，refer方法最终调用的还是Protocol的export，refer方法，但在ProtocolListenerWrapper的export，refer中增强了Protocol的export，refer方法，做了一些额外的判定、封装处理

在这里插入图片描述

最后附上本文中的Demo地址，有兴趣的可以跑一下

https://github.com/hosaos/JavaLearningDemo

hosaos
关注
专栏目录
Java中的Spi以及Dubbo中的Spi机制解析
m0_51464746的博客
02-16 600
SPI 全称为 Service Provider Interface，是一种服务发现机制。本质是由将接口的实现类的全限定名配置在文件当中，由服务加载，这样可以在运行时，动态的为接口加载实现类。 举个例子，我们在用JDBC连接数据库时，创建连接就能直接获取到Mysql或者Oracle，Java时如何调用到相对应的驱动呢？ 我们将连接数据库看作一个扩展点，其他数据都是该点的实现，当我们需要连接相对应的的数据库时，Spi会帮助我们发现有哪些实现并加载。 一、J...
java spi与dubbo spi区别
uhana的博客
05-08 7873
java spi与dubbo spi区别java spi :是上游产商给服务供应商提供的接口，供应商遵循接口契约提供自己的实现.。提供了服务接口的一种实现之后，在jar包的META-INF/services/目录里同时创建一个以服务接口命名的文件。该文件里就是实现该服务接口的具体实现类。而当外部程序装配这个模块的时候，就能通过该jar包META-INF/services/里的配置文件找到具体的实现类
java spi 与 dubbo spi
念念不忘，必有回响
04-05 587
传统java spi 在java 中我们要动态通过配置文件制定实现类该如何实现呢？使用java spi机制即可，我们来看下面这个例子 public interface Robot { void sayHello(); } 然后定义两个实现类。分别为 OptimusPrime 和 Bumblebee public class OptimusPrime implements Robot { @Override public void sayHello() {
从Java SPI机制实现到Dubbo SPI扩展
java界的小学生
01-20 2192
SPI扩展 SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用，比如 Dubbo 就是通过 SPI 机制加载所有的组件。...
incubator-dubbo-dubbo-2.6.1
04-26
【标签】"dubbo" 指的是该项目的核心技术，Dubbo是一个Java语言编写的开源框架，主要用于构建高性能、分布式服务。它提供服务注册、服务发现、负载均衡、容错处理、监控等关键功能。 **Dubbo的主要特性：** 1. **...
dubbo-dubbo-2.7.8.zip
08-04
Dubbo，作为一个高性能、轻量级的Java开源框架，被广泛应用于分布式系统开发中。2.7.8是其一个重要的版本，包含了众多优化和改进。在本文中，我们将深入探讨这个版本的核心特性、设计理念以及实际应用中的关键知识点...
dubbo-demo
03-16
7. **SPI（Service Provider Interface）扩展机制**：Dubbo使用Java的SPI机制，允许用户自定义并扩展Dubbo的各种组件和服务行为，增强了框架的灵活性。 8. **QoS（服务质量）管理**：Dubbo提供了QoS参数设置，如...
dubbo-dev-book
09-15
Dubbo是一款高性能、轻量级的Java RPC框架，专注于提供高效的分布式服务调用方案。在架构设计方面，Dubbo将复杂的网络通信、负载均衡、服务发现、服务治理等细节封装起来，使得开发者能够更加专注于业务逻辑的实现。...
java 中SPI和Dubbo中SPI的区别
nandao158的博客
05-03 2500
今天分享两者区别： 1、原理方面： java是一次性加载完毕，浪费资源。 Dubbo是对javaSPI的扩展，以键值对的形式存在，用到哪个实现类取哪一个，而且可以分组，默认注解配置等方式。 2、代码示例： 1）javaspi示例： 定义一个接口： 定义三个实现类： 配置文件配置： 2）dubbospi代码示例： 3、 ...
Java Spi以及Dubbo Spi
weixin_44716359的博客
10-10 784
无
Java spi和Dubbo spi的对比以及应用
二祥的工作历程
03-21 310
Spi测试的基础环境 一个Shape的接口，有一个draw方法 一个Circle类和Rect类实现Shape，重写draw方法 代码如下： // 接口：形状 public interface Shape { void draw(); } // 圆类，实现形状接口 public class Circle implements Shape { public void draw() { System.out.println("画一个圆"); } } // 矩形类，实现
Dubbo SPI 和 Java SPI 区别？
最新发布
NZC2237的博客
12-29 591
Dubbo SPI：Dubbo SPI 的配置文件内容可以包含多个扩展实现，每个扩展实现对应一个键值对，键是扩展实现的名字，值是扩展实现的全限定类名。Dubbo SPI：Dubbo SPI 是基于 Java SPI 的一种增强机制。总体来说，Dubbo SPI 是对 Java SPI 的增强，提供了更灵活、可扩展、支持动态替换的机制，使得在实际应用中更容易实现插件式的架构设计。Java SPI：Java SPI 的配置文件内容是单一的实现类的全限定类名，通常存储在META-INF/services目录下。
Java SPI 与 dubbo SPI
weixin_48967543的博客
05-30 115
Java原生SPI京东优惠券 www.fenfaw.net 面向接口编程+策略模式 实现 建立接口 Robot public interface Robot { /** * 测试方法1 */ void sayHello(); } 多个实现类实现接口 RobotA public class RobotA implements Robot { public RobotA() { System.out.println("Happy RobotA .
dubbo spi和java spi的原理和区别
weixin_42082191的博客
05-29 248
spi
Java SPI + Dubbo SPI
水月青花
12-01 468
1. 什么是SPI SPI全称Service Provider Interface，服务提供接口，是Java提供的一套用来被第三方实现或者扩展的接口，它可以用来启用框架扩展和替换组件。 SPI的作用就是为这些被扩展的API寻找服务实现。 2. API和SPI API （Application Programming Interface）叫应用程序接口，是有实现方制定接口并完成对接口的实现，调用方仅仅依赖接口调用，且无权选择不同实现。 从使用人员上来说，API 直接被应用开发人员使用。 SPI （Servic
Java SPI与Dubbo SPI
lovexin_xin的博客
05-29 547
Java原生SPI 面向接口编程+策略模式 实现 建立接口 Robot public interface Robot { /** * 测试方法1 */ void sayHello(); } 多个实现类实现接口 RobotA public class RobotA implements Robot { public RobotA() { System.out.println("Happy RobotA is loaded"); }
Java SPI机制与Dubbo中的应用解析
Dubbo是一个高性能、轻量级的开源Java RPC框架，它提供了从服务注册与发现、负载均衡到服务调用等全面的服务治理方案。在Dubbo的设计中，Service Provider Interface (SPI)机制起到了关键的作用，它允许Dubbo在运行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值