1、dubbo扩展点机制

最新推荐文章于 2023-04-01 23:21:51 发布
最新推荐文章于 2023-04-01 23:21:51 发布
阅读量97 收藏
点赞数
文章标签： java python runtime
原文链接：https://my.oschina.net/baoyuexing/blog/1791677
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

spring的几个问题

spring是如何启动容器的

常见的一种在本地使用main方法启动spring的方法

    public static void main(String[] args) throws Exception {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"META-INF/spring/dubbo-demo-provider.xml"});
        context.start();
        ...
        //System.in.read(); // 按任意键退出
        context.close();
    }

dubbo的几个问题

dubbo是如何启动容器的？

这个大家应该都知道，通过com.alibaba.dubbo.container.Main.main方法来启动的。

public class Main {

    //在dubbo.properties中配置， 以配置dubbo.container=log4j,spring为例
    public static final String CONTAINER_KEY = "dubbo.container";

    public static final String SHUTDOWN_HOOK_KEY = "dubbo.shutdown.hook";

    private static final Logger logger = LoggerFactory.getLogger(Main.class);
    
    //整个dubbo，最先使用ExtensionLoader的地方
    private static final ExtensionLoader<Container> loader = ExtensionLoader.getExtensionLoader(Container.class);

    private static volatile boolean running = true;

    public static void main(String[] args) {
        try {
            //1. 从dubbo.properties里面读取dubbo.container这个配置；
            if (args == null || args.length == 0) {
                String config = ConfigUtils.getProperty(CONTAINER_KEY, loader.getDefaultExtensionName());
                args = Constants.COMMA_SPLIT_PATTERN.split(config);
            }
            //2. 使用Container接口的ExtensionLoader中获取具体的Container实现类；
            final List<Container> containers = new ArrayList<Container>();
            //agrs中有两个值 "log4j,spring"
            for (int i = 0; i < args.length; i++) {
                containers.add(loader.getExtension(args[i]));
            }
            logger.info("Use container type(" + Arrays.toString(args) + ") to run dubbo serivce.");

            if ("true".equals(System.getProperty(SHUTDOWN_HOOK_KEY))) {
                //5. 当主线程被外部终止时，会触发 shutdownhook，执行Container的stop与close方法
                Runtime.getRuntime().addShutdownHook(new Thread() {
                    public void run() {
                        for (Container container : containers) {
                            try {
                                container.stop();
                                logger.info("Dubbo " + container.getClass().getSimpleName() + " stopped!");
                            } catch (Throwable t) {
                                logger.error(t.getMessage(), t);
                            }
                            synchronized (Main.class) {
                                running = false;
                                //6.通知下面的锁操作，主线程正常走完代码，并最终停止。
                                Main.class.notify();
                            }
                        }
                    }
                });
            }
            //3. 执行Container接口的start方法；
            for (Container container : containers) {
                container.start();
                logger.info("Dubbo " + container.getClass().getSimpleName() + " started!");
            }
            System.out.println(new SimpleDateFormat("[yyyy-MM-dd HH:mm:ss]").format(new Date()) + " Dubbo service server started!");
        } catch (RuntimeException e) {
            e.printStackTrace();
            logger.error(e.getMessage(), e);
            System.exit(1);
        }
        //4. 用一个死循环，保留主线程；
        synchronized (Main.class) {
            while (running) {
                try {
                    Main.class.wait();
                } catch (Throwable e) {
                }
            }
        }
    }

}

dubbo容器的可扩展功能实现

