『Dubbo SPI源码分析』Wrapper 机制分析

于 2023-07-22 23:56:18 发布
阅读量84 收藏
点赞数
分类专栏： 『后端』 文章标签： dubbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzz805/article/details/131747361
版权

Dubbo Wrapper 机制分析

  1. 创建测试 demo
  • 首先创建一个接口，举例为 Car
package com.luban.dubbo_spi.api;

@SPI
public interface Car {
    public void getColor();
}
  • 根据接口，先创建一个实现类
package com.luban.dubbo_spi.impl;

public class RedCar implements Car {

    public void getColor() {
        System.out.println("red");
    }
}
  • 创建实现类的包装类
package com.luban.dubbo_spi.impl;

public class CarWrapper implements Car{

    private Car car;

    public CarWrapper(Car car) {
        System.out.println("12");
        this.car = car;
    }

    @Override
    public void getColor() {
        car.getColor();
    }

    @Override
    public void getColorForUrl(URL url) {
    }
}
  • 然后在 resources 创建一个目录 META-INF.services 目录
  • 并在 META-INF.services 目录中创建文件 com.luban.dubbo_spi.api.Car 一定要与接口同名
red = com.luban.dubbo_spi.impl.RedCar
com.luban.dubbo_spi.impl.CarWrapper
  • 创建主程序测试 @SPI
public class CarDemo {

    public static void main(String[] args) {
        ExtensionLoader<Car> extensionLoader =
                ExtensionLoader.getExtensionLoader(Car.class);

        Car redCar = extensionLoader.getExtension("red");
        redCar.getColor();
    }
}
  1. 首先通过 ExtensionLoader.getExtensionLoader() 获取加载器
public class CarDemo {

    public static void main(String[] args) {
        // 1. 获取加载器
        ExtensionLoader<Car> extensionLoader =
                ExtensionLoader.getExtensionLoader(Car.class);
       ...
    }
}
  1. 在执行 getExtensionLoader() 时，会先判断传入的 Car.class 有没有标注 @SPI。然后通过 EXTENSION_LOADERS 属性获取是否有创建好的 ExtensionLoader，没有就执行创建
public class ExtensionLoader<T> {

    // 缓存 ExtensionLoader，每个接口对应一个 ExtensionLoader
    private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();
    ...
    public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
        if (type == null) {// type = interface com.luban.dubbo_spi.api.Car
            throw new IllegalArgumentException("Extension type == null");
        }
        if (!type.isInterface()) { // 不能不是接口
            throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
        }
        if (!withExtensionAnnotation(type)) { // 不能没有 SPI 标注
            throw new IllegalArgumentException("Extension type(" + type +
                    ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
        }

        // 1. 通过 Car.class 从 EXTENSION_LOADERS 获取 ExtensionLoader
        ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        if (loader == null) {
            // 2. 没有则创建
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
            loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }
}
  1. 由于是一次创建，所以 objectFactory 赋值的是 AdaptiveExtensionFactory。AdaptiveExtensionFactory 创建流程可以参考 『Dubbo SPI源码分析』SPI 机制分析
public class ExtensionLoader<T> {
    
    private final Class<?> type;
    private final ExtensionFactory objectFactory;// 用于依赖注入
    ...
    private ExtensionLoader(Class<?> type) {
        this.type = type;
        // 拿出 ExtensionFactory 接口的所有实现类中的 Adaptive 实现
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }
}
  1. 获取了 ExtensionLoader 后，开始执行 getExtension() 获取实现的扩展类
public class CarDemo {

    public static void main(String[] args) {
        ExtensionLoader<Car> extensionLoader =
                ExtensionLoader.getExtensionLoader(Car.class);
        // 1. 获取接口的扩展类
        Car redCar = extensionLoader.getExtension("red");
       ...
    }
}
  1. 执行 getExtension() 方法时，先判断缓存实例 cachedInstances 中，是否存在创建的对象，没有的话，则执行 createExtension() 创建
public class ExtensionLoader<T> {

