dubbo2.0源码中的设计模式与SPI介绍

最新推荐文章于 2023-06-29 15:41:08 发布
最新推荐文章于 2023-06-29 15:41:08 发布
阅读量318 收藏
点赞数
分类专栏： Dubbo

Dubbo源码包介绍

当我们从github把Dubbo源码下载下来之后有如下源码包
这里写图片描述
下面来说明每个包的作用，以便我们有目的的阅读代码
dubbo-admin
dubbo管理平台源码包，用来管理dubbo服务的启动、禁用、降权、接口测试等，操作界面如下
这里写图片描述
dubbo-cluster
集群模块，将多个服务提供方伪装为一个提供方，包括：负载均衡, 容错，路由等，集群的地址列表可以是静态配置的，也可以是由注册中心下发。
dubbo-common
公共逻辑模块，包括Util类和通用模型
dubbo-config
配置模块，是Dubbo对外的API，用户通过Config使用Dubbo，隐藏Dubbo所有细节
例如：

<bean id=“xxxService” class=“com.xxx.XxxServiceImpl” /> <!-- 和本地服务一样实现远程服务 -->
<dubbo:service interface=“com.xxx.XxxService” ref=“xxxService” /> <!-- 增加暴露远程服务配置 -->
   
   
  • 1
  • 2

dubbo-container
容器模块，是一个Standlone的容器，以简单的Main加载Spring启动，因为服务通常不需要Tomcat/JBoss等Web容器的特性，没必要用Web容器去加载服务
dubbo-demo
dubbo服务provider和consumer例子
dubbo-filter
dubbo扩展过滤器功能，针对dubbo接口，类似Spring的AOP，经常用的并发控制、超时设置、异常设置、tps限流设置等等都是通过filter来实现的。
dubbo-monitor
监控模块，统计服务调用次数，调用时间的，调用链跟踪的服务
dubbo-registry
注册中心模块，基于注册中心下发地址的集群方式，以及对各种注册中心的抽象。
dubbo-remoting
远程通讯模块，相当于Dubbo协议的实现，如果RPC用RMI协议则不需要使用此包
dubbo-rpc
远程调用模块，抽象各种协议，以及动态代理，只包含一对一的调用，不关心集群的管理

dubbo用到的设计模式

工厂模式

Java SPI

在我们分析工厂模式之前我们先了解下Java SPI（service provice interface）。SPI是JDK内置的一种服务发现机制。目前有不少框架用它来做服务的扩展发现， 简单来说，它就是一种动态替换发现的机制， 举个例子来说， 有个接口，想运行时动态的给它添加实现，你只需要添加一个实现。
这里写图片描述
而后把新加的实现描述给JDK即可，Dubbo框架就是基于SPI机制提供扩展功能。
我们看下文件目录
这里写图片描述
各个类的源码如下：

package com.swk.spi;
public interface HelloInterface {
    public void sayHello();
}
package com.swk.spi.impl;
import com.swk.spi.HelloInterface;
public class ImageHello implements HelloInterface{
    @Override
    public void sayHello() {
        System.out.println("image hello");
    }
}
package com.swk.spi.impl;
import com.swk.spi.HelloInterface;
public class TextHello implements HelloInterface{
    @Override
    public void sayHello() {
        System.out.println("text hello");
    }
}
package com.swk.spi;
import java.util.ServiceLoader;
public class SPIMain {

    public static void main(String[] args) {
        ServiceLoader<HelloInterface> loaders = ServiceLoader.load(HelloInterface.class);
        for(HelloInterface in:loaders){
            in.sayHello();
        }
    }
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

com.swk.spi.HelloInterface文件内容如下，添加一个实现类的全名就可以调用这个类里面的方法

com.swk.spi.impl.TextHello
com.swk.spi.impl.ImageHello
   
   
  • 1
  • 2

运行结果如下

text hello
image hello
   
   
  • 1
  • 2

下面我们看看dubbo的实现，dubbo的扩展机制和java的SPI机制非常相似，但是又增加了如下功能：
1、可以方便的获取某一个想要的扩展实现，java的SPI机制就没有提供这样的功能
2、对于扩展实现IOC依赖注入功能：
现在实现者A1含有setB()方法，会自动注入一个接口B的实现者，此时注入B1还是B2呢？都不是，而是注入一个动态生成的接口B的实现者B$Adpative，该实现者能够根据参数的不同，自动引用B1或者B2来完成相应的功能
3、对扩展采用装饰器模式进行功能增强，类似AOP实现的功能

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

我们以Protocal为例来分析下

@SPI("dubbo")
public interface Protocol {

