【知识库】--dubbo SPI 动态扩展点之getAdaptiveExtension()触发调用链（267）

最新推荐文章于 2024-04-22 00:03:27 发布
最新推荐文章于 2024-04-22 00:03:27 发布
阅读量1k 收藏
点赞数
分类专栏： dubbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qfzhangwei/article/details/75581799
版权

 已知 com.alibaba.dubbo.common.extension.ExtensionLoader :

* <li>自动注入关联扩展点。</li>
* <li>自动Wrap上扩展点的Wrap类。</li>
* <li>缺省获得的的扩展点是一个Adaptive Instance。
而在dubbo.internal文件下  （dubbo/3.1.11/dubbo-3.1.11.jar!/META-INF/dubbo/internal/com.alibaba.dubbo.rpc.Protocol）里面包含如下两个wrapper 

filter=com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper
listener=com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper
com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper wrap调用链
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
        return protocol.export(invoker);
    }
    return protocol.export(buildInvokerChain(invoker, Constants.SERVICE_FILTER_KEY, Constants.PROVIDER));
}

public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
    if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
        return protocol.refer(type, url);
    }
    return buildInvokerChain(protocol.refer(type, url), Constants.REFERENCE_FILTER_KEY, Constants.CONSUMER);
}
调用链--链接 
private static <T> Invoker<T> buildInvokerChain(final Invoker<T> invoker, String key, String group) {
    Invoker<T> last = invoker;
    List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);
    if (filters.size() > 0) {
        for (int i = filters.size() - 1; i >= 0; i --) {
            final Filter filter = filters.get(i);
            final Invoker<T> next = last;
            last = new Invoker<T>() {

                public Class<T> getInterface() {
                    return invoker.getInterface();
                }

                public URL getUrl() {
                    return invoker.getUrl();
                }

                public boolean isAvailable() {
                    return invoker.isAvailable();
                }

                public Result invoke(Invocation invocation) throws RpcException {
                    return filter.invoke(next, invocation);
                }

                public void destroy() {
                    invoker.destroy();
                }

                @Override
                public String toString() {
                    return invoker.toString();
                }
            };
        }
    }
    return last;
}

问题来了：他们在哪里触发？

1从如下地方开始（举例）

private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();

2 getAdaptiveExtention() 方法