    // 缓存实例，每个接口的实现类对应一个实例
    private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>();
    ...
    public T getExtension(String name) {
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        // 1. 尝试从缓存中获取扩展类
        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) {
                    // 2. 获取不到扩展类实体，就创建，其中 name = red
                    instance = createExtension(name);
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }
}
  1. 执行 createExtension() 时，先执行 getExtensionClasses() 获取所有扩展类
public class ExtensionLoader<T> {
	...
    private T createExtension(String name) {
        // 1. 执行 getExtensionClasses() 获取扩展类
        Class<?> clazz = getExtensionClasses().get(name); 
        ...
    }
}
  1. 执行 getExtensionClasses() 时，尝试先从 ExtensionLoader 尝试先从自己的缓存集合 cachedClasses 获取集合，如果没有就需要去加载文件获取
public class ExtensionLoader<T> {

    private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();
    ....
    // 从所有文件里获取所有type接口的所有实现类并缓存
    private Map<String, Class<?>> getExtensionClasses() {
        // 1. 尝试从缓存集合中拿出集合
        Map<String, Class<?>> classes = cachedClasses.get();
        if (classes == null) {
            synchronized (cachedClasses) {
                classes = cachedClasses.get();
                if (classes == null) {
                    // 2. 没有就尝试加载文件
                    classes = loadExtensionClasses();
                    cachedClasses.set(classes);
                }
            }
        }
        return classes;
    }
}
  1. loadExtensionClasses() 会从几个关键目录中获取对应文件解析后存入集合中返回
public class ExtensionLoader<T> {

    private final Class<?> type;
    private static final Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*");
    private String cachedDefaultName;
    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/";
    ...
    private Map<String, Class<?>> loadExtensionClasses() {
        final SPI defaultAnnotation = type.getAnnotation(SPI.class); // interface org.apache.dubbo.common.extension.ExtensionFactory
        // SPI后面的值就是默认的实现的类，只能指定一个实现类
        if (defaultAnnotation != null) {
            String value = defaultAnnotation.value();// 一开始 interface org.apache.dubbo.common.extension.ExtensionFactory 的 SPI 没标注默认值，
            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];
                }
            }
        }

        // 是一个 map，key 是别名，value 是具体的实现类
        // 会从不同的地方寻找接口的所有实现类，这就是扩展的实现
        // 主要会从三个地方找
        // META-INF/dubbo/
        // META-INF/dubbo/internal/
        // META-INF/services/
        Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
        // 1. 加载目录中的文件
        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; // 找到 org.apache.dubbo.common.extension.ExtensionFactory 所有的地方的实现类
    }
}
  1. loadDirectory() 先去拼接目录 + 接口名称，得到资源定位符后再去加载文件内容
public class ExtensionLoader<T> {
    ...
    private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type) {// type：org.apache.dubbo.common.extension.ExtensionFactory
        String fileName = dir + type;
        try {
            Enumeration<java.net.URL> urls;
            ClassLoader classLoader = findClassLoader();
            if (classLoader != null) {
                urls = classLoader.getResources(fileName);
            } else {
                urls = ClassLoader.getSystemResources(fileName);
            }
            if (urls != null) {
                while (urls.hasMoreElements()) {
                    // 单个资源的url
                    java.net.URL resourceURL = urls.nextElement(); 
                    // 1. 加载文件的内容
                    loadResource(extensionClasses, classLoader, resourceURL);
                }
            }
        } catch (Throwable t) {
            logger.error("Exception when load extension class(interface: " +
                    type + ", description file: " + fileName + ").", t);
        }
    }

}
  1. 解析文件中的每一行内容后，通过 loadClass() 来校验和加载扩展类
public class ExtensionLoader<T> {
    ...
    private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), "utf-8"));
            try {
                String line;
                while ((line = reader.readLine()) != null) {
                    final int ci = line.indexOf('#');
                    if (ci >= 0) {
                        line = line.substring(0, ci);
                    }
                    line = line.trim();
                    if (line.length() > 0) {
                        try {
                            String name = null;
                            int i = line.indexOf('=');
                            if (i > 0) {
                                name = line.substring(0, i).trim();
                                line = line.substring(i + 1).trim();
                            }
                            if (line.length() > 0) {
                                // 1. name 就是加载文件中的别名，line 就是实现类全名。加载扩展类
                                loadClass(extensionClasses, resourceURL, Class.forName(line, true, classLoader), name);
                            }
                        } catch (Throwable t) {
                            IllegalStateException e = new IllegalStateException("Failed to load extension class(interface: " + type + ", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);
                            exceptions.put(line, e);
                        }
                    }
                }
            } finally {
                reader.close();
            }
        } catch (Throwable t) {
            logger.error("Exception when load extension class(interface: " +
                    type + ", class file: " + resourceURL + ") in " + resourceURL, t);
        }
    }
}
  1. loadClass() 首先读取的是第一行内容 red = com.luban.dubbo_spi.impl.RedCar 这时候先把类存入 cachedNames 属性中。再遍历下一行 com.luban.dubbo_spi.impl.CarWrapper 把包装类存入 cachedWrapperClasses 属性中，然后返回
  • 重点
    • 判断是否为包装类，只需要判断是否只有包含 Car.class 的构造函数
