Dubbo如何通过SPI提高框架的可扩展性？-低调大师

Dubbo如何通过SPI提高框架的可扩展性？

2020-08-18 618

介绍

最近看了一下Dubbo的源码，国人写的框架和国外的果然是两种不同的风格，Dubbo的源码还是比较清晰容易懂的。Spring框架一个Bean的初始化过程就能绕死在源码中.

Dubbo的架构是基于分层来设计的，每层执行固定的功能，上层依赖下层，下层的改变对上层不可见，每层都是可以被替换的组件

Service和Config为API接口层，让Dubbo使用者方便的发布和引用服务
其他各层均为SPI层，意味着每层都是组件化的，可以被替换

例如，注册中心可以用Redis，Zookeeper。传输协议可以用dubbo，rmi，hessian等。
网络通信可以用mina，netty。序列化可以用fastjson，hessian2，java原生的方式等

SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能

那么Dubbo的SPI是怎么实现的呢？先来了解一下Java SPI

Java SPI

Java SPI是通过策略模式实现的，一个接口提供多个实现类，而使用哪个实现类不在程序中确定，而是配置文件配置的，具体步骤如下

定义接口及其对应的实现类
在META-INF/services目录下创建以接口全路径命名的文件
文件内容为实现类的全路径名
在代码中通过java.util.ServiceLoader#load加载具体的实现类

写个Demo演示一下

public interface Car {

    void getBrand();
}

public class BenzCar implements Car {

    @Override
    public void getBrand() {
        System.out.println("benz");
    }
}

public class BMWCar implements Car {

    @Override
    public void getBrand() {
        System.out.println("bmw");
    }
}

org.apache.dubbo.Car的内容如下

org.apache.dubbo.BenzCar
org.apache.dubbo.BMWCar

测试类

public class JavaSpiDemo {

    public static void main(String[] args) {
        ServiceLoader<Car> carServiceLoader = ServiceLoader.load(Car.class);
        // benz
        // bmw
        carServiceLoader.forEach(Car::getBrand);
    }
}

Dubbo SPI

用Dubbo SPI将上面的例子改造一下

@SPI
public interface Car {

    void getBrand();
}

public class BenzCar implements Car {

    @Override
    public void getBrand() {
        System.out.println("benz");
    }
}

public class BMWCar implements Car {
    @Override
    public void getBrand() {
        System.out.println("bmw");
    }
}

org.apache.dubbo.quickstart.Car的内容如下

benz=org.apache.dubbo.quickstart.BenzCar
bmw=org.apache.dubbo.quickstart.BMWCar

测试类

public class DubboSpiDemo {

    public static void main(String[] args) {
        ExtensionLoader<Car> extensionLoader = ExtensionLoader.getExtensionLoader(Car.class);
        Car car = extensionLoader.getExtension("benz");
        car.getBrand();
    }
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface SPI {

    String value() default "";

}

@SPI标记接口是一个Dubbo SPI接口，即是一个扩展点，value属性可以指定默认实现

Dubbo 并未使用 Java 原生的 SPI 机制，而是对其进行了增强，使其能够更好的满足需求。Dubbo SPI的优点如下

JDK标准的SPI会一次性实例化扩展点的所有实现。而Dubbo SPI能实现按需加载
Dubbo SPI增加了对扩展点Ioc和Aop的支持

Dubbo SPI的实现步骤如下

定义接口及其对应的实现类，接口上加@SPI注解，表明这是一个扩展类
在META-INF/services目录下创建以接口全路径命名的文件
文件内容为实现类的全路径名
在代码中通过ExtensionLoader加载具体的实现类

Dubbo SPI 扩展点的特性

自动包装

扩展类的构造函数是一个扩展点，则认为这个类是一个Wrapper类，即AOP

用例子演示一下

@SPI
public interface Car {

    void getBrand();
}

public class BenzCar implements Car {
    @Override
    public void getBrand() {
        System.out.println("benz");
    }
}

public class CarWrapper implements Car {

    private Car car;

    public CarWrapper(Car car) {
        this.car = car;
    }

    @Override
    public void getBrand() {
        System.out.println("start");
        car.getBrand();
        System.out.println("end");
    }
}

org.apache.dubbo.aop.Car内容如下（resources\META-INF\services目录下）

benz=org.apache.dubbo.aop.BenzCar
org.apache.dubbo.aop.CarWrapper

测试类

public class DubboSpiAopDemo {