明确下面几个概念

  1. 扩展接口 com.alibaba.dubbo.container.Container
  2. 扩展配置 dubbo.container = log4j,spring
  3. 扩展实现

  • com.alibaba.dubbo.container.log4j.Log4jContainer log4j的日志初始工作，当多进程启动时，做日志隔离

  • com.alibaba.dubbo.container.logback.LogbackContainer logback的日志初始工作

  • com.alibaba.dubbo.container.spring.SpringContainer spring容器的启动，使用spring容器来实现aop与ioc，【这个配置，往往是必选的】

  • com.alibaba.dubbo.container.jetty.JettyContainer 启动一个Servlet Web容器，提供了一个web页面，做一些监控之类的时期，注意：在写HttpResponse的时候，也是用SPI机制，不同的请 求页面经过PageServlet交个不同的PageHandler去实现

  • com.alibaba.dubbo.monitor.simple.RegistryContainer

    我们来想一个这样的问题，上面是dubbo支持的容器，包括log4j、logback、spring、jetty、registry，那么dubbo是如何通过配置的方式来实现容器的可扩展的呢？假如给你做你怎么做呢？

  • spring的API(Application Programming Interface、应用编程接口)方式,接口多实现类的动态调动；

  • JDK标准的SPI(Service Provider Interface、)机制 dubbo的扩展点加载机制是从JDK的spi机制加强而来。 dubbo改进了JDK标准的SPI机制以下问题：

  • spring与JDK的SPI都会一次性实例化扩展点所有实现，如果有扩展实现初始化很耗时，但如果没用上，也会加载。

  • JDK的SPI机制不支持Ioc与Aop功能，而dubbo中的扩展点可以直接setter注入其他扩展点。【这个一部分，下面会有涉及，我们会在下一个文章中详细描述】

扩展接口Container源码

关键说明，

  1. 必须带有SPI注解
  2. 注解里面的值，是默认实现，在ExtensionLoader源码去细讲。

/**
 * Container. (SPI, Singleton, ThreadSafe)
 *
 * @author william.liangf
 */
@SPI("spring")
public interface Container {

    /**
     * start.
     */
    void start();

    /**
     * stop.
     */
    void stop();

}

ExtensionLoader源码

关键说明， 1. ExtensionLoader有一个private的构造函数，并通过getExtensionLoader这个镜头方法返回实例，是一个单例工厂类。 2. 一个扩展接口对应一个ExtensionLoader实例，也就是说最终我们加载了多少个扩展接口(注意是扩展接口，而不是扩展实现类)，就多少个实例； 3. 关键static final变量，所有实例共享

    private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();

    private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();

4.  所有的final变量，单个实例共享，每一个扩展接口对应的ExtensionLoader都不一样

    //扩展接口名称
    private final Class<?> type;
    //也是一个扩展接口，用于注入扩展接口中需要注入的类，实现dubbo的扩展点的自动注入
    private final ExtensionFactory objectFactory;

    private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>();

    private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();

    private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>();
    private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>();
    private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>();
    private volatile Class<?> cachedAdaptiveClass = null;
    private String cachedDefaultName;
    private volatile Throwable createAdaptiveInstanceError;

    private Set<Class<?>> cachedWrapperClasses;

    private Map<String, IllegalStateException> exceptions = new ConcurrentHashMap<String, IllegalStateException>();

结合Main类的使用，讲一下几个核心方法

1.核心方法 -> ExtensionLoader.getExtensionLoader 返回ExtensionLoader实例

private static final ExtensionLoader<Container> loader = ExtensionLoader.**getExtensionLoader**(Container.class);

获取ExtensionLoader实例

  • getExtensionLoader(Container.class)【将返回的实例放到EXTENSION_LOADERS变量中】
    • new ExtensionLoader<T>(type) 【初始化type与objectFactory变量，初始化objectFactory变量的时候有一点点的绕。假如这个接口不是ExtensionFactory，就需要初始化这样的一个objectFactory，否则就需要，具体后面会将】 获取ExtensionLoader实例结束

2. 核心方法 -> ExtensionLoader.getExtension获得扩展实现

注意此时已经拿到了扩展接口Container对应的那个ExtensionLoader实例了，在下面的处理中，基本都是更新这个实例的变量，而很少会更新类变量了。

for (int i = 0; i < args.length; i++) {
   containers.add(loader.getExtension(args[i]));
}
  • getExtension("log4j" or "spring" or "logback" ....)
    • createExtension("log4j" or "spring" or "logback" ....) --创建指定类型的扩展接口的instance
      • getExtensionClasses() --加载扩展接口的所有class文件
        • loadExtensionClasses() --扩展接口的所有的class文件
          • loadFile() --从三个路径下，查找class文件
      • clazz.newInstance() --创建指定class的instance
      • injectExtension(instace) --注入属性Ioc
        • objectFactory.getExtension(pt, property) --反射的方式，解析setXxx(Xxx xxx)方法，注入Xxx实例
      • injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance)); --对实例进行层层包装，最终返回一个包装过后的instance