public class ExtensionLoader<T> {
    
    private final Class<?> type;
    private volatile Class<?> cachedAdaptiveClass = null;
    private static final Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*");
    private final Map<String, Object> cachedActivates = new ConcurrentHashMap<String, Object>();
    ...
    private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException {
        // 是不是接口的实现类
        if (!type.isAssignableFrom(clazz)) {
            throw new IllegalStateException("Error when load extension class(interface: " +
                    type + ", class line: " + clazz.getName() + "), class "
                    + clazz.getName() + "is not subtype of interface.");
        }
        // 实现类上是否有 Adaptive 注解，这段代码的意思就是一个接口的实现类中只有一个 Adaptive
        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());
            }
            // 2. 实现类是不是 wrapper类，判断逻辑是这个实现类的构造方法的参数是不是有且仅有一个参数，且参数类型是接口类型
        } else if (isWrapperClass(clazz)) { 
            // wrapper类可以有多个
            Set<Class<?>> wrappers = cachedWrapperClasses;
            if (wrappers == null) {
                cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
                wrappers = cachedWrapperClasses;
            }
            wrappers.add(clazz);
        } else {
            clazz.getConstructor();
            if (StringUtils.isEmpty(name)) {
                // 如果在文件里没有配名字，可以去看实现类上是否有Extension注解，可以取这个注解的值作为名字
                // 如果没有Extension这个注解，则取实现类的simple名，并进行简化，比如接口为CarService, 实现类为RedCarService, 那么名字则为red
                name = findAnnotationName(clazz);
                if (name.length() == 0) {
                    throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
                }
            }
            // 如果配置的名字使用逗号隔开的
            String[] names = NAME_SEPARATOR.split(name);
            if (names != null && names.length > 0) {
                ...
                // 1. red = com.luban.dubbo_spi.impl.RedCar 存入 cachedNames 缓存中
                for (String n : names) {
                    // 配了多个名字cachedName也只会缓存一个
                    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());
                    }
                }
            }
        }
    }
    
    // 判断是否为包装类依据
    private boolean isWrapperClass(Class<?> clazz) {
        try {
            clazz.getConstructor(type);
            return true;
        } catch (NoSuchMethodException e) {
            return false;
        }
    }
}
  1. 加载完各个目录的文件后，就会得到对应的 extensionClasses 集合，并根据 name 获取到对应的类，并创建实例。因为在加载时，会把所有的包装类存入 cachedWrapperClasses 集合中，通过遍历，该实例进行包装，最后返回包装的扩展类以供使用