    public static void main(String[] args) {
        ExtensionLoader<Car> extensionLoader = ExtensionLoader.getExtensionLoader(Car.class);
        Car car = extensionLoader.getExtension("benz");
        // start
        // benz
        // end
        car.getBrand();
    }
}

BenzCar是一个扩展类，CarWrapper是一个包装类，当获取BenzCar的时候实际获取的是被CarWrapper包装后的对象，类似代理模式

自动加载

如果一个扩展类是另一个扩展类的成员变量，并且拥有set方法，框架会自动注入这个扩展点的实例，即IOC。先定义2个扩展点

org.apache.dubbo.ioc.Car（resources\META-INF\services目录下）

benz=org.apache.dubbo.ioc.BenzCar

org.apache.dubbo.ioc.Wheel（resources\META-INF\services目录下）

benz=org.apache.dubbo.ioc.BenzWheel

@SPI
public interface Wheel {

    void getBrandByUrl();
}

public class BenzWheel implements Wheel {

    @Override
    public void getBrandByUrl() {
        System.out.println("benzWheel");
    }
}

@SPI
public interface Car {

    void getBrandByUrl();
}

public class BenzCar implements Car {

    private Wheel wheel;

    public void setWheel(Wheel wheel) {
        this.wheel = wheel;
    }

    @Override
    public void getBrandByUrl() {
        System.out.println("benzCar");
        wheel.getBrandByUrl();
    }
}

测试demo

public class DubboSpiIocDemo {

    public static void main(String[] args) {
        ExtensionLoader<Car> extensionLoader = ExtensionLoader.getExtensionLoader(Car.class);
        Car car = extensionLoader.getExtension("benz");
        car.getBrandByUrl();
    }
}

我跑这个代码的时候直接报异常，看了一下官网才发现dubbo是可以注入接口的实现的，但不像spring那么智能，
dubbo必须用URL（类似总线）来指定扩展类对应的实现类.。这就不得不提到@Adaptive注解了

自适应

使用@Adaptive注解，动态的通过URL中的参数来确定要使用哪个具体的实现类

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Adaptive {

    String[] value() default {};

}

@SPI
public interface Wheel {

    @Adaptive("wheel")
    void getBrandByUrl(URL url);
}

public class BenzWheel implements Wheel {

    @Override
    public void getBrandByUrl(URL url) {
        System.out.println("benzWheel");
    }
}

@SPI
public interface Car {

    void getBrandByUrl(URL url);
}

public class BenzCar implements Car {

    // 这个里面存的是代理对象
    private Wheel wheel;

    public void setWheel(Wheel wheel) {
        this.wheel = wheel;
    }

    @Override
    public void getBrandByUrl(URL url) {
        System.out.println("benzCar");
        // 代理类根据URL找到实现类，然后再调用实现类
        wheel.getBrandByUrl(url);
    }
}

public class DubboSpiIocDemo {

    public static void main(String[] args) {
        ExtensionLoader<Car> extensionLoader = ExtensionLoader.getExtensionLoader(Car.class);
        Car car = extensionLoader.getExtension("benz");
        Map<String, String> map = new HashMap<>();
        // 指定wheel的实现类为benz
        map.put("wheel", "benz");
        URL url = new URL("", "", 1, map);
        // benzCar
        // benzWheel
        car.getBrandByUrl(url);
    }
}

可以看到BenzCar对象成功注入了BenzWheel。BenzCar中其实注入的是BenzWheel的代码对象，这个代理对象会根据@Adaptive("wheel")获取到wheel，然后从url中找到key为wheel的值，这个值即为实现类对应的key。

上面的注释提到BenzCar里面注入的Wheel其实是一个代理对象（框架帮我们生成），在代理对象中根据url找到相应的实现类，然后调用实现类。

因为代理对象是框架在运行过程中帮我们生成的，没有文件可以查看，所以用Arthas来查看一下生成的代理类

curl -O https://alibaba.github.io/arthas/arthas-boot.jar
java -jar arthas-boot.jar
# 根据前面的序号选择进入的进程，然后执行下面的命令
jad org.apache.dubbo.adaptive.Wheel$Adaptive

生成的Wheel

package org.apache.dubbo.adaptive;

import org.apache.dubbo.adaptive.Wheel;
import org.apache.dubbo.common.URL;
import org.apache.dubbo.common.extension.ExtensionLoader;

public class Wheel$Adaptive
implements Wheel {
    public void getBrandByUrl(URL uRL) {
        if (uRL == null) {
            throw new IllegalArgumentException("url == null");
        }
        URL uRL2 = uRL;
        String string = uRL2.getParameter("wheel");
        if (string == null) {
            throw new IllegalStateException(new StringBuffer().append("Failed to get extension (org.apache.dubbo.adaptive.Wheel) name from url (").append(uRL2.toString()).append(") use keys([wheel])").toString());
        }
        Wheel wheel = (Wheel)ExtensionLoader.getExtensionLoader(Wheel.class).getExtension(string);
        wheel.getBrandByUrl(uRL);
    }
}

@Adaptive可以标记在类上或者方法上

标记在类上：将该实现类直接作为默认实现，不再自动生成代码
标记在方法上：通过参数动态获得实现类，比如上面的例子

用源码演示一下用在类上的@Adaptiv，Dubbo为自适应扩展点生成代码，如我们上面的WheelAdaptive，但生成的代码还需要编译才能生成class文件。我们可以用JavassistCompiler（默认的）或者JdkCompiler来编译（需要配置），这个小小的功能就用到了@Adaptive

如果想用JdkCompiler需要做如下配置

<dubbo:application compiler="jdk" />

Compiler类图如下

@SPI("javassist")
public interface Compiler {