    /**
     * 获取缺省端口，当用户没有配置端口时使用。
     * 
     * @return 缺省端口
     */
    int getDefaultPort();
    /**
     * 暴露远程服务：<br>
     * 1. 协议在接收请求时，应记录请求来源方地址信息：RpcContext.getContext().setRemoteAddress();<br>
     * 2. export()必须是幂等的，也就是暴露同一个URL的Invoker两次，和暴露一次没有区别。<br>
     * 3. export()传入的Invoker由框架实现并传入，协议不需要关心。<br>
     * 
     * @param <T> 服务的类型
     * @param invoker 服务的执行体
     * @return exporter 暴露服务的引用，用于取消暴露
     * @throws RpcException 当暴露服务出错时抛出，比如端口已占用
     */
    @Adaptive
    <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;
    /**
     * 引用远程服务：<br>
     * 1. 当用户调用refer()所返回的Invoker对象的invoke()方法时，协议需相应执行同URL远端export()传入的Invoker对象的invoke()方法。<br>
     * 2. refer()返回的Invoker由协议实现，协议通常需要在此Invoker中发送远程请求。<br>
     * 3. 当url中有设置check=false时，连接失败不能抛出异常，并内部自动恢复。<br>
     * 
     * @param <T> 服务的类型
     * @param type 服务的类型
     * @param url 远程服务的URL地址
     * @return invoker 服务的本地代理
     * @throws RpcException 当连接服务提供方失败时抛出
     */
    @Adaptive
    <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
    /**
     * 释放协议：<br>
     * 1. 取消该协议所有已经暴露和引用的服务。<br>
     * 2. 释放协议所占用的所有资源，比如连接和端口。<br>
     * 3. 协议在释放后，依然能暴露和引用新的服务。<br>
     */
    void destroy();
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

Protocol的实现类有
这里写图片描述
ExtensionLoader中含有一个静态属性，用于缓存所有的扩展加载实例，这里加载Protocol.class，就以Protocol.class为key，创建的ExtensionLoader为value存储到上述EXTENSION_LOADERS中

public class ExtensionLoader<T> {
    private static final Logger logger = LoggerFactory.getLogger(ExtensionLoader.class);

    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 static final Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*");

    private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();
    private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

我们来看下，ExtensionLoader实例是如何来加载Protocol的实现类的：
1、先解析Protocol上的Extension注解的name,存至String cachedDefaultName属性中，作为默认的实现
2、到类路径下的加载 META-INF/services/com.alibaba.dubbo.rpc.Protocol文件
这里写图片描述
文件内容如下

filter=com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper
listener=com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper
mock=com.alibaba.dubbo.rpc.support.MockProtocol
   
   
  • 1
  • 2
  • 3

这里的

