dubbo核心---SPI（一）

最新推荐文章于 2024-09-06 22:12:43 发布
最新推荐文章于 2024-09-06 22:12:43 发布
阅读量156 收藏
点赞数
分类专栏： # 分布式服务治理框架dubbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41301079/article/details/104636745
版权

一、SPI

  1. java中的SPI（service provider interface），数据库驱动 java.sql.Driver, 通过加载在MATA-INF/services下以java.sql.Driver,命名的文件
    在这里插入图片描述
    数据库驱动厂商自己实现，比如mysql
    在这里插入图片描述

  2. dubbo很好的借鉴了这种SPI机制，dubbo会加载META-INF/services，META-INF/dubbo和META-INF/dubbo/internal三个目录下的文件，我们定义一个MyProtocol的协议和org.apache.dubbo.rpc.Protocol的文件
    在这里插入图片描述
    文件内容为：myprotocol=com.gp.patterns.MyProtocol
    在这里插入图片描述
    利用dubbo提供的api测试
    在这里插入图片描述
    执行后，端口为9527，我们看下ExtensionLoader都做了什么。

  3. ExtensionLoader分析

    #1. 获取ExtensionLoader
public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
	//EXTENSION_LOADERS缓存对应type的ExtensionLoader
    ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
    if (loader == null) {
        EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
        loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
    }
    return loader;
}

    #2.获取对应name的实例
public T getExtension(String name) {
    if (StringUtils.isEmpty(name)) {
        throw new IllegalArgumentException("Extension name == null");
    }
    //使用默认配置
    if ("true".equals(name)) {
        return getDefaultExtension();
    }
    //用于保存name对应的实例
    Holder<Object> holder = getOrCreateHolder(name);
    Object instance = holder.get();
    if (instance == null) {
        synchronized (holder) {
            instance = holder.get();
            if (instance == null) {
            	#3. 创建这个实例
                instance = createExtension(name);
                holder.set(instance);
            }
        }
    }
    return (T) instance;
}

    #3. 创建这个实例
private T createExtension(String name) {
	#4.获取扩展点class
    Class<?> clazz = getExtensionClasses().get(name);
    if (clazz == null) {
        throw findException(name);
    }
    try {
    	//EXTENSION_INSTANCES缓存这个扩展点
        T instance = (T) EXTENSION_INSTANCES.get(clazz);
        if (instance == null) {
            EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
            instance = (T) EXTENSION_INSTANCES.get(clazz);
        }
        //dubbo的set方法注入实例，用到了dubbo SPI的自适应扩展点，要求set方法的参数必须是一个扩展点
        injectExtension(instance);
        Set<Class<?>> wrapperClasses = cachedWrapperClasses;
        if (CollectionUtils.isNotEmpty(wrapperClasses)) {
            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 + ") couldn't be instantiated: " + t.getMessage(), t);
    }
}

    #4.获取扩展点class
private Map<String, Class<?>> getExtensionClasses() {
	//cachedClasses是一个Holder类
    Map<String, Class<?>> classes = cachedClasses.get();
    if (classes == null) {
        synchronized (cachedClasses) {
            classes = cachedClasses.get();
            if (classes == null) {
            	#5.加载扩展点class  并缓存
                classes = loadExtensionClasses();
                cachedClasses.set(classes);
            }
        }
    }
    return classes;
}

    #5.加载扩展点class  并缓存
private Map<String, Class<?>> loadExtensionClasses() {
	#6.缓存默认的扩展点   @SPI注解的默认值
    cacheDefaultExtensionName();

	//将三个目录下的文件里面对应的key value 加载进extensionClasses 中
    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;
}

    #6.缓存默认的扩展点   @SPI注解的默认值
private void cacheDefaultExtensionName() {
    final SPI defaultAnnotation = type.getAnnotation(SPI.class);
    if (defaultAnnotation != null) {
        String value = defaultAnnotation.value();
        if ((value = value.trim()).length() > 0) {
            String[] names = NAME_SEPARATOR.split(value);
            if (names.length > 1) {
                throw new IllegalStateException("More than 1 default extension name on extension " + type.getName()
                        + ": " + Arrays.toString(names));
            }
            if (names.length == 1) {
                cachedDefaultName = names[0];
            }
        }
    }
}

二、dubbo的扩展点

  1. dubbo的静态扩展点

    1.静态扩展点
