『Dubbo SPI源码分析』@Adaptive 机制分析

最新推荐文章于 2024-05-06 10:37:06 发布
最新推荐文章于 2024-05-06 10:37:06 发布
阅读量74 收藏
点赞数
分类专栏： 『后端』 文章标签： dubbo java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzz805/article/details/131865298
版权

『Dubbo SPI源码分析』@Adaptive 机制分析

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

@SPI
public interface Car {
    public void getColor();
    
    @Adaptive
    public void getColorForUrl(URL url);
}
- 根据接口，先创建一个实现类
```java
package com.luban.dubbo_spi.impl;

public class RedCar implements Car {

    public void getColor() {
        System.out.println("red");
    }
    
    @Override
    public void getColorForUrl(URL url) {
    }
}
  • 再创建一个实现类
package com.luban.dubbo_spi.impl;

public class BlackCar implements Car {

    public void getColor() {
        System.out.println("black");
    }

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

    public static void main(String[] args) {

        ExtensionLoader<Car> carLoader = ExtensionLoader.getExtensionLoader(Car.class);
        Car adCar = carLoader.getAdaptiveExtension();

        Map<String, String> map = new HashMap<>();
        map.put("car", "black");
        URL url = new URL("","",1, map);
        adCar.getColorForUrl(url);
    }
}
  1. @Adaptive 除了可以标记在自定义的 Adaptive 类（即 com.luban.dubbo_spi.impl.AdaptiveCar 类）上面以外（『Dubbo SPI源码分析』依赖注入机制分析），还可以标记在接口的对应方法中，获取 dubbo 帮你实现的代理类，首先也是按照老套路，先执行 ExtensionLoader.getExtensionLoader() 扫描配置文件中实现了 com.luban.dubbo_spi.api.Car 的类以后，就可以从中获取到 Adaptive 扩展类
public class CarDemo {

    public static void main(String[] args) {
		// 1. 获取实现了 com.luban.dubbo_spi.api.Car 接口的扩展类
        ExtensionLoader<Car> carLoader = ExtensionLoader.getExtensionLoader(Car.class);
        // 2. 获取 Adaptive 扩展类
        Car adCar = carLoader.getAdaptiveExtension();
        ...
    }
}
  1. com.luban.dubbo_spi.api.Car 的 ExtensionLoader 先判断是否有过 Adaptive 实例对象，如果有则直接返回，没有就创建
public class ExtensionLoader<T> {
    private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>();
    private volatile Throwable createAdaptiveInstanceError;
    ...
    public T getAdaptiveExtension() {
        // 一个接口只能有一个Adaptive实现
        Object instance = cachedAdaptiveInstance.get();
        if (instance == null) {
            if (createAdaptiveInstanceError == null) {
                synchronized (cachedAdaptiveInstance) {
                    // 1. 尝试从缓存中获取 Adaptive 对象
                    instance = cachedAdaptiveInstance.get();
                    if (instance == null) {
                        try {
                            // 2. 没有就创建
                            instance = createAdaptiveExtension(); 
                            cachedAdaptiveInstance.set(instance);
                        } catch (Throwable t) {
                            createAdaptiveInstanceError = t;
                            throw new IllegalStateException("fail to create adaptive instance: " + t.toString(), t);
                        }
                    }
                }
            } else {
                throw new IllegalStateException("fail to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError);
            }
        }

        return (T) instance;
    }
}
  1. ExtensionLoader 会调用 getAdaptiveExtensionClass() 获取 Adaptive 扩展类，其中依赖注入就忽略了，因为配置的 case 没有依赖注入
public class ExtensionLoader<T> {
    ...
    @SuppressWarnings("unchecked")
    private T createAdaptiveExtension() {
        try {
            // 1. 获取 Adaptive 扩展类
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
        }
    }
}
  1. ExtensionLoader 继续调用 createAdaptiveExtensionClass() 方法，用于生成代理类
public class ExtensionLoader<T> {
    ...
    private Class<?> createAdaptiveExtensionClass() {
    	// 1. 生成代理类的代码
        String code = createAdaptiveExtensionClassCode();
		...
    }
}
  1. 首先遍历每个方法，判断存在一个方法有注释 @Adaptive，没有则抛异常。找到有注释的方法后，先找到存在 URL.class 入参的位置，生成校验 URL 入参代码。然后从 @Adaptive 的 value 属性中取值，没有的话，只能用类名小写代替，即为 “car”（这个参数是 URL 上的占位符 key，用作取数据）。然后判断方法参数列表是否有 org.apache.dubbo.rpc.Invocation 入参，有也生成相应的校验入参代码。最后根据 value 值，生成获取参数的代码，并返回
  • 重点
    • @Adaptive 注解中，如果填写了 value 值，代表指定占位符名称，没填写，则用类名小写
    • 一定要填入 URL.class 参数，除非自定义其他 protocol 协议
    • 没标注 @Adaptive 注解的方法，使用会抛异常
    • 可以再添加一个 org.apache.dubbo.rpc.Invocation 入参
  • 生成的代理代码如下
package com.luban.dubbo_spi.api;
import org.apache.dubbo.common.extension.ExtensionLoader;
public class Car$Adaptive implements com.luban.dubbo_spi.api.Car {
    public void getColorForUrl(org.apache.dubbo.common.URL arg0) {
        if (arg0 == null) throw new IllegalArgumentException("url == null");
        org.apache.dubbo.common.URL url = arg0;
        String extName = url.getParameter("car");
        if(extName == null) throw new IllegalStateException("Fail to get extension(com.luban.dubbo_spi.api.Car) name from url(" + url.toString() + ") use keys([car])");
        com.luban.dubbo_spi.api.Car extension = (com.luban.dubbo_spi.api.Car)ExtensionLoader.getExtensionLoader(com.luban.dubbo_spi.api.Car.class).getExtension(extName);extension.getColorForUrl(arg0);
    }
    public void getColor() {throw new UnsupportedOperationException("method public abstract void com.luban.dubbo_spi.api.Car.getColor() of interface com.luban.dubbo_spi.api.Car is not adaptive method!");
    }
}
  • 源代码
public class ExtensionLoader<T> {
	private final Class<?> type;
	private String cachedDefaultName;
	...
    private String createAdaptiveExtensionClassCode() {
        StringBuilder codeBuilder = new StringBuilder();
        Method[] methods = type.getMethods();
        boolean hasAdaptiveAnnotation = false;
        // 1. 看是不是所有方法上都没有 Adaptive 注解，都没有则会抛异常
        for (Method m : methods) {
            if (m.isAnnotationPresent(Adaptive.class)) {
                hasAdaptiveAnnotation = true;
                break;
            }
        }
        // 没有 Adaptive 注解，就抛异常
        if (!hasAdaptiveAnnotation) {
            throw new IllegalStateException("No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");
        }

        // 生成包，import, 类名
        codeBuilder.append("package ").append(type.getPackage().getName()).append(";");
        codeBuilder.append("\nimport ").append(ExtensionLoader.class.getName()).append(";");
        codeBuilder.append("\npublic class ").append(type.getSimpleName()).append("$Adaptive").append(" implements ").append(type.getCanonicalName()).append(" {");

        for (Method method : methods) {
            Class<?> rt = method.getReturnType();
            Class<?>[] pts = method.getParameterTypes();
            Class<?>[] ets = method.getExceptionTypes();

            Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
            StringBuilder code = new StringBuilder(512);
            // 2. 如果方法上没有 Adaptive 注解，则加上抛异常代码
            if (adaptiveAnnotation == null) {
                code.append("throw new UnsupportedOperationException(\"method ")
                        .append(method.toString()).append(" of interface ")
                        .append(type.getName()).append(" is not adaptive method!\");");
            } else {
                // 3. 寻找 URL 参数所在位置
                int urlTypeIndex = -1;
                for (int i = 0; i < pts.length; ++i) {
                    if (pts[i].equals(URL.class)) {
                        urlTypeIndex = i;
                        break;
                    }
                }
                
                // 4. 存在 URL 参数，就从 URL 中取数据，并判空
                if (urlTypeIndex != -1) {
                    // Null Point check
                    String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"url == null\");",
                            urlTypeIndex);
                    code.append(s);

                    s = String.format("\n%s url = arg%d;", URL.class.getName(), urlTypeIndex);
                    code.append(s);
                }
                else {
                    String attribMethod = null;
                    // 如果没有 URL 参数，就从其他参数中去找是不是有返回值为 URL 的 get 方法
                    LBL_PTS:
                    for (int i = 0; i < pts.length; ++i) {
                        Method[] ms = pts[i].getMethods();
                        for (Method m : ms) {
                            String name = m.getName();
                            if ((name.startsWith("get") || name.length() > 3)
                                    && Modifier.isPublic(m.getModifiers())
                                    && !Modifier.isStatic(m.getModifiers())
                                    && m.getParameterTypes().length == 0
                                    && m.getReturnType() == URL.class) {
                                urlTypeIndex = i;
                                attribMethod = name;
                                break LBL_PTS;
                            }
                        }
                    }
                    if (attribMethod == null) {
                        throw new IllegalStateException("fail to create adaptive class for interface " + type.getName()
                                + ": not found url parameter or url attribute in parameters of method " + method.getName());
                    }

                    // Null point check
                    String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"%s argument == null\");",
                            urlTypeIndex, pts[urlTypeIndex].getName());
                    code.append(s);
                    s = String.format("\nif (arg%d.%s() == null) throw new IllegalArgumentException(\"%s argument %s() == null\");",
                            urlTypeIndex, attribMethod, pts[urlTypeIndex].getName(), attribMethod);
                    code.append(s);

                    s = String.format("%s url = arg%d.%s();", URL.class.getName(), urlTypeIndex, attribMethod);
                    code.append(s);
                }
                // 5. 取 adaptive 注解的值，可以是个数组，如果没有值，则会取类名，LoadBalance->load.balance
                String[] value = adaptiveAnnotation.value();
                if (value.length == 0) {
                    String splitName = StringUtils.camelToSplitName(type.getSimpleName(), ".");
                    value = new String[]{splitName};
                }
                // 6. 判断参数列表中是否有 Invocation 对象
                boolean hasInvocation = false;
                for (int i = 0; i < pts.length; ++i) {
                    if (("org.apache.dubbo.rpc.Invocation").equals(pts[i].getName())) {
                        // Null Point check
                        String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"invocation == null\");", i);
                        code.append(s);
                        s = String.format("\nString methodName = arg%d.getMethodName();", i);
                        code.append(s);
                        hasInvocation = true;
                        break;
                    }
                }
                // 默认名是接口上的 Extension 注解上对于的值
                String defaultExtName = cachedDefaultName;
                String getNameCode = null;
                // 倒序循环 adaptive 注解的值
                for (int i = value.length - 1; i >= 0; --i) {
                    if (i == value.length - 1) {
                        if (null != defaultExtName) {
                            if (!"protocol".equals(value[i])) {
                                if (hasInvocation) {
                                    // url.getMethodParameter(methodName, value[i], defaultExtName)
                                    // methodName 是从 Invocation 对象中获取的
                                    getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
                                } else {
                                    // url.getParameter(value[i], defaultExtName)
                                    getNameCode = String.format("url.getParameter(\"%s\", \"%s\")", value[i], defaultExtName);
                                }
                            } else {
                                getNameCode = String.format("( url.getProtocol() == null ? \"%s\" : url.getProtocol() )", defaultExtName);
                            }
                        } else {
                            if (!"protocol".equals(value[i])) {
                                if (hasInvocation) {
                                    getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
                                } else {
                                     
                                    getNameCode = String.format("url.getParameter(\"%s\")", value[i]);
                                }
                            } else {
                                getNameCode = "url.getProtocol()";
                            }
                        }
                    } else {
                        if (!"protocol".equals(value[i])) {
                            if (hasInvocation) {
                                getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
                            } else {
                                // 7. 生成取从 URL 取数据代码，其中 value[i] = car
                                getNameCode = String.format("url.getParameter(\"%s\", %s)", value[i], getNameCode);
                            }
                        } else {
                            getNameCode = String.format("url.getProtocol() == null ? (%s) : url.getProtocol()", getNameCode);
                        }
                    }
                }
                code.append("\nString extName = ").append(getNameCode).append(";");
                // check extName == null?
                String s = String.format("\nif(extName == null) " +
                                "throw new IllegalStateException(\"Fail to get extension(%s) name from url(\" + url.toString() + \") use keys(%s)\");",
                        type.getName(), Arrays.toString(value));
                code.append(s);

                // 根据取出来的扩展名获取扩展
                s = String.format("\n%s extension = (%<s)%s.getExtensionLoader(%s.class).getExtension(extName);",
                        type.getName(), ExtensionLoader.class.getSimpleName(), type.getName());
                code.append(s);

                // return statement
                if (!rt.equals(void.class)) {
                    code.append("\nreturn ");
                }
                // 执行扩展实现类的方法
                s = String.format("extension.%s(", method.getName());
                code.append(s);
                for (int i = 0; i < pts.length; i++) {
                    if (i != 0) {
                        code.append(", ");
                    }
                    code.append("arg").append(i);
                }
                code.append(");");
            }

            codeBuilder.append("\npublic ").append(rt.getCanonicalName()).append(" ").append(method.getName()).append("(");
            for (int i = 0; i < pts.length; i++) {
                if (i > 0) {
                    codeBuilder.append(", ");
                }
                codeBuilder.append(pts[i].getCanonicalName());
                codeBuilder.append(" ");
                codeBuilder.append("arg").append(i);
            }
            codeBuilder.append(")");
            if (ets.length > 0) {
                codeBuilder.append(" throws ");
                for (int i = 0; i < ets.length; i++) {
                    if (i > 0) {
                        codeBuilder.append(", ");
                    }
                    codeBuilder.append(ets[i].getCanonicalName());
                }
            }
            codeBuilder.append(" {");
            codeBuilder.append(code.toString());
            codeBuilder.append("\n}");
        }
        codeBuilder.append("\n}");
        if (logger.isDebugEnabled()) {
            logger.debug(codeBuilder.toString());
        }
        // 8. 返回生成的代码
        return codeBuilder.toString();
    }
}
  1. 当生成代理类代码后，通过获取加载器，以及编译器来生成对应代码，并返回
public class ExtensionLoader<T> {
    ...
    private Class<?> createAdaptiveExtensionClass() {
    	// 生成代理类的代码
        String code = createAdaptiveExtensionClassCode();
        // 1. 创建加载器
        ClassLoader classLoader = findClassLoader();
        // 2. 创建编译器
        org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        // 3. 编译生成代码
        return compiler.compile(code, classLoader);
    }
}
  1. 代码生成之后，要传入 URL 参数，以获取实际执行的类，其中参数一定是 “car”，而 value 值是在 com.luban.dubbo_spi.api.Car 配置文件的类
public class CarDemo {

    public static void main(String[] args) {

        ExtensionLoader<Car> carLoader = ExtensionLoader.getExtensionLoader(Car.class);
        Car adCar = carLoader.getAdaptiveExtension();

        Map<String, String> map = new HashMap<>();
        map.put("car", "black");
        URL url = new URL("","",1, map);
        // 1. 传入 URL 参数，执行方法
        adCar.getColorForUrl(url);
    }
}
  1. 实际执行的时候，就是执行下面这个代理类了，其中会根据 URL 的参数，通过 getExtensionLoader() 获取指定的类并且实例化后执行 getColorForUrl() 方法
package com.luban.dubbo_spi.api;
import org.apache.dubbo.common.extension.ExtensionLoader;
public class Car$Adaptive implements com.luban.dubbo_spi.api.Car {
    public void getColorForUrl(org.apache.dubbo.common.URL arg0) {
        if (arg0 == null) throw new IllegalArgumentException("url == null");
        org.apache.dubbo.common.URL url = arg0;
        String extName = url.getParameter("car");
        if(extName == null) throw new IllegalStateException("Fail to get extension(com.luban.dubbo_spi.api.Car) name from url(" + url.toString() + ") use keys([car])");
        com.luban.dubbo_spi.api.Car extension = (com.luban.dubbo_spi.api.Car)ExtensionLoader.getExtensionLoader(com.luban.dubbo_spi.api.Car.class).getExtension(extName);extension.getColorForUrl(arg0);
    }
    public void getColor() {throw new UnsupportedOperationException("method public abstract void com.luban.dubbo_spi.api.Car.getColor() of interface com.luban.dubbo_spi.api.Car is not adaptive method!");
    }
}
  1. 总结
    在这里插入图片描述
Gavinjou大笨象
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Dubbo源码分析之SPI
01-31
SPI 全称为 Service Provider Interface，是一种服务发现机制。
dubbo SPI之@SPI、@Adaptive注解, 以及什么时候动态生成$Adaptive代码
Brucelwl的博客
01-31 645
本文基于dubbo2.7.7对如下三个问题分析 1. ``@SPI``注解的作用；2. ``@Adaptive``注解的作用，放在Type和Method上的区别和注意点；3. 什么时候动态生成和编译``xxx$Adaptive``代码
Dubbo SPI源码分析
Charge8的博客
07-10 283
Dubbo SPI源码分析
dubbo之@Adaptive注解分析
wang0907的博客
01-15 1067
写在前面 dubbo提供了SPI机制可以通过外部配置文件来动态加载扩展类，有时我们可能需要配置这些扩展类挨个执行来满足业务场景，进行一些数据的处理等，此时这些扩展类我们都是需要的，还有一些其他的场景，需要根据外部环境的不同（如某参数的值），来动态的选择使用哪个扩展类，针对这种需求，dubbo提供了@Adaptive注解来完成该功能，源码如下： @Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE, ElementT
Dubbo（八）内核解析（DubboSPI机制、Adaptive机制、Wrapper机制、Activate机制）
chenandyuan的博客
07-26 589
Dubbo 的内核解析 所谓 Dubbo 的内核是指，Dubbo 中所有功能都是基于它之上完成的，都是由它作为基础的。Dubbo 内核的工作原理由四部分构成：服务发现机制 SPI、自适应机制 Adaptive、包装机制 Wrapper 与激活机制 Activate。 Dubbo 通过这四种机制实现了对插件的 IoC、AOP，实现了对自动生成类的动态编译 Compile。 1. JDK 的 SPI 机制 1.1 简介 SPI，Service Provider Interface，服务提供者接口，是一种服
Dubbo源码学习--SPI实现@SPI和@Adaptive
井底之蛙
08-23 9602
上一篇博客 Dubbo入门学习--Dubbo服务提供接口SPI机制我们已经简单介绍了Dubbo的SPI机制，这篇博客我们来剖析一下Dubbo是如何使用SPI机制的，在接口中使用@SPI("值")使用默认的实现类，如果我们不想使用默认的实现类是如何处理的。1、获取指定实现类在ExtensionLoader中获取默认实现类或者通过实现类名称来获取实现类。Protocol refprotocol = E...
Dubbo源码解析-——SPI机制
ZXMSH的博客
02-26 2700
SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。
Dubbo 源码分析 - SPI 机制
Java2B
05-14 935
1.简介 SPI 全称为 Service Provider Interface，是 Java 提供的一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用，比如 Dubbo 就是通过 SPI 机制...
Dubbo源码(1)-SPI机制源码解析
程序员不鸣的博客
05-03 540
文章目录一、什么是SPI二、基本使用2.1、核心注解和URL类2.2、单元测试三、SPI机制源码解析3.1、ExtensionLoader3.1.1、属性3.1.2、拓展类资源加载1）getExtensionClasses2）loadExtensionClasses3）loadFile3.1.3、获取指定Extension2）createExtension3）injectExtension3.1....
【Dubbo源码分析】Dubbo SPI
通往神秘的道路的专栏
05-31 2630
1、简介 SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用，比如 Dubbo 就是通过 SPI 机制加载所有的组件。...
阿里巴巴Dubbo实现的源码分析
01-30
这里我们只是补充一下从源码具体实现角度来看的某些细节方面，包括Invoker、ExtensionLoader等方面。任何官方已经介绍过的细节，我们不做画蛇添足，官方文档已经足够详实了，这篇文档的定位是补充实现的相关细节，是...
dubbo源码分析系列
02-09
dubbo 在不少java后台服务为主的公司应用很广泛。对dubbo 源码有深入的了解，可以加深rpc 的原理，顺带可以理解同类型的产品、...主要分析dubbo rpc spi cluster register 相关的源码；对dubbo的核心代码有详细的解读，
dubbo的源码分析
05-26
dubbo源码,方便大家的学习 深入学习dubbo协议 企业级应用
链表刷题集
yajunjiao的专栏
04-30 874
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1397
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
《设计一款蓝牙热敏打印机》
最新发布
唐顺才的博客
05-06 127
安卓apk用java + kotlin编写、上位机用Qt编写。主控芯片用易兆威蓝牙ic，通讯接口：蓝牙、串口、usb。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 1200
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
Nacos 配置中心实例分析实践
m0_73557631的博客
05-03 1011
​ 浏览器: http://localhost:5000/nacos/config/ip。先创建e-commerce-nacos-config-client5000 模块。​ 启动e-commerce-nacos-config-client5000。​ 启动Nacos Server。
dubbo源码分析资料
02-06
如果你想进行 Dubbo 源码分析，可以从以下几个方面入手： 1. Dubbo 的整体架构：Dubbo 采用了基于 RPC 框架的分布式服务架构，其中包含服务提供者、服务消费者、注册中心和监控中心等组件。了解这些组件的功能和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值