 private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
 private static final ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();
   
   
  • 1
  • 2

我们可以理解为一种工厂模式，这种实现方式的优点是可扩展性强，想要扩展实现，只需要在 classpath 下增加个文件就可以了，代码零侵入。另外，像上面的 Adaptive 实现，可以做到调用时动态决定调用哪个实现，但是由于这种实现采用了动态代理，会造成代码调试比较麻烦，需要分析出实际调用的实现类。

装饰器模式与责任链模式

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构
责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型对请求的发送者和接收者进行解耦
在我们介绍工厂模式的时候我们也提到了装饰器模式，Dubbo 在启动和调用阶段都大量使用了装饰器模式。
以 Provider 提供的调用链为例，具体的调用链代码是在 ProtocolFilterWrapper 的 buildInvokerChain 完成的，具体是将注解中含
有 group=provider 的 Filter 实现，按照 order 排序，最后的调用顺序是查看文本打印
EchoFilter-》 ClassLoaderFilter-》 GenericFilter-》 ContextFilter-》 ExceptionFilter-》TimeoutFilter-》 MonitorFilter-》 TraceFilter。更确切地说，这里是装饰器和责任链模式的混合使用。例如， EchoFilter 的作用是判断是否是回声测试请求，是的话直接返回内容，这是一种责任链的体现，源码如下：

/**
 * EchoInvokerFilter
 * 
 * @author william.liangf
 */
@Activate(group = Constants.PROVIDER, order = -110000)
public class EchoFilter implements Filter {
    public Result invoke(Invoker<?> invoker, Invocation inv) throws RpcException {
        // 是否是回声测试请求
        if(inv.getMethodName().equals(Constants.$ECHO) && inv.getArguments() != null && inv.getArguments().length == 1 )
            return new RpcResult(inv.getArguments()[0]);
        return invoker.invoke(inv);
    }
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

而像 ClassLoaderFilter则只是在主功能上添加了功能，更改当前线程的 ClassLoader，这是典型的装饰器模式，源码如下

/**
 * ClassLoaderInvokerFilter
 * 
 * @author william.liangf
 */
@Activate(group = Constants.PROVIDER, order = -30000)
public class ClassLoaderFilter implements Filter {
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        ClassLoader ocl = Thread.currentThread().getContextClassLoader();
        // 在主功能上添加了功能，更改当前线程的 ClassLoader
        Thread.currentThread().setContextClassLoader(invoker.getInterface().getClassLoader());
        try {
            return invoker.invoke(invocation);
        } finally {
            Thread.currentThread().setContextClassLoader(ocl);
        }
    }
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

观察者模式

当一个对象被修改时，则会自动通知它的依赖对象
在dubbo provider服务启动时候要向注册中心注册自己的服务，在dubbo consumer向注册中心订阅服务时则是一种观察者模式，他开启了一个listener，注册中心会每 5 秒定时检查是否有服务更新，如果有更新，向该服务的提供者发送一个 notify 消息， provider 接受到 notify 消息后，即运行 NotifyListener 的 notify 方法，执行监听器方法。

public interface NotifyListener {
    /**
     * 当收到服务变更通知时触发。
     * 
     * 通知需处理契约：<br>
     * 1. 总是以服务接口和数据类型为维度全量通知，即不会通知一个服务的同类型的部分数据，用户不需要对比上一次通知结果。<br>
     * 2. 订阅时的第一次通知，必须是一个服务的所有类型数据的全量通知。<br>
     * 3. 中途变更时，允许不同类型的数据分开通知，比如：providers, consumers, routers, overrides，允许只通知其中一种类型，但该类型的数据必须是全量的，不是增量的。<br>
     * 4. 如果一种类型的数据为空，需通知一个empty协议并带category参数的标识性URL数据。<br>
     * 5. 通知者(即注册中心实现)需保证通知的顺序，比如：单线程推送，队列串行化，带版本对比。<br>
     * 
     * @param urls 已注册信息列表，总不为空，含义同{@link com.alibaba.dubbo.registry.RegistryService#lookup(URL)}的返回值。
     */
    void notify(List<URL> urls);
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

动态代理模式

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能
Dubbo 扩展 jdk spi 的类 ExtensionLoader 的 Adaptive 实现是典型的动态代理实现。 Dubbo需要灵活地控制实现类，即在调用阶段动态地根据参数决定调用哪个实现类，所以采用先生成代理类的方法，能够做到灵活的调用。生成代理类的代码是 ExtensionLoader 的createAdaptiveExtensionClassCode 方法。代理类的主要逻辑是，获取 URL 参数中指定参数的值作为获取实现类的 key。