    Class<?> compile(String code, ClassLoader classLoader);

}

Compiler用@SPI指定了默认实现类为javassist

源码中获取Compiler调用了如下方法

org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();

getAdaptiveExtension()会获取自适应扩展类，那么这个自适应扩展类是谁呢？

是AdaptiveCompiler，因为类上有@Adaptive注解

@Adaptive
public class AdaptiveCompiler implements Compiler {

    private static volatile String DEFAULT_COMPILER;

    public static void setDefaultCompiler(String compiler) {
        DEFAULT_COMPILER = compiler;
    }

    /**
     * 获取对应的Compiler，并调用compile做编译
     * 用户设置了compiler，就用设置了的，不然就用默认的
     */
    @Override
    public Class<?> compile(String code, ClassLoader classLoader) {
        Compiler compiler;
        ExtensionLoader<Compiler> loader = ExtensionLoader.getExtensionLoader(Compiler.class);
        String name = DEFAULT_COMPILER; // copy reference
        if (name != null && name.length() > 0) {
            // 用用户设置的
            compiler = loader.getExtension(name);
        } else {
            // 用默认的
            compiler = loader.getDefaultExtension();
        }
        return compiler.compile(code, classLoader);
    }

}

从compile方法可以看到，如果用户设置了编译方式，则用用户设置的，如果没有设置则用默认的，即JavassistCompiler

自动激活

使用@Activate注解，可以标记对应的扩展点默认被激活使用

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Activate {

    // 所属组，例如消费端，服务端
    String[] group() default {};

    // URL中包含属性名为value的键值对，过滤器才处于激活状态
    String[] value() default {};

    // 指定执行顺序，before指定的过滤器在该过滤器之前执行
    @Deprecated
    String[] before() default {};

    // 指定执行顺序，after指定的过滤器在该过滤器之后执行
    @Deprecated
    String[] after() default {};

    // 指定执行顺序，值越小，越先执行
    int order() default 0;
}

可以通过指定group或者value，在不同条件下获取自动激活的扩展点。before，after，order是用来排序的，感觉一个order参数就可以搞定排序的功能，所以官方把before，after标记为@Deprecated

Dubbo Filter就是基于这个来实现的。Dubbo Filter是Dubbo可扩展性的一个体现，可以在调用过程中对请求进行进行增强

我写个demo演示一下这个自动激活是怎么工作的

@SPI
public interface MyFilter { 
    void filter();
}

consumer组能激活这个filter

@Activate(group = {"consumer"})
public class MyConsumerFilter implements MyFilter {
    @Override
    public void filter() {

    }
}

provider组能激活这个filter

@Activate(group = {"provider"})
public class MyProviderFilter implements MyFilter {
    @Override
    public void filter() {

    }
}

consumer组和provide组都能激活这个filter

@Activate(group = {"consumer", "provider"})
public class MyLogFilter implements MyFilter {
    @Override
    public void filter() {

    }
}

consumer组和provide组都能激活这个filter，同时url中指定key的value为cache

@Activate(group = {"consumer", "provider"}, value = "cache")
public class MyCacheFilter implements MyFilter {
    @Override
    public void filter() {

    }
}

测试类如下
getActivateExtension有3个参数，依次为url, key, group

public class ActivateDemo {