@SuppressWarnings("unchecked")
public T getAdaptiveExtension() {
    Object instance = cachedAdaptiveInstance.get();
    if (instance == null) {
        if (createAdaptiveInstanceError == null) {
            synchronized (cachedAdaptiveInstance) {
                instance = cachedAdaptiveInstance.get();
                if (instance == null) {
                    try {
                        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;
}

3  createAdaptiveExtension() 方法

@SuppressWarnings("unchecked")
private T createAdaptiveExtension() {
    try {
        return injectExtension((T) getAdaptiveExtensionClass().newInstance());
    } catch (Exception e) {
        throw new IllegalStateException("Can not create adaptive extenstion " + type + ", cause: " + e.getMessage(), e);
    }
}

4 Class<?> getAdaptiveExtensionClass() 方法

private Class<?> getAdaptiveExtensionClass() {
    getExtensionClasses();
    if (cachedAdaptiveClass != null) {
        return cachedAdaptiveClass;
    }
    return cachedAdaptiveClass = createAdaptiveExtensionClass();
}

5 Class<?> createAdaptiveExtensionClass() 方法

private Class<?> createAdaptiveExtensionClass() {
    String code = createAdaptiveExtensionClassCode();
    ClassLoader classLoader = findClassLoader();
    com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
    return compiler.compile(code, classLoader);
}

6 重点：生成代码code

private String createAdaptiveExtensionClassCode() {
    StringBuilder codeBuidler = new StringBuilder();
    Method[] methods = type.getMethods();
    boolean hasAdaptiveAnnotation = false;
    for (Method m : methods) {
        if (m.isAnnotationPresent(Adaptive.class)) {
            hasAdaptiveAnnotation = true;
            break;
        }
    }
    // 完全没有Adaptive方法，则不需要生成Adaptive类
    if (!hasAdaptiveAnnotation)
        throw new IllegalStateException("No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");

    codeBuidler.append("package " + type.getPackage().getName() + ";");
    codeBuidler.append("\nimport " + ExtensionLoader.class.getName() + ";");
    codeBuidler.append("\npublic class " + type.getSimpleName() + "$Adpative" + " implements " + type.getCanonicalName() + " {");

    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);
        if (adaptiveAnnotation == null) {
            code.append("throw new UnsupportedOperationException(\"method ")
                    .append(method.toString()).append(" of interface ")
                    .append(type.getName()).append(" is not adaptive method!\");");
        } else {
            int urlTypeIndex = -1;
            for (int i = 0; i < pts.length; ++i) {
                if (pts[i].equals(URL.class)) {
                    urlTypeIndex = i;
                    break;
                }
            }
            // 有类型为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);
            }
            // 参数没有URL类型
            else {
                String attribMethod = null;

                // 找到参数的URL属性
                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 adative 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);
            }

            String[] value = adaptiveAnnotation.value();
            // 没有设置Key，则使用“扩展点接口名的点分隔 作为Key
            if (value.length == 0) {
                char[] charArray = type.getSimpleName().toCharArray();
                StringBuilder sb = new StringBuilder(128);
                for (int i = 0; i < charArray.length; i++) {
                    if (Character.isUpperCase(charArray[i])) {
                        if (i != 0) {
                            sb.append(".");
                        }
                        sb.append(Character.toLowerCase(charArray[i]));
                    } else {
                        sb.append(charArray[i]);
                    }
                }
                value = new String[]{sb.toString()};
            }

            boolean hasInvocation = false;
            for (int i = 0; i < pts.length; ++i) {
                if (pts[i].getName().equals("com.alibaba.dubbo.rpc.Invocation")) {
                    // 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;
                }
            }

            String defaultExtName = cachedDefaultName;
            String getNameCode = null;
            for (int i = value.length - 1; i >= 0; --i) {
                if (i == value.length - 1) {
                    if (null != defaultExtName) {
                        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\", \"%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
                            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(");");
        }

        codeBuidler.append("\npublic " + rt.getCanonicalName() + " " + method.getName() + "(");
        for (int i = 0; i < pts.length; i++) {
            if (i > 0) {
                codeBuidler.append(", ");
            }
            codeBuidler.append(pts[i].getCanonicalName());
            codeBuidler.append(" ");
            codeBuidler.append("arg" + i);
        }
        codeBuidler.append(")");
        if (ets.length > 0) {
            codeBuidler.append(" throws ");
            for (int i = 0; i < ets.length; i++) {
                if (i > 0) {
                    codeBuidler.append(", ");
                }
                codeBuidler.append(pts[i].getCanonicalName());
            }
        }
        codeBuidler.append(" {");
        codeBuidler.append(code.toString());
        codeBuidler.append("\n}");
    }
    codeBuidler.append("\n}");
    if (logger.isDebugEnabled()) {
        logger.debug(codeBuidler.toString());
    }
    return codeBuidler.toString();
}

7 上面生成的代码中 有如下一段

s = String.format("\n%s extension = (%<s)%s.getExtensionLoader(%s.class).getExtension(extName);",
        type.getName(), ExtensionLoader.class.getSimpleName(), type.getName());

8 这里就是触发wrap的源头：如下方法

/**
 * 返回指定名字的扩展。如果指定名字的扩展不存在，则抛异常 {@link IllegalStateException}.
 *
 * @param name
 * @return
 */
@SuppressWarnings("unchecked")
public T getExtension(String name) {
    if (name == null || name.length() == 0)
        throw new IllegalArgumentException("Extension name == null");
    if ("true".equals(name)) {
        return getDefaultExtension();
    }
    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) {
                instance = createExtension(name);
                holder.set(instance);
            }
        }
    }
    return (T) instance;
}


9 根据名字扩展：（这里的名字其实就是协议中的关键字如zookeeper，dubbo等）

@SuppressWarnings("unchecked")
private T createExtension(String name) {
    Class<?> clazz = getExtensionClasses().get(name);
    if (clazz == null) {
        throw findException(name);
    }
    try {
        T instance = (T) EXTENSION_INSTANCES.get(clazz);
        if (instance == null) {
            EXTENSION_INSTANCES.putIfAbsent(clazz, (T) clazz.newInstance());
            instance = (T) EXTENSION_INSTANCES.get(clazz);
        }
        injectExtension(instance);
        Set<Class<?>> wrapperClasses = cachedWrapperClasses;
        if (wrapperClasses != null && wrapperClasses.size() > 0) {
            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);
    }
}

10 上面方法中的代码片段：解释了com.alibaba.dubbo.common.extension.ExtensionLoader的注释（wrap）

injectExtension(instance);//自动注入关联扩展点。

Set<Class<?>> wrapperClasses = cachedWrapperClasses;
if (wrapperClasses != null && wrapperClasses.size() > 0) {
    for (Class<?> wrapperClass : wrapperClasses) {//自动Wrap上扩展点的Wrap类。

        instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
    }
}

11 最终验证 本文一开始讲解的两个wrapper类，第一个就是负责责任链的链接

filter=com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper
listener=com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper

12 附加 dubbo 3.1.11 的filter列表

adminzkfilter=com.alibaba.dubbo.registry.filter.AdminZkServiceFilter
monitor=com.alibaba.dubbo.monitor.support.MonitorFilter
validation=com.alibaba.dubbo.validation.filter.ValidationFilter
cache=com.alibaba.dubbo.cache.filter.CacheFilter
trace=com.alibaba.dubbo.rpc.protocol.dubbo.filter.TraceFilter
future=com.alibaba.dubbo.rpc.protocol.dubbo.filter.FutureFilter
echo=com.alibaba.dubbo.rpc.filter.EchoFilter
generic=com.alibaba.dubbo.rpc.filter.GenericFilter
genericimpl=com.alibaba.dubbo.rpc.filter.GenericImplFilter
token=com.alibaba.dubbo.rpc.filter.TokenFilter
accesslog=com.alibaba.dubbo.rpc.filter.AccessLogFilter
activelimit=com.alibaba.dubbo.rpc.filter.ActiveLimitFilter
classloader=com.alibaba.dubbo.rpc.filter.ClassLoaderFilter
context=com.alibaba.dubbo.rpc.filter.ContextFilter
consumercontext=com.alibaba.dubbo.rpc.filter.ConsumerContextFilter
exception=com.alibaba.dubbo.rpc.filter.ExceptionFilter
executelimit=com.alibaba.dubbo.rpc.filter.ExecuteLimitFilter
deprecated=com.alibaba.dubbo.rpc.filter.DeprecatedFilter
compatible=com.alibaba.dubbo.rpc.filter.CompatibleFilter
timeout=com.alibaba.dubbo.rpc.filter.TimeoutFilter

自驱
关注
专栏目录
Dubbo架构篇 - 拓展点机制之激活拓展点
The Secret
12-13 325
本文分析Dubbo三大拓展点机制之一的激活拓展点机制
Dubbo知识点大全
java_green_hand0909的博客
02-26 839
我们首先了解 Dubbo 的分层和几个核心模块，分别介绍他们的职责。然后通过一个简单的例子，服务消费者调用服务提供者，用 Dubbo 的工作流程将各个模块串起来。在这 22 步的流程中，以服务提供者和服务消费者的初始化为起点，用到了 Config 和 Proxy 以及 Protocol，Invoker。注册中心作为两者的连接桥梁，起到了服务发现和注册的作用，并且着重讲了如何通过 ZooKeeper 实现注册中心的原理。
dubbo源码分析之getAdaptiveExtension
yangxiaobo118的博客
06-17 704
得到spi接口的适配类核心实现方法是createAdaptiveExtension（），当前对象缓存cachedAdaptiveInstance中没有实例时，调用 --&gt;createAdaptiveExtension（）--&gt;(T) getAdaptiveExtensionClass().newInstance() 得到该类型的适配实例 --&gt;getExtensionClasse...
Dubbo SPI，ExtensionLoader之getExtension和getAdaptiveExtension的区别与联系
luzhensmart的专栏
09-08 422
在dubbo中，大量的使用了ExtensionLoader进行接口实现类的扩展，也就是SPI机制，ExtensionLoader会扫描classpath下与扩展接口全路径名一致的配置文件，如下 文件中配置的都是扩展接口的实现类，调用ExtensionLoader的get类方法后，其会读取上述文件中所有的key=value键值对，加载value对应的class，并缓存到本地map中，key对应配置文件中的key，value对应Class对象。 ExtensionLoader提供了两类get方法，.
聊聊dubbo的ExtensionLoader.getActivateExtension
chuoguo3754的博客
08-24 558
序 本文主要研究一下dubbo的ExtensionLoader.getActivateExtension ExtensionLoader.getActivateExtension dubbo-2.7.3/dubbo-common/src/main/java/org/apache/dubbo/c...
Dubbo 源码阅读（三）getAdaptiveExtension
日有寸进
03-31 332
实际工作中，我们希望实例能懒加载，或者运行期自动选择 注解 @Adaptive 能解决这个选择问题 注解在实例类上时，直接选此类为适配类（一个接口只允许一个类标记） 注解在接口方法上时，只为此方法生成代理逻辑（方法必须有参数为url或者参数有返回url的方法） /** * 各个实现类上面没有@Adaptive * SPI上有注解@SPI("b") * URL中有具体的值info.serv...
dubbo源码解析2.01.pdf
07-24
- **扩展点**：扩展点是指Dubbo中可以通过配置来动态替换实现的功能点，例如序列化方式、负载均衡策略等。 - **扩展点配置**：通过在配置文件或代码中指定特定的扩展名来选择具体的实现。 - **扩展点加载流程**：...
分布式中间件之Dubbo详解
tdd18792032806的博客
07-29 3525
文章内容输出来源：拉勾教育Java高薪训练营 心得体会： 在拉勾教育高薪训练营里经过三个月多的学习，很辛苦但也收获很多，主要体现在：1.以前是工作遇到了哪方面的问题才去学习并解决，很难形成知识体系，在拉勾高薪训练营里课程内容很丰富，基础回顾加进阶讲解，完美的打造了个人的知识体系，为成为一名合格的架构师奠定了基础；2.值得一说的是“闯关式”的学习模式，若上一个模块的作业未完成就无法学习下一个模块，但有班主任和导师对个人的学习进行督促，可以让我们学员必须牢靠的掌握技术知识点；3.在知识点技术落地方面，以前只是听
dubbo2.5.8源码包
08-06
7. **SPI扩展机制**：Dubbo采用Java的Service Provider Interface（SPI）机制，允许用户自定义实现，源码中可以学习如何利用这一特性进行功能扩展。 8. **协议与序列化**：Dubbo支持多种通信协议（如Dubbo、HTTP、...
SpringCloud-2-基础组件（Feign、Hystrix、Sentinel）
m0_60875109的博客
07-28 629
雪崩效应的分析及处理； 服务熔断组件Hystrix，sentinel包含的服务降级，服务熔断，监控检查等功能的讲解； 服务调用组件Feign及其搭配客户端负载均衡组件consul组件的使用；
Dubbo 源码阅读（二）getActivateExtension
日有寸进
03-31 686
某此情况下，同一个接口的多个实现需要同时发挥作用，比如filter链。此时需要按条件选择一批实现类来工作。 /** * @Activate(group = {"group1","group2"},order = 1,value = "value1")打在某个自定义的Filter上 */ @Test public void testActivate() { ExtensionLoader...
【Dubbo的那些SPI接口】
最新发布
d1451545368的博客
04-22 743
Dubbo中有 @SPI @Adaptive @Activate 三个跟SPI相关的注解@SPI标记这是一个SPI接口@Adaptive作用在SPI接口的成员方法，调用SPI接口方法时根据这个方法的入参字段来决定使用哪个SPI接口实现类@Activate自动激活的实现类。
Dubbo——扩展点动态编译的实现
吴声子夜歌的博客
06-29 224
扩展点动态编译的实现 Dubbo SPI的自适应特性让整个框架非常灵活，而动态编译又是自适应特性的基础，因为动态生成的自适应类只是字符串，需要通过编译才能得到真正的Class。虽然我们可以使用反射来动态代理一个类，但是在性能上和直接编译好的Class会有一定差距。Dubbo SPI通过代码的动态生成，并配合动态编译器，灵活地在原始类基础上创建新的自适应类。 总体结构 Dubbo中有三种代码编译器，分别是JDK编译器、Javassist编译器和AdaptiveCompiler编译器。这几种编译器都实现了Com
Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();的解析
星坠竹空
02-13 921
这种Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();生成代理对象的方法在dubbo中运用的非常多。他主要运用了SPI技术。简单可以概括为（以Protocol为例）： @SPI(&quot;dubbo&quot;) public interface Protocol {} Pro...
dubbo启动报java.lang.ClassNotFoundException: javassist.ClassPath
sgs的博客
08-04 1万+
使用gradle 打包dubbox放到nexus私服上 公司更换私服地址。导致一些资源需要重新定位 上传。中间出了点小插曲竟然让我纠结了半天 在dubbo启动的过程中报错误：java.lang.ClassNotFoundException: javassist.ClassPath，调试发现代码：Class clazz = Class.forName(line, true, classLoad
Dubbo包编译版本较高导致项目启动失败
点滴
04-26 8804
问题描述：公司下载项目后，自动下载依赖JAR，有时候自动下载的Dubbo包的JDK编译版本比运行环境JDK版本高，启动会一直报错，错误信息如下Caused by: java.lang.ExceptionInInitializerError at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) at su...
Dubbo 和 JDK 版本不匹配
韦观松のBóKè
12-08 9166
Maven项目，使用Dubbo 2.8.4，启动报错： POM.XML依赖如下： com.alibaba dubbo  2.8.4 Eclipse报错如下： Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with
dubbo+spring_maven 遇到的问题 dubbojar包版本和jdk问题
热门推荐
u011671022的专栏
03-22 1万+
Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'com.yaochufa.privilege.api.ISystemService': Instantiation of bean failed; nested exce
5分钟Spring-boot集成Dubbo，构建高效分布式服务
通过本文的学习，读者将掌握如何在一个Spring Boot项目中集成Dubbo，实现服务的分布式调用，从而提升系统的可扩展性和容错性。如果你对这个过程有任何疑问，可以参考源码或访问文末提供的项目Github地址获取更多信息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

自驱

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值