 /**
     * 根据URL传参获取指定实现类的key
     * 2017年6月4日 上午10:20:25
     * @return
     */
    private String createAdaptiveExtensionClassCode() {
        StringBuilder codeBuidler = new StringBuilder();
        // 根据反射获取方法集合
        Method[] methods = type.getMethods();
        boolean hasAdaptiveAnnotation = false;
        for(Method m : methods) {
            // 判断每个方法是否使用了Adaptive注解
            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的注解信息
            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) {
                    // 如果是URL类型
                    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(ets[i].getCanonicalName());
                }
            }
            codeBuidler.append(" {");
            codeBuidler.append(code.toString());
            codeBuidler.append("\n}");
        }
        codeBuidler.append("\n}");
        if (logger.isDebugEnabled()) {
            logger.debug(codeBuidler.toString());
        }
        return codeBuidler.toString();
    }
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
在云端123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
精通Dubbo——dubbo2.0源码中的设计模式与SPI介绍
路漫漫，水迢迢
06-04 8063
Dubbo源码包介绍当我们从github把Dubbo源码下载下来之后有如下源码包 下面来说明每个包的作用，以便我们有目的的阅读代码 dubbo-admin dubbo管理平台源码包，用来管理dubbo服务的启动、禁用、降权、接口测试等，操作界面如下 dubbo-cluster 集群模块，将多个服务提供方伪装为一个提供方，包括：负载均衡, 容错，路由等，集群的地址列表可以是静态配置的
长文详解：DUBBO源码使用了哪些设计模式
lt_xiaodou的博客
09-04 537
DUBBO作为RPC领域优秀开源的框架在业界十分流行，本文我们阅读其源码并对其使用到的设计模式进行分析。需要说明的是本文所说的设计模式更加广义，不仅包括标准意义上23种设计模式，还有一些常见经过检验的代码模式例如双重检查锁模式、多线程保护性暂停模式等等。模板方法模式定义一个操作中的算法骨架，一般使用抽象类定义算法骨架。抽象类同时定义一些抽象方法，这些抽象方法延迟到子类实现，这样子类不仅遵守了算法骨架约定，也实现了自己的算法。既保证了规约也兼顾灵活性。这就是用抽象构建框架，用实现扩展细节。DUBBO源码中有一
Dubbo 3.x源码(3)—Dubbo SPI机制的介绍与使用
终生学习践行者
06-29 645
介绍了JDK的SPI机制的概念和原理，并且介绍了Dubbo SPI机制的概念和原理，以及Dubbo SPI机制的优缺点
精通Dubbo——dubbo2.0源码中Spring Bean的加载
qq5132834的专栏
07-06 200
【转载】http://blog.csdn.net/fuyuwei2015/article/details/72872019
Dubbo学习之SPI实战与debug源码
增量星球
08-25 4658
目录绪论环境搭建dubbo-demo-interfacedubbo-demo-xmldubbo-demo-xml-provider源码跟踪getExtensioncreateExtensiongetExtensionClassesloadDirectoryloadResourceinjectExtension总结 绪论 上篇文章《dubbo学习之源码创建属于自己的dubbo-demo》溪源带着大家简单搭建了自己的demo，基础环境已经搭建完成，从这篇文章开始，溪源便开始学习并总结Dubbo的相关机制，此篇文
2-Dubbo架构设计与底层原理-SPI源码分析
Java架狗师知识框架速查表
07-27 192
SPI全称为ServiceProviderInterface，是Java提供的一种服务发现机制。SPI的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过SPI机制为我们的程序提供拓展功能。SPI机制在第三方框架中也有所应用，比如Dubbo就是通过SPI机制加载所有的组件。不过，Dubbo并未使用Java原生的SPI机制，而是对其进行了增强，使其能够更好的满足需求。......
dubbo的SPI应用与原理
Dream It Possible
02-28 897
本篇简单分别介绍了 Java SPI 与 Dubbo SPI 用法，并对 Dubbo SPI 的加载拓展类的过程进行了分析。同时分析了Dubbo AOP的实现原理。如果文章中有错误不妥之处，希望大家指正。举例。
dubbo源码解析-SPI机制
Blue92120的博客
03-14 379
exchange 信息交换层：封装请求响应模式，同步转异步，以 `Request`, `Response` 为中心，扩展接口为 `Exchanger`, `ExchangeChannel`, `ExchangeClient`, `ExchangeServer`。- cluster 路由层：封装多个提供者的路由及负载均衡，并桥接注册中心，以 `Invoker` 为中心，扩展接口为 `Cluster`, `Directory`, `Router`, `LoadBalance`。
dubbo中的SPI机制的使用和源码分析
JAVA技术爱好者
02-27 423
dubbo中的SPI机制的使用和源码分析SPISPI机制概述JDK中的SPI机制dubbo SPIdubbo spi架构图dubbo aopdubbo的依赖注入dubbo中@SPIDubbo SPI源码分析ExtensionLoadergetExtensionLoader(Class class)getExtension(String name)Dubbo中的IOCcreateAdaptiveExtensionClass SPI 为什么要分析 dubbo的SPI机制，我只能说dubbo的SPI机制是dubb
apache dubbo 3.0.7源码
05-06
1. **设计模式与架构** - **服务提供者（Provider）**：提供服务的模块，暴露服务接口供消费者调用。 - **服务消费者（Consumer）**：调用远程服务的模块，通过服务接口调用服务。 - **注册中心（Registry）**：...
dubbo 源码
03-23
Dubbo采用了SPI（Service Provider Interface）设计模式，允许用户自定义实现并动态加载扩展点。`ExtensionLoader`是Dubbo实现SPI的关键组件，它使得Dubbo具有良好的可扩展性和灵活性。 总结，Dubbo的源码学习不仅...
dubbo源码解析2.01.pdf
07-24
Dubbo源码解析不仅涵盖了框架本身的设计和实现细节，还包括了对Java相关技术和设计模式的应用。通过深入理解这些知识点，不仅可以帮助开发者更好地使用Dubbo，还能提高他们对分布式系统设计的理解和掌握。
dubbo源码分析系列
04-06
《Dubbo源码分析系列》是一份深入探讨Java开源...通过对《Dubbo源码分析系列》的学习，开发者不仅可以掌握Dubbo的基本使用，还能深入理解其设计思想，从而更好地在实际项目中应用和优化Dubbo，提高系统的稳定性和效率。
毕设系统—智慧工地监控管理系统-可执行内含文档代码-可执行内含文档代码.zip
07-28
毕设系统—智慧工地监控管理系统-可执行内含文档代码-可执行内含文档代码.zip
一种基于关键能力的体系贡献率评估方法_李丹.caj
最新发布
07-28
一种基于关键能力的体系贡献率评估方法_李丹
化学/环境学-线性拟合/零级反应动力学拟合/一级反应动力学拟合/二级反应动力学拟合/三级反应动力学拟合软件
07-28
在进行实验的过程中，常常遇到做出一组数据却不知其效果的困扰，如做出标准曲线却不知其拟合优度。一般需用电脑的专业软件进行拟合，如Origin、MATLAB等，但存在操作步骤复杂，软件需付费等问题。基于上述情况，针对线性拟合（linear fitting）和零级反应动力学拟合（zero-order reaction kinetics fitting）、一级反应动力学拟合（first-order reaction kinetics fitting）、二级反应动力学拟合（second-order reaction kinetics fitting）、三级反应动力学拟合（third-order reaction kinetics fitting）等特殊拟合场景，开发了一个软件，其优势有： a.使用BSD许可证，即允许免费使用、修改和分发； b.支持手机（Android系统）和电脑（Windows系统）双平台使用，便于在实验现场检验实验效果； c.软件界面均采用中文。
731545397801645熊猫侠v1.1.50.apk
07-28
731545397801645熊猫侠v1.1.50.apk
深入解析Dubbo 2.0源码：核心机制与流程梳理
本文是一篇深入解析Dubbo 2.0源码的详尽指南，作者基于自己的阅读和研究，对Dubbo的核心机制、设计模式、Bean加载、扩展点机制、代理实现以及远程调用流程进行了详细的剖析。以下是一些关键知识点： 1. **源码阅读...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值