public class ExtensionLoader<T> {
    // 实现类对应的实例
    private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();
    ...
    private T createExtension(String name) {
        Class<?> clazz = getExtensionClasses().get(name); // 取出对应的实现类
        if (clazz == null) {
            throw findException(name);
        }
        try {
            // 1. 生成实例并缓存
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            injectExtension(instance);
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            if (CollectionUtils.isNotEmpty(wrapperClasses)) {
                // 2. 遍历所有包装类，对实例进行包装
                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. 总结
    在这里插入图片描述
Gavinjou大笨象
关注
专栏目录
SpringCloud Alibaba系列——6Dubbo的SPI机制分析
Eclipse_2019的博客
07-26 465
JDK中的SPI应用；Dubbo中的SPI机制；Dubbo中的四种SPI使用方式；Dubbo中的SPI和JDK中的SPI区别
dubbo源码分析学习---dubbo spi机制
qq_36697880的博客
11-01 284
一、简介 SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用，比如 Dubbo 就是通过 SPI 机制加载所有的组件。不过，Dubbo 并未使用 Java 原生的 SPI 机制，而是对其进行了增强，使其能够更好的满足...
dubbo Wrapper
weixin_30322405的博客
06-05 213
1 public com.alibaba.dubbo.common.bytecode.Wrapper0 exteneds Wrapper{ 2 3 4 public static String[] pns; 5 public static java.util.Map pts; 6 public static String[] mns; ...
Dubbo Wrapper
CoderLi
03-27 597
今天谈谈 Dubbo 的 org.apache.dubbo.common.bytecode.Wrapper 类 Dubbo 依赖该工具在服务提供者端接收处理请求的时候、直接调用提供服务的 service 相对于传统的反射、性能其实有很大的提升 private static Wrapper makeWrapper(Class<?> c) { String name = c.getName(); ClassLoader cl = ClassUtils.getClassLoade
dubbo学习篇之dubbo内核解析（三）Wrapper
技术随笔
05-12 2004
dubbo内核解析dubbo的内核WrapperWrapper的规范Wrapper的代码实现Wrapper源码解析加载Wrapper类组装Wrapper类 dubbo的内核 dubbo所有功能都是基于dubbo内核之上完成的，dubbo内核由四部分构成，分别为SPI,Adaptive,Wrapper,Activate。 而dubbo的内核设计原则，也是我们所熟悉的aop,ioc与动态编译compiler,这些称之为dubbo的内核原理。 Wrapper Wrapper机制，即扩展点自动包装。Wrapper
Dubbo Wrapper 解析
changjh1的博客
06-08 547
发现别人写的很好了，这只是自己记录一下。摘抄一下，以后遇到问题，再更新 Wrapper的规范 Wrapper 机制不是通过注解实现的，而是通过一套 Wrapper 规范实现的。 Wrapper 类在定义时需要遵循如下规范： 该类要实现 SPI 接口 该类中要有 SPI 接口的引用 该类中必须含有一个含参的构造方法且参数只能有一个类型为SPI借口 在接口实现方法中要调用 SPI 接口引用对象的相应方法 该类名称以 Wrapper 结尾 ...
Dubbo源码---Wrapper详解
qq_37721097的博客
02-05 397
Dubbo源码篇---Wrapper详解
dubbo源码分析之八-dubbo的spi机制
热门推荐
liushangzaibeijing的博客
07-18 5万+
本片博文以spi机制为切入点，首先了解spi机制，介绍了java自己的SPI实现方式和源码分析，并通过其缺点引出了Dubbo的SPI机制，通过对其使用示例、流程、源码分析等详细分析了其相关流程，其中对ExtensionLoader、@Adaptive,@Activate,@SPI注解进行使用介绍。希望这边文章能让读者很好的了解java SPI和Dubbo的SPI机制。
Dubbo源码分析（一）dubbo SPI扩展点加载之扩展点自动包装
qq_14957991的博客
12-10 481
dubbo最核心的思想就是就是SPI服务发现，可以实现动态加载实现类。http://dubbo.apache.org/zh-cn/docs/dev/SPI.html 在dubbo的官方文档中用扩展点的介绍。我们可以看到，dubbo扩展点主要有四大特性 扩展点自动包装。 扩展点自动装配. 扩展点自适应. 扩展点自动激活 接下来我会以Dubbo的Protocol 接口为例来说明一下dubbo的四大特...
从源码的角度带你看懂dubbo的spi机制
weixin_45630885的博客
02-09 696
dubbo spi机制源码分析
Dubbo Wrapper机制
最新发布
一个格子衫男孩儿的笔记本
07-06 239
但是这么一来，如何生成动态代理类的逻辑就至关重要了，而且万一我们以后有自主定制的诉求，想修改这段生成代理类的这段逻辑，反而受 Cglib 库的牵制。1.JDK动态代理是通过反射创建对象并反射调用对象的方法，而 Dubbo 本身是一款追求高性能的调用框架，反射层面的各种耗时开销是不能容忍的，因此这是 JDK 代理的一个不足。​Wrapper，很多人从单词层面来解读，很容易理解成是 Java 包装类，或者是装饰器设计模式，其实都不是，它是 Dubbo 中的一种动态生成的代理类。
分布式RPC系统框架Dubbo-23Dubbo的内核解析-Wrapper机制
诸般世界
10-08 732
Wrapper机制，即扩展类的包装机制；就是对扩展类中的SPI接口方法进行增强，进行包装，是AOP思想的提现，是Wrapper(装饰者)设计模式的应用(是一种特例的装饰者设计模式)，一个SPI可以包含多个Wrapper。 注意，Wrapper类不属于“拓展类”； 1.Wrapper类规范 Wrapper机制不是通过注解实现的，而是通过Wrapper类实现，Wrapper类在定义时需要遵循如下规范： 类要实现SPI接口； 类中要有SPI接口的引用； 在接口实现方...
Dubbo中Wrapper类的原理与实例
luzhensmart的专栏
09-03 1133
Dubbo Wrapper 可以认为是一种反射机制。它既可以读写目标实例的字段，也可以调用目标实例的方法。比如 Car是接口；RaceCar是实现类，实现了Car；ferrari和porsche是RaceCar的两个实例 Dubbo为接口Car生成一个Warpper子类，比如Wrapper0；然后创建Wrapper0的实例wrapper0 通过wrapper0#setPropertyValue来修改ferrari的字段，也可以修改porsche的字段 通过wrapper0#invokeMethod来
DUBBO扩展ExtensionLoader 之接口Wrapper实现剖析
weixin_45283443的博客
08-01 301
起因，在服务接口的发布过程中，其中invoker会经过协议的导出后生成一个Exporter，如下图： 上图代码中的 Exporter<?> exporter = protocol.export(invoker);这句代码里面会涉及到protocol的Wrapper 。其中的protocol是通过dubbo 的SPI机制动态生成的适配类产生的对象。其定义在ServiceConfig类中...
Dubbo源码篇02---从泛化调用探究Wrapper机制的原理
m0_53157173的博客
05-06 1143
从泛化调用探究Wrapper机制的原理
Dubbo的Wrapper类原理接口 -- 实现类似AOP的效果
之城的专栏
08-20 1214
Dubbo的wrapper 类实际上也是SPI接口的扩展类， 只是这个扩展类必须以wrapper命名结尾，必须有一个参数的构造方法而已。 在正常获取SPI接口的时候实际上获取的是Wrapper的实现类， 这个实现类使用静态代理方式可以代理SPI实现类而已。
Dubbo框架架构
niyuelin1990的博客
01-14 4592
一、整体框架 1、Dubbo介绍 Apache Dubbo是一款高性能、轻量级的开源Java RPC框架。 它有三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。 1、Dubbo特点 1、面向接口代理的高性能RPC调用：提供高性能的基于代理的远程调用能力，服务以接口为粒度，为开发者屏蔽远程调用底层细节。 2、智能负载均衡：内置多种负载均衡策略，智能感知下游节点健康状...
Dubbo（八）内核解析（DubboSPI机制、Adaptive机制、Wrapper机制、Activate机制）
语雀同名：犬豪 yuque.com/qhao
09-06 1516
Dubbo 的内核解析 所谓 Dubbo 的内核是指，Dubbo 中所有功能都是基于它之上完成的，都是由它作为基础的。Dubbo 内核的工作原理由四部分构成：服务发现机制 SPI、自适应机制 Adaptive、包装机制 Wrapper 与激活机制 Activate。 Dubbo 通过这四种机制实现了对插件的 IoC、AOP，实现了对自动生成类的动态编译 Compile。 1. JDK 的 SPI 机制 1.1 简介 SPI，Service Provider Interface，服务提供者接口，是一种
Javassist入门与实际应用
sinat_28979467的博客
10-24 684
什么是Javassits Javasists(Java Programming Assistant) 使java字节码操作变得更加简单。主要用于编辑java中的字节码的类库，使java程序在运行时定义一个新类，并在jvm加载时修改类文件。Javassist 提供两个级别的 API：源级别和字节码级别。 Javassits几个重要的类 ClassPool 存储类容器 ClassPool cla...
Dubbo SPI源码深度解析：打造高效分布式服务
"深度解析Dubbo的可扩展机制SPI源码：从理论到实践，打造高效、稳定的分布式服务框架" Dubbo的可扩展性是通过其Service Provider Interface (SPI) 实现的，这是一种允许用户自定义扩展点并动态加载的机制。SPI的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值