public class ExtensionTest {

    public static void main(String[] args) {
        //通过名字获取的就是静态扩展点
        Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension("myprotocol");
        System.out.println(protocol.getDefaultPort());
    }
    
}

  2. dubbo的自适应扩展点

    1. 自适应扩展点
public class ExtensionTest {

    public static void main(String[] args) {
        //自适应扩展点，返回AdaptiveCompiler，
        Compiler compiler = ExtensionLoader.getExtensionLoader(Compiler.class).getAdaptiveExtension();
        compiler.compile("", null);
        System.out.println(compiler);
    }

}


    1. 根据name自适应用什么compiler， dubbo提供两种 jdk和javassist，默认是@SPI("javassist")，
2.  @Adaptive在类上表示是一个自适应扩展类
@Adaptive
public class AdaptiveCompiler implements Compiler {

    private static volatile String DEFAULT_COMPILER;

    public static void setDefaultCompiler(String compiler) {
        DEFAULT_COMPILER = 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);
    }

}


    1.@Adaptive如果在方法上，则动态代理生成对应的扩展点
2.ExetensionLoader的loadClass方法会判断是不是标注在类上，
public T getAdaptiveExtension() {
   ....
      instance = createAdaptiveExtension();
   ....
    return (T) instance;
}

private T createAdaptiveExtension() {
    try {
        return injectExtension((T) getAdaptiveExtensionClass().newInstance());
    } catch (Exception e) {
        throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
    }
}

private Class<?> getAdaptiveExtensionClass() {
    getExtensionClasses();
    //loadClass会判断@Adaptive标注在哪里
    //类上
    if (cachedAdaptiveClass != null) {
        return cachedAdaptiveClass;
    }
    //方法上
    return cachedAdaptiveClass = createAdaptiveExtensionClass();
}

private Class<?> createAdaptiveExtensionClass() {
    String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
    ClassLoader classLoader = findClassLoader();
    org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
    return compiler.compile(code, classLoader);
}

  3. dubbo的激活扩展点

    1.类似Springboot的Conditional，

public class ExtensionTest {

    public static void main(String[] args) {
        //激活扩展点
        ExtensionLoader<Filter> extensionLoader = ExtensionLoader.getExtensionLoader(Filter.class);
        URL url = new URL("", "", 0);
        //url驱动，添加参数就像 dubbo的：@Service(cache = FilterConstants.CACHE_KEY)
        //加了cache，就加载CacheFilter
        url = url.addParameter("cache", "cache");
        List<Filter> filters = extensionLoader.getActivateExtension(url, "cache");
        System.out.println(filters.size());
    }

}

    1.group表示能用在服务端还是客户端