    public static void main(String[] args) {
        ExtensionLoader<MyFilter> extensionLoader = ExtensionLoader.getExtensionLoader(MyFilter.class);
        // url中没有参数
        URL url = URL.valueOf("test://localhost");
        List<MyFilter> allFilterList = extensionLoader.getActivateExtension(url, "", null);
        /**
         * org.apache.dubbo.activate.MyConsumerFilter@53e25b76
         * org.apache.dubbo.activate.MyProviderFilter@73a8dfcc
         * org.apache.dubbo.activate.MyLogFilter@ea30797
         *
         * 不指定组则所有的Filter都被激活
         */
        allFilterList.forEach(item -> System.out.println(item));
        System.out.println();

        List<MyFilter> consumerFilterList = extensionLoader.getActivateExtension(url, "", "consumer");
        /**
         * org.apache.dubbo.activate.MyConsumerFilter@53e25b76
         * org.apache.dubbo.activate.MyLogFilter@ea30797
         *
         * 指定consumer组，则只有consumer组的Filter被激活
         */
        consumerFilterList.forEach(item -> System.out.println(item));
        System.out.println();

        // url中有参数myfilter
        url = URL.valueOf("test://localhost?myfilter=cache");
        List<MyFilter> customerFilter = extensionLoader.getActivateExtension(url, "myfilter", "consumer");
        /**
         * org.apache.dubbo.activate.MyConsumerFilter@53e25b76
         * org.apache.dubbo.activate.MyLogFilter@ea30797
         * org.apache.dubbo.activate.MyCacheFilter@aec6354
         *
         * 指定key在consumer组的基础上，MyCacheFilter被激活
         */
        customerFilter.forEach(item -> System.out.println(item));
        System.out.println();
    }
}

总结一下就是，getActivateExtension不指定组就是激活所有的Filter，指定组则激活指定组的Filter。指定key则从Url中根据key取到对应的value，假设为cache，然后把@Activate注解中value=cache的Filter激活

即group用来筛选，value用来追加，Dubbo Filter就是靠这个属性激活不同的Filter的

ExtensionLoader的工作原理

ExtensionLoader是整个Dubbo SPI的主要实现类，有如下三个重要方法，搞懂这3个方法基本上就搞懂Dubbo SPI了。

加载扩展类的三种方法如下

getExtension()，获取普通扩展类
getAdaptiveExtension()，获取自适应扩展类
getActivateExtension()，获取自动激活的扩展类

getExtension()上面的例子中已经有了。自适应的特性上面已经演示过了，当获取Wheel的实现类是框架会调用getAdaptiveExtension()方法。

代码就不放了，这3个方法的执行过程还是比较简单的，如果你有看不懂的，可以看我给源码加的注释。

https://github.com/erlieStar/dubbo-analysis

理解了Dubbo SPI你应该就把Dubbo搞懂一半了，剩下就是一些服务导出，服务引入，服务调用的过程了

欢迎关注

有帮助？点赞！转发！

本文分享自微信公众号 - Java识堂（erlieStar）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

微信关注我们

原文链接：https://my.oschina.net/u/4447432/blog/4504806

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

对抗鲁棒性使得神经网络又强又怂

AI TIME欢迎每一位AI爱好者的加入！对抗样本的存在表明现代神经网络是相当脆弱的。为解决这一问题，研究者相继提出了许多方法，其中使用对抗样本进行训练被认为是至今最有效的方法之一。然而，经过对抗训练后神经网络对于正常样本的性能往往会下降，这一问题引起了学术界的广泛关注，这种准确度与鲁棒性之间互相妥协的本质原因仍未被找出。在这一工作中，讲者及其团队从正则化的角度来研究神经网络的对抗鲁棒性。嘉宾团队指出，经过对抗训练之后的网络在特征空间的绝大多数方向上将被平滑，导致样本集中于决策边界附近；换言之，经过对抗训练的网络输出往往是相对低置信度的，这种网络对于正常样本的性能往往也是更差的。研究表明，我们应该以更温和的手段来构建对抗鲁棒性，避免过度正则化。温宇馨，本科毕业于华南理工大学，目前在华南理工大学几何感知与智能实验室就读博士三年级，导师为贾奎教授。研究兴趣包括计算机视觉与机器学习。已在相关领域的国际顶级会议期刊如ICML, TPAMI等发表多篇论文。一、对抗样本与对抗鲁棒性在温宇馨同学提到的这个案例中，第一张熊猫的图片在神经网络中以57.7%的置信度识别为熊猫；但把第二张熊...

2020-08-17

757

本文选自 Doocs 开源社区旗下“源码猎人”项目，作者 AmyliaY。项目将会持续更新，欢迎 Star 关注。项目地址：https://github.com/doocs/source-code-hunter 线程池核心组件图解看源码之前，先了解一下该组件最主要的几个接口、抽象类和实现类的结构关系。该组件中，Executor 和 ExecutorService 接口定义了线程池最核心的几个方法，提交任务 submit ()、关闭线程池 shutdown()。抽象类 AbstractExecutorService 主要对公共行为 submit()系列方法进行了实现，这些 submit()方法的实现使用了模板方法模式，其中调用的 execute()方法是未实现的来自 Executor 接口的方法。实现类 ThreadPoolExecutor 则对线程池进行了具体而复杂的实现。另外还有一个常见的工具类 Executors，里面为开发者封装了一些可以直接拿来用的线程池。源码赏析话不多说，直接上源码。（这里只看最主要的代码部分） Executor 和 Executor...

2020-08-18

617

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。