上面总体逻辑就是 图片 具体介绍一下loadFile方法

    //...
    private static final String SERVICES_DIRECTORY = "META-INF/services/";
    private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";
    private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";
    //...
    Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
    loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
    loadFile(extensionClasses, DUBBO_DIRECTORY);
    loadFile(extensionClasses, SERVICES_DIRECTORY);
    return extensionClasses;

if (clazz.isAnnotationPresent(Adaptive.class)) {
    if (cachedAdaptiveClass == null) {
        cachedAdaptiveClass = clazz;
    } else if (!cachedAdaptiveClass.equals(clazz)) {
        throw new IllegalStateException("More than 1 adaptive class found: "
                + cachedAdaptiveClass.getClass().getName()
                + ", " + clazz.getClass().getName());
    }
} else {
    try {
        clazz.getConstructor(type);
        Set<Class<?>> wrappers = cachedWrapperClasses;
        if (wrappers == null) {
            cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
            wrappers = cachedWrapperClasses;
        }
        wrappers.add(clazz);
    } catch (NoSuchMethodException e) {
        clazz.getConstructor();
        if (name == null || name.length() == 0) {
            name = findAnnotationName(clazz);
            if (name == null || name.length() == 0) {
                if (clazz.getSimpleName().length() > type.getSimpleName().length()
                        && clazz.getSimpleName().endsWith(type.getSimpleName())) {
                    name = clazz.getSimpleName().substring(0, clazz.getSimpleName().length() - type.getSimpleName().length()).toLowerCase();
                } else {
                    throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + url);
                }
            }
        }
        String[] names = NAME_SEPARATOR.split(name);
        if (names != null && names.length > 0) {
            Activate activate = clazz.getAnnotation(Activate.class);
            if (activate != null) {
                cachedActivates.put(names[0], activate);
            }
            for (String n : names) {
                if (!cachedNames.containsKey(clazz)) {
                    cachedNames.put(clazz, n);
                }
                Class<?> c = extensionClasses.get(n);
                if (c == null) {
                    extensionClasses.put(n, clazz);
                } else if (c != clazz) {
                    throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
                }
            }
        }
    }
}

从上面三个路径下加载dubbo扩展点的配置。我们以DUBBO_INTERNAL_DIRECTORY路径下的配置文件为例，说明下dubbo下扩展的配置。

  1. 扩展接口实现类，实现Container接口，例如SpringContainer.java
  2. 在资源META-INF.dubbo.internal文件夹下，有一个以Container接口全路径名称为名字的文件；
  3. 上述文件名中内容格式为 {key}={value}，key为扩展点实现类的配置名称，例如spring、log4j等；value为SpringContainer类的全路径名称 loadFile中就是以这样的规则，解析这样的配置文件，并放到extensionClasses这样的Map中返回，extensionClasses的key是这个{key},value是这个{value}对应的class。

这里面主要是四个逻辑，涉及到几种情况。 图片

拿到所有配置的Container实例

for (Container container : containers) {
    container.start();
    logger.info("Dubbo " + container.getClass().getSimpleName() + " started!");
}

执行SpringContainer.java的start方法

    public void start() {
        String configPath = ConfigUtils.getProperty(SPRING_CONFIG);
        if (configPath == null || configPath.length() == 0) {
            configPath = DEFAULT_SPRING_CONFIG;
        }
        context = new ClassPathXmlApplicationContext(configPath.split("[,\\s]+"));
        context.start();
    }

这个不是这篇文章最开始的那个问题的答案嘛，原来dubbo就是通过这么简单的方式的来启动spring容器的。这算是一个首尾呼应嘛~

终于，终于，第一篇文章写完了~ 下篇文章会讲解扩展点是如何**注入**其他扩展点的。

转载于:https://my.oschina.net/baoyuexing/blog/1791677

weixin_33962621
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
dubbo的容器模块
zgfyxc的博客
07-11 190
dubbo的容器模块，是一个独立的容器，因为服务通常不需要Tomcat/JBoss等Web容器的特性，没必要用Web容器去加载服务。 服务容器只是一个简单的Main方法，并加载一个简单的Spring容器，用于暴露服务。 我们看启动生产者、消费者、简单监控者的 start.sh 命令中，可以看到启动命令如下： nohup java $JAVA_OPTS $JAVA_MEM_OPTS ...
Dubbo原理解析-监控
weixin_34370347的博客
08-10 194
  Dubbo发布代码中，自带了一个简易的监控中心实现。对于一般的小业务这个监控中心应该能够满足需求，对于那些大业务量的大公司一般都会有自己的监控中心，更加丰富的功能如常用的报警短信通知等等。这章讲解分析使得读者能够了解一般的监控中心实现，也使得有自己接入监控中心需求的大概知道如何集成自己的监控中心实现。下面我们就以dubbo自带的监控中心开始讲解。   监控中心 1.  ...