@Activate(group = {CONSUMER, PROVIDER}, value = CACHE_KEY)
public class CacheFilter implements Filter {	
	
｝
帮我还花呗
关注
专栏目录
dubbo之SPI解析
qiangcai的专栏
08-31 2万+
一 概述    一大早来上班，准备写CSDN博客，发现前面的文章下有人评价，有点欣喜，有点安慰。算是对我这段时间作品的回报和我前进的动力吧！继续写吧.. 前面阅读dubbo源码经常看到Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();    这种类型的代码来获
Dubbo SPI
小城我家
09-10 143
dubbo spi SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用，比如 Dubbo 就是通过 SPI 机制加载所有...
Dubbo源码剖析-SPI机制(超详细深度剖析篇)
最新发布
weixin_55721317的博客
09-06 1038
Dubbo源码剖析-SPI篇
dubbo SPI
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
02-05 209
RMI rmi clinet: public class RmiClient { public static void main(String[] args) throws RemoteException, NotBoundException, MalformedURLException { String remoteAddr = "rmi://localhos...
dubbo SPI
weixin_33733810的博客
05-17 194
什么是spi dubbo的所有功能都拆分并且抽象为interface,通过SPI查找这些interface的实现,并且通过url组合起来,就成了一个完整的rpc框架。SPI可理解为根据接口，找不同的实现类。 为什么要重新造一个 那么JDK已经有了SPI，dubbo为何要自己写一个？有没比SPI更好的机制去加载接口的实现类？ 前面我们写了一个JDK的SPI例子，那么它有什么不好呢？ 1.JDK中sp...
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是其一个重要的版本，包含了众多优化和改进。在本文中，我们将深入探讨这个版本的核心特性、设计理念以及实际应用中的关键知识点...
domain incubator-dubbo-dubbo-2.5.8版本
02-25
一、Dubbo核心概念 1. 服务提供者（Provider）：暴露服务的服务方。 2. 服务消费者（Consumer）：调用远程服务的服务方。 3. 注册中心（Registry）：服务提供者和消费者通过注册中心发现彼此，实现服务的注册与发现...
alibaba-dubbo-dubbo-2.5.8-4-gc8093cf.zip_dubbo 2.5_dubbo 2.8.4_d
09-15
本文将围绕标题中的"alibaba-dubbo-dubbo-2.5.8-4-gc8093cf.zip"和"2.8.4"这两个版本，深入解析Dubbo的核心特性，并探讨两个版本之间的差异。 首先，让我们聚焦于Dubbo 2.5.8。这一版本是在2.5系列的一个稳定迭代，...
dubbo-dubbo-3.2.6.zip
09-15
一、Dubbo的核心特性 1. **服务注册与发现**：Dubbo支持基于Zookeeper、Eureka等注册中心的服务注册与发现，实现了服务的动态管理和负载均衡，使得服务提供者和服务消费者能够透明地进行交互。 2. **高性能RPC**：...
Dubbo-SPI
justimkiss的专栏
11-06 469
SPI1. 定义 SPI即Service Provider Interface，服务提供接口。 ​ 系统中抽象的各个模块，往往有很多不同的实现方案，比如日志模块，xml解析模块，jdbc模块的方案等。面向对象的设计里，我们一般推荐模块之间基于接口编程，模块之间不对实现类进行硬编码。一旦代码里设计具体的实现类，就违反了可插拔的原则，如果需要替换一种实现，就需要修改代码。​ 为了实现在模块装
dubbo之SPI
懒猫的脚印
03-12 229
dubbo spi的机制贯穿着dubbo的整个架构
dubbo的SPI
qq_25106373的博客
03-16 150
SPI(Service Provider Interface) 本质是 将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。 在Java中SPI是被用来设计给服务提供商做插件使用的。基于策略模式 来实现动态加载的机制。我们在程序只定义一个接口，具体的实现交个不同的服务提供者；在程序启动的时候，读取配置文件，由配置确定要调用哪一个实现； 通过 SPI 机制为我们的程序提供拓展功能，在dubbo中，基于 SPI，我们可以很容易的对 Du
Dubbo 之 SPI
qq_36194388的博客
09-07 556
1.1 SPI简介 SPI 全称为 (Service Provider Interface) ，是JDK内置的一种服务提供发现机制。 目前有不少框架用它 来做服务的扩展发现，简单来说，它就是一种动态替换发现的机制。使用SPI机制的优势是实现解耦， 使得第三方服务模块的装配控制逻辑与调用者的业务代码分离。 1.2 JDK中的SPI java中如果想要使用SPI功能，先提供标准服务接口，然后再提供相关接口实现和调用者。这样就可以通 过SPI机制中约定好的信息进行查询相应的接口实现。 SPI遵循如下约定： 1、
dubbo中的SPI
weixin_45804540的博客
09-10 160
dubbo中的SPI https://blog.csdn.net/qiangcai/article/details/77750541
dubbo解析-SPI核心类ExtensionLoader详解
龚厂长的博客
04-27 397
SPI提供了一种插件功能，可以对组件替换。dubbo的各层中，除了服务代理层和配置层之外，其他层组件都可以使用SPI替换。 本文介绍SPI的核心类ExtensionLoader中的几个方法。ExtensionLoader实现了SPI功能。
Dubbo SPI介绍
在路上2017的专栏
10-08 174
为什么要设计adaptive？注解在类上和注解在方法上的区别？ adaptive设计的目的是为了识别固定已知类和扩展未知类。 1.注解在类上：代表人工实现，实现一个装饰类（设计模式中的装饰模式），它主要作用于固定已知类， 目前整个系统只有2个，AdaptiveCompiler、Adapti...
深入解析Dubbo SPI的设计原理与实现
一、Dubbo SPI概述 Apache Dubbo是一个高性能、轻量级的Java RPC框架，它在内部使用了SPI（Service Provider Interface，服务提供接口）机制来加载各种扩展点。Dubbo的SPI机制是对Java原生SPI的增强，它解决了Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值