Dubbo——扩展点详解
吴声子夜歌的博客
07-03 2642
扩展点整体架构 1. RPC层扩展点 按照完整的Dubbo结构分层，RPC层可以分为四层：Config、Proxy、Registry、Cluster。由于Config属于API范畴，因此只关注Proxy、Registry、Cluster三层的扩展点。 1.1 Proxy层扩展点 Proxy层主要的扩展接口是ProxyFactory。Dubbo中的ProxyFactory有两种默认实现：Javassist和JDK，用户可以自行扩展自己的实现，如CGLIB。Dubbo默认选择Javassist作为默认字节码生
Dubbo扩展点加载机制
啊杰的博客
03-16 233
1 加载机制概述 Dubbo具有很好的扩展性，这与其巧妙的运用设计模式、特殊的加载机制密切相关。基于Dubbo SPI 加载机制，让整个框架的接口和具体实现完全解耦，从而奠定了整个框架良好扩展性的基础。Dubbo 几乎所有的功能组件都是基于扩展机制（SPI）实现的。 博主的Honey-Audit审计服务也是利用SPI机制奠定其良好的扩展性基础 1.1扩展点的分类与缓存 Dubbo SPI 可以分为Class 缓存、实例缓存。这两种缓存又能根据扩展类的种类分为普通扩展类、包装扩展类（Wrapper）、自
Dubbo的扩展点
在途中
11-14 1536
dubbo在整体的架构设计上，都是通过扩展点实现的。 Dubbo扩展点规范 如果要扩展自定义的SPI(Service Provider Interface)，可以再resources目录下配置三种目录，分别是：META-INF/dubbo/或者META-INF/services或者META-INF/dubbo/internal/ 文件名与接口名称保持一致，文件内容以key-value形式存在，e...
dubbo spi可扩展机制源码解析
12-24
5. **扩展点机制**： - Dubbo SPI还支持自定义扩展点，用户可以方便地扩展Dubbo的各种组件，如协议、序列化、调度器等。 - 扩展点通过`@SPI`注解标识，`@Adaptive`注解用于生成适配器代码，实现动态加载。 6. **...
dubbo的SPI-扩展点机制
08-04
dubbo的核心思想就是SPI思想，想读懂dubbo源码应该认真的看下，详细的讲解了dubbo的SPI思想，从为什么，是什么，怎么做的来分析了dubbo的spi思想
18-Dubbo相关知识点1
08-08
1. **Dubbo 默认协议**：基于单一长连接的NIO异步通信。这种协议适用于数据量小、并发高的场景，如消费者数量多于提供者的场景。不过，它不适合传输大数据量的文件或媒体内容。 2. **RMI（Remote Method Invocation...
深度解析Dubbo的可扩展机制SPI源码：从理论到实践，打造高效、稳定的分布式服务框架
最新发布
01-11
1. 根据"name"查找并加载对应的扩展点实现类。 2. 使用反射创建扩展点实例，并将其与实现类一起缓存。 3. 对实例进行依赖注入，即自动为实例的属性赋值。如果属性类型为接口，Dubbo会提供一个适配的扩展点实例，这个...
dubbo-spi_mouse1oc_dubbospi_
10-03
5. **扩展点与生命周期**：Dubbo SPI允许开发者定义自己的扩展点，这为系统提供了高度可扩展性。每个扩展点都有其生命周期管理，包括初始化、销毁等阶段。 6. **缓存与性能**：为了提高性能，`ExtensionLoader`会...
Dubbo之扩展机制深入分析
jannal专栏
12-25 37
目录dubbo版本扩展点特性注解@SPI@Adaptive@ActivateExtensionLoadergetExtensiongetAdaptiveExtension生成源代码逻辑编译源代码getActivateExtensionExtensionFactory总结dubbo版本 dubbo版本2.6.7 扩展点特性 自动包装(Wrapper)：ExtensionLoader在加载扩...
Dubbo 扩展点机制
weixin_56018532的博客
08-21 631
Dubbo 扩展点机制
【深入理解 Dubbo 与实战】4 Dubbo 扩展点加载机制
green1997的博客
04-06 749
文章目录4 Dubbo 扩展点加载机制4.1 加载机制概述4.1.1 Java SPI4.1.2 扩展点加载机制的改进4.1.3 扩展点的配置规范4.1.4 扩展点的分类与缓存4.1.5 扩展点的特性4.2 扩展点注解4.2.1 扩展点注解 @SPI4.2.2 扩展点自适应注解 @Adaptive4.2.3 扩展点自动激活 @Activate4.3 ExtensionLoader 工作原理4.3.1 工作流程4.3.2 getExtension 的的实现原理4.3.3 getAdaptiveExtensio
【Dubbo核心 详解一】Dubbo扩展机制的详解
陈书予
04-01 242
Dubbo是一个高性能的分布式服务框架，广泛应用于各种规模和种类的企业级项目中。在实际应用过程中，Dubbo的核心能力是扩展机制，它可以让Dubbo具有更强的可定制化能力，也可以让Dubbo更好地适应各种应用场景。Dubbo的扩展机制主要包括：自适应扩展机制、SPI扩展机制、自定义扩展点机制、过滤器扩展机制、负载均衡扩展机制和容错机制扩展。这些机制使得Dubbo的使用更加灵活方便，可以满足不同需要的业务场景，也可以根据实际情况来选择合适的扩展机制。
dubbo启动服务之容器（Container）
热门推荐
wender的专栏
03-10 1万+
from http://www.ccblog.cn/75.htm讲解dubbo启动服务的时候先来了解下java的spi机制一：SPI 简介SPI 全称为 (Service Provider Interface) ,是JDK内置的一种服务提供发现机制。 目前有不少框架用它来做服务的扩展发现， 简单来说，它就是一种动态替换发现的机制， 举个例子来说， 有个接口，想运行时动态的给它添加实现，你只需要添加...
dubbo源码深度解读三之container模块
KilluaZoldyck的博客
07-30 2581
前言：container为服务容器，用于部署运行服务，是一个Standlone的容器，以简单的Main加载Spring启动，因为服务通常不需要Tomcat/JBoss等Web容器的特性，没必要用Web容器去加载服务。
dubbo 快速启动-结合spring注解使用com.alibaba.dubbo.container.Main启动
小城我家
12-28 1277
开始 是在之前的项目上 https://blog.csdn.net/ko0491/article/details/85168055 只更改Main类 之前的 现在的 public class Main3 { public static void main(String[] args) throws IOException { // com.alibaba.dubbo...
Dubbo-扩展机制
一把空心菜
11-10 961
一、基本概述 前言 Dubbo 框架设计采用了[微内核+插件]的方式，以此来保证框架整体的灵活性，在提升可定制性的同时，避免了自身的臃肿。通过将原本与内核集成在一起的组件分离出来，只提供了特定的接入接口，组件可以独立的发展、更改而不会对现有系统造成改动。 Dubbo 的扩展机制基于 Java 的 SPI，但又不同于它。这里由于篇幅缘故，不再介绍 JDK 的 SPI 机制。它具有以下特点： Dub...
[0115ZIZI]扩展库组织架构介绍
资资的博客
11-28 231
文章目录一.扩展库组织架构1.1 扩展库介绍1.2 扩展库一览图二.接口架构介绍2.1 扩展line库2.2 扩展circle库2.3 扩展arc库2.4 扩展rect库 一.扩展库组织架构 1.1 扩展库介绍 这次我主要扩展了四种接口，分别是圆(circle)、线(Line)、方形(rect)、弧线(arc)。 这四种接口分别包含在四个js文件中。 1.2 扩展库一览图 二.接口架构介绍 这边主要介绍每个库中的函数架构，函数的调用和方法可以查看下面的链接。相关库链接 2.1 扩展line库 2.2
Dubbo之扩展点ExtensionLoader
06-09
ExtensionLoader的实现方式是通过Java SPI机制和反射机制实现的，它会扫描META-INF/dubbo目录下的配置文件，将其中的扩展点实现类进行加载，并缓存起来。当需要获取某个扩展点的实现类时，ExtensionLoader会根据名称...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值