zzy0_0
zzy0_0

dubbo源码分析

Dubbo插件化

Dubbo的插件化实现非常类似于原生的JAVA的SPI：它只是提供一种协议，并没有提供相关插件化实施的接口。用过的同学都知道，它有一种java原生的支持类：ServiceLoader，通过声明接口的实现类，在META-INF/services中注册一个实现类，然后通过ServiceLoader去生成一个接口实例，当更换插件的时候只需要把自己实现的插件替换到META-INF/services中即可。

SPI

Dubo Spi 和Java SPi的使用和对比

在Dubbo中，SPI是一个非常核心的机制，贯穿在几乎所有的流程中。弄明白这一块能够帮我们明白dubo源码

Dubbo是基于Java原生SPI机制思想的一个改进，所以，先从JAVA SPI机制开始了解什么时SPI以后再去学习Dubbo的SPI就比较简单

JAVASPI

SPI全称（service provider interface），是JDK内置的一种服务提供发现机制，目前市面上有很多框架都是用它来做服务的扩展发现，大家耳熟能详的如JDBC、日志框架都有用到；

简单来说，它是一种动态替换发现的机制。举个简单的例子，如果我们定义了一个规范，需要第三方厂商去实现，那么对于我们应用方来说，只需要集成对应厂商的插件，既可以完成对应规范的实现机制。 形成一种插拔式的扩展手段。

java原生spi实现
  1. 需要在classpath下创建一个目录，该目录命名必须是：META-INF/services

  2. 在该目录下创建一个properties文件，该文件需要满足以下几个条件

    1. 文件名必须是扩展的接口的全路径名称
    2. 文件内部描述的是该扩展接口的所有实现类
    3. 文件的编码格式是UTF-8
  3. 通过java.util.ServiceLoader的加载机制来发现 首先定义api接口 接下来对应产商实现对应的接口，并且在resouces的META-INF/services中创建对应的文件,并且通过properties规则配置实现类的全路径

​ 以及对应调用方引入api接口，和对应产商的jar

​ 并且在对应的resouces中引入接口，如果引入了多个产商的jar，那么会取到多个产商的东西

SPI的实际应用

​ SPI在很多地方有应用，大家可以看看最常用的java.sql.Driver驱动。JDK官方提供了java.sql.Driver这个驱动扩展点，但是你们并没有看到JDK中有对应的Driver实现。 那在哪里实现呢？

以连接Mysql为例，我们需要添加mysql-connector-java依赖。然后，你们可以在这个jar包中找到SPI的配置信息。如下图，所以java.sql.Driver由各个数据库厂商自行实现。这就是SPI的实际应用。当然除了这个意外，大家在spring的包中也可以看到相应的痕迹

SPI的缺点
  1. JDK标准的SPI会一次性加载实例化扩展点的所有实现，什么意思呢？就是如果你在META-INF/service下的文件里面加了N个实现类，那么JDK启动的时候都会一次性全部加载。那么如果有的扩展点实现初始化很耗时或者如果有些实现类并没有用到，那么会很浪费资源
  2. 如果扩展点加载失败，会导致调用方报错，而且这个错误很难定位到是这个原因

dubbo SPI规范

​ 使用原生spi,如果路径下有多个实现都会加载进来，如果有一个加载失败，会比较麻烦

目录

​ Dubbo的SPI并非原生的SPI，Dubbo的规则是在

  • ​ /META-INF/dubbo
  • /META-INF/internal
  • ​ /META-INF/service

并且基于SPI接口去创建一个文件下面以需要实现的接口去创建一个文件，并且在文件中以properties规则一样配置实现类的全面以及分配实现的一个名称。

文件名称和接口名称保持一致，文件内容和SPI有差异，内容是key对应value

我们看一下dubbo-cluster模块的META-INF.dubbo.internal：

实现自己的扩展点

在resources目录下新建文件

META-INF/dubbo/com.alibaba.dubbo.rpc.Protocol文件，文件内容为

defineProtocol=com.gupaoedu.dubbo.protocol.DefineProtocol

实现Protocol

import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.rpc.Exporter;
import com.alibaba.dubbo.rpc.Invoker;
import com.alibaba.dubbo.rpc.Protocol;
import com.alibaba.dubbo.rpc.RpcException;
public class DefineProtocol implements Protocol {

  @Override
  public int getDefaultPort() {
    return 8888;
  }

  @Override
  public  Exporter export(Invoker invoker) throws RpcException {
    return null;
  }

  @Override
  public  Invoker refer(Class type, URL url) throws RpcException {
    return null;
  }

  @Override
  public void destroy() {

  }
}

调用

public class App {
  public static void main(String[] args) throws IOException, InterruptedException {
    ClassPathXmlApplicationContext context = new
      ClassPathXmlApplicationContext
      ("dubbo-client.xml");

    Protocol protocol=ExtensionLoader.getExtensionLoader(Protocol.class).
      getExtension("defineProtocol");
    System.out.println(protocol.getDefaultPort());

    System.in.read();
  }
}

SPI源码分析

​ 切入点

Protocol protocol=ExtensionLoader.getExtensionLoader(Protocol.class).
  getExtension("defineProtocol");

dubbo的扩展点框架主要位于这个包下：

com.alibaba.dubbo.common.extension

大概结构如下：

com.alibaba.dubbo.common.extension
|--factory

    |--AdaptiveExtensionFactory  自适应扩展点工厂
    |--SpiExtensionFactory         SPI扩展点工厂

|--support

   |--ActivateComparator

|--Activate 自动激活加载扩展的注解

   |--Adaptive                      自适应扩展点的注解 
   |--ExtensionFactory              扩展点对象生成工厂接口

|--ExtensionLoader 扩展点加载器，扩展点的查找，校验，加载等核心逻辑的实现类

  |--SPI                           @SPI告诉当前应用其实一个扩展点例如Protocol 一定可以在对应的meta-inf/dubbo.internal 中看到

dubbo-config-spring
|- extension
|--SpringExtensionFactory

其中最核心的类就是ExtensionLoader，几乎所有特性都在这个类中实现。

ExtensionLoader没有提供public的构造方法，但是提供了一个public static的getExtensionLoader，这个方法就是获取ExtensionLoader实例的工厂方法。其public成员方法中有三个比较重要的方法：

getActivateExtension ：根据条件获取当前扩展可自动激活的实现

getExtension ： 根据名称获取当前扩展的指定实现

getAdaptiveExtension : 获取当前扩展的自适应实现

Protocol源码

@SPI("dubbo")
public interface Protocol {

  /**
     * 获取缺省端口，当用户没有配置端口时使用。
     * 
     * @return 缺省端口
     */
  int getDefaultPort();

  /**
     * 暴露远程服务：

     * 1. 协议在接收请求时，应记录请求来源方地址信息：RpcContext.getContext().setRemoteAddress();

     * 2. export()必须是幂等的，也就是暴露同一个URL的Invoker两次，和暴露一次没有区别。

     * 3. export()传入的Invoker由框架实现并传入，协议不需要关心。

     * 
     * @param  服务的类型
     * @param invoker 服务的执行体
     * @return exporter 暴露服务的引用，用于取消暴露
     * @throws RpcException 当暴露服务出错时抛出，比如端口已占用
     */
  @Adaptive
   Exporter export(Invoker invoker) throws RpcException;

  /**
     * 引用远程服务：

     * 1. 当用户调用refer()所返回的Invoker对象的invoke()方法时，协议需相应执行同URL远端export()传入的Invoker对象的invoke()方法。

     * 2. refer()返回的Invoker由协议实现，协议通常需要在此Invoker中发送远程请求。

     * 3. 当url中有设置check=false时，连接失败不能抛出异常，并内部自动恢复。

     * 
     * @param  服务的类型
     * @param type 服务的类型
     * @param url 远程服务的URL地址
     * @return invoker 服务的本地代理
     * @throws RpcException 当连接服务提供方失败时抛出
     */
  @Adaptive
   Invoker refer(Class type, URL url) throws RpcException;

  /**
     * 释放协议：

     * 1. 取消该协议所有已经暴露和引用的服务。

     * 2. 释放协议所占用的所有资源，比如连接和端口。

     * 3. 协议在释放后，依然能暴露和引用新的服务。

     */
  void destroy();

}

从上述Protocol的源码，可以看到两个注解@SPI("duo") 和 @Adaptive

@SPI :表示当前这个接口是一个扩展点，可以实现自己的扩展实现

@Adaptive 表示一个自适应扩展点，在方法级别上，会动态生成一个适配器类

getExtensionLoader

Protocol protocol=ExtensionLoader.getExtensionLoader(Protocol.class).
 getExtension("defineProtocol");
@SuppressWarnings("unchecked")
public static  ExtensionLoader getExtensionLoader(Class type) {
  if (type == null)
    throw new IllegalArgumentException("Extension type == null");
  if (!type.isInterface()) {
    throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
  }
  if (!withExtensionAnnotation(type)) {
    throw new IllegalArgumentException("Extension type(" + type +
                                  ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
  }

  ExtensionLoader loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
  if (loader == null) {
    EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
    loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
  }
  return loader;
}

​ 根据一个类型class获得一个ExtensionLoader，需要一个class类型的参数，这个参数必须是接口，而且此接口必须要@SPI注解注释，否则拒绝处理。检查通过之后首先会检查ExtensionLoader缓存中是否已经存在该扩展对应的ExtensionLoader,如果有则返回，否则创建一个新的ExtensionLoader负责加载此扩展实现，同时缓存起来。所以每一个扩展，dubbo中只会有一个对应的ExtensionLoader实例

接下来看下ExtensionLoader的私有构造函数：

private ExtensionLoader(Class type) {
  this.type = type;
  objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}

​ 这里保存了对应的扩展类型，并且设置了一个额外的objectFactory属性，他是一个ExtensionFactory类型，ExtensionFactory主要用于加载扩展的实现：

ExtensionFactory主要用于加载扩展的实现：

@SPI
public interface ExtensionFactory {

  /**
     * Get extension.
     * 
     * @param type object type.
     * @param name object name.
     * @return object instance.
     */
   T getExtension(Class type, String name);

}

​ ExtensionFactory有@SPI注解，说明当前这个接口是一个扩展点。从extension包的结构图可以看到。Dubbo内部提供了两个实现类：SpiExtensionFactory和AdaptiveExtensionFactory。不同的实现可以以不同的方式来完成扩展点实现的加载。

getAdaptiveExtension()

对应上述ExtensionLoader的getAdaptiveExtension()我们查看对应的getAdaptivesion()方法获得一个自适应的扩展点

如果是配置在类级别上，表示自定义适配器，如果是配置在方法上，表示需要动态生成适配器类

表示当前是自定义扩展点

默认的ExtensionFactory实现中，AdaptiveExtensionFactotry被@Adaptive注解注释，也就是它就是ExtensionFactory对应的自适应扩展实现(每个扩展点最多只能有一个自适应实现，如果所有实现中没有被@Adaptive注释的，那么dubbo会动态生成一个自适应实现类)，也就是说，所有对ExtensionFactory调用的地方，实际上调用的都是AdpativeExtensionFactory，那么我们看下他的实现代码：

@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {
    
    private final List factories;
    
    public AdaptiveExtensionFactory() {
        ExtensionLoader loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
        List list = new ArrayList();
        for (String name : loader.getSupportedExtensions()) {
            list.add(loader.getExtension(name));
        }
        factories = Collections.unmodifiableList(list);
    }

    public  T getExtension(Class type, String name) {
        for (ExtensionFactory factory : factories) {
            T extension = factory.getExtension(type, name);
            if (extension != null) {
                return extension;
            }
        }
        return null;
    }

​ 这段代码，其实就相当于一个代理入口，它会遍历当前系统中所有的ExtensionFactory实现来获取指定的扩展实现，获取到扩展实现，遍历完所有ExtensionFactory实现，调用ExtensionLoader的getSupportedExtensions方法来获取ExtensionFactory的所有实现

​ 从前面ExtensionLoader的私有构造函数中可以看出，在选择ExtensionFactory的时候，并不是调用getExtension(name)来获取某个具体的实现类，而是调用getAdaptiveExtension来获取一个自适应的实现。那么首先我们就来分析一下getAdaptiveExtension这个方法的实现吧：

@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;
}

​ 首先检查缓存的adaptiveInstance是否存在，如果存在则直接使用，否则的话调用createAdaptiveExtension方法来创建新的adaptiveInstance并且缓存起来。也就是说对于某个扩展点，每次调用ExtensionLoader.getAdaptiveExtension获取到的都是同一个实例。

createAdaptiveExtension方法
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);
  }
}
 在`createAdaptiveExtension`方法中，首先通过`getAdaptiveExtensionClass`方法获取到最终的自适应实现类型，然后实例化一个自适应扩展实现的实例，最后进行扩展点注入操作 

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

上述代码中主要做了两件事情

  1. getExtensionClasses() 加载所有路径下的扩展点
  2. createAdaptiveExtensionClass() 动态创建一个扩展点

cachedAdaptiveClass这里有个判断，用来判断当前Protocol这个扩展点是否存在一个自定义的适配器，如果有，则直接返回自定义适配器，否则，就动态创建，这个值是在getExtensionClasses中赋值的，这块代码我们稍后再看

getExtensionClasses()
private final Holder>> cachedClasses = new Holder>>();
private Map> getExtensionClasses() {
  //com.alibaba.dubbo.rpc.Protocal=>[xx,xx]
  Map> classes = cachedClasses.get();
  if (classes == null) {
    synchronized (cachedClasses) {
      classes = cachedClasses.get();
      if (classes == null) {
        classes = loadExtensionClasses();
        cachedClasses.set(classes);
      }
    }
  }
  return classes;
}

上述代码主要做了几件事

  1. 从cachedClasses中获得一个结果，这个结果实际上就是所有的扩展点类，key对应name,value对应class
  2. 通过双重检查锁判断
  3. 调用loadExtensionClasses()，去加载扩展点的实现
loadExtensionClasses()
// 此方法已经getExtensionClasses方法同步过。
private Map> loadExtensionClasses() {
  //type->Protocol.class
  final SPI defaultAnnotation = type.getAnnotation(SPI.class);
  if(defaultAnnotation != null) {
    String value = defaultAnnotation.value();
    if(value != null && (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> extensionClasses = new HashMap>();
  loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
  loadFile(extensionClasses, DUBBO_DIRECTORY);
  loadFile(extensionClasses, SERVICES_DIRECTORY);
  return extensionClasses;
}

从代码里面可以看到，在loadExtensionClasses中首先会检测扩展点在@SPI注解中配置的默认扩展实现的名称，并将其赋值给cachedDefaultName属性进行缓存，后面想要获取该扩展点的默认实现名称就可以直接通过访问cachedDefaultName字段来完成，比如getDefaultExtensionName方法就是这么实现的。从这里的代码中又可以看到，具体的扩展实现类型，是通过调用loadFile方法来加载，分别从一下三个地方加载：

META-INF/dubbo/internal

META-INF/dubbo

META-INF/services/

主要逻辑：

  1. 获得当前扩展点的注解，也就是Protocol.class这个类的注解@SPI
  2. 判断这个注解不为空，则再次获取@SPI中的value值
  3. 如果value有值，也就是@SPI("dubbo")，则吧此dubbo的值赋值给cachedDefaultName，这就是为什么我们能够通过ExtensionLoader.getExtensionLoader(Protocol.class).getDefaultExtension()能够获取到DubboProtocol这个扩展点的原因
  4. 最后，通过loadFile去加载指定路径下的所有扩展点
loadFile()
private void loadFile(Map> extensionClasses, String dir) {
  String fileName = dir + type.getName();
  try {
    Enumeration urls;
    ClassLoader classLoader = findClassLoader();
    if (classLoader != null) {
      urls = classLoader.getResources(fileName);
    } else {
      urls = ClassLoader.getSystemResources(fileName);
    }
    if (urls != null) {
      while (urls.hasMoreElements()) {
        java.net.URL url = urls.nextElement();
        try {
          BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));
          try {
            String line = null;
            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) {
                    Class clazz = Class.forName(line, true, classLoader);
                    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.");
                    }
                    //如果在类级别上，表示自定义适配器
                    //如果是在方法上，表示需要动态生成适配器类
                    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());
                      }
                    } else {
                      try {
                        clazz.getConstructor(type);
                        Set> wrappers = cachedWrapperClasses;
                        if (wrappers == null) {
                          cachedWrapperClasses = new ConcurrentHashSet>();
                          wrappers = cachedWrapperClasses;
                        }
                        wrappers.add(clazz);
                      } catch (NoSuchMethodException e) {
                        clazz.getConstructor();
                        if (name == null || name.length() == 0) {
                          name = findAnnotationName(clazz);
                          if (name == null || name.length() == 0) {
                            if (clazz.getSimpleName().length() > type.getSimpleName().length()
                                && clazz.getSimpleName().endsWith(type.getSimpleName())) {
                              name = clazz.getSimpleName().substring(0, clazz.getSimpleName().length() - type.getSimpleName().length()).toLowerCase();
                            } else {
                              throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + url);
                            }
                          }
                        }
                        String[] names = NAME_SEPARATOR.split(name);
                        if (names != null && names.length > 0) {
                          Activate activate = clazz.getAnnotation(Activate.class);
                          if (activate != null) {
                            cachedActivates.put(names[0], activate);
                          }
                          for (String n : names) {
                            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());
                            }
                          }
                        }
                      }
                    }
                  }
                } catch (Throwable t) {
                  IllegalStateException e = new IllegalStateException("Failed to load extension class(interface: " + type + ", class line: " + line + ") in " + url + ", cause: " + t.getMessage(), t);
                  exceptions.put(line, e);
                }
              }
            } // end of while read lines
          } finally {
            reader.close();
          }
        } catch (Throwable t) {
          logger.error("Exception when load extension class(interface: " +
                       type + ", class file: " + url + ") in " + url, t);
        }
      } // end of while urls
    }
  } catch (Throwable t) {
    logger.error("Exception when load extension class(interface: " +
                 type + ", description file: " + fileName + ").", t);
  }
}

解析指定路径下的文件，获取对应的扩展点，通过反射的方式进行实例化之后，put到extensionClasses这个Map集合中

调用loadFile方法，代码比较长，主要做了几个事情，有几个变量会赋值

cachedAdaptiveClass : 当前Extension类型对应的AdaptiveExtension类型(只能一个)

cachedWrapperClasses : 当前Extension类型对应的所有Wrapper实现类型(无顺序)

cachedActivates : 当前Extension实现自动激活实现缓存(map,无序)

cachedNames : 扩展点实现类对应的名称(如配置多个名称则值为第一个)

当loadExtensionClasses方法执行完成之后，还有以下变量被赋值：

cachedDefaultName : 当前扩展点的默认实现名称

当getExtensionClasses方法执行完成之后，除了上述变量被赋值之外，还有以下变量被赋值：

cachedClasses : 扩展点实现名称对应的实现类(一个实现类可能有多个名称)

其实也就是说，在调用了getExtensionClasses方法之后，当前扩展点对应的实现类的一些信息就已经加载进来了并且被缓存了。后面的许多操作都可以直接通过这些缓存数据来进行处理了。

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);
}

动态生成适配器代码，以及动态编译

  1. createAdaptiveExtensionClassCode ,动态创建一个字节码文件，返回code这个字符串
  2. 通过compilier.compile进行编译（默认情况下使用的是javassist）
  3. 通过classLoader载入到jvm中

上生成的code和类是

import com.alibaba.dubbo.common.extension.ExtensionLoader;

public class Protocol$Adaptive implements com.alibaba.dubbo.rpc.Protocol {
  public void destroy() {
    throw new UnsupportedOperationException("method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
  }

  public int getDefaultPort() {
    throw new UnsupportedOperationException("method public abstract int com.alibaba.dubbo.rpc.Protocol.getDefaultPort() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
  }

  public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) throws com.alibaba.dubbo.rpc.RpcException {
    if (arg1 == null) throw new IllegalArgumentException("url == null");
    com.alibaba.dubbo.common.URL url = arg1;
    String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
    if (extName == null)
      throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
    com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
    return extension.refer(arg0, arg1);
  }

  public com.alibaba.dubbo.rpc.Exporter export(com.alibaba.dubbo.rpc.Invoker arg0) throws com.alibaba.dubbo.rpc.RpcException {
    if (arg0 == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");
    if (arg0.getUrl() == null)
      throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");
    com.alibaba.dubbo.common.URL url = arg0.getUrl();
    String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
    if (extName == null)
      throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
    com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
    return extension.export(arg0);
  }
}
动态生成类的主要功能
  1. 从url或者拓展接口获取扩展接口实现类的名称
  2. 根据名称，获取实现了ExtensionLoader.getExtensionLoader(扩展接口类).getExtension(扩展接口实现类名称)，然后调用类的方法

refer是一个引用，得到一个url的参数，通过参数判断是走哪个协议发布服务

回到createAdaptiveExtension方法，他调用了getExtesionClasses方法加载扩展点实现信息完成之后，就可以直接通过判断cachedAdaptiveClass缓存字段是否被赋值盘确定当前扩展点是否有默认的AdaptiveExtension实现。如果没有，那么就调用createAdaptiveExtensionClass方法来动态生成一个。在dubbo的扩展点框架中大量的使用了缓存技术。

创建自适应扩展点实现类型和实例化就已经完成了，下面就来看下扩展点自动注入的实现

injectExtension
@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {
    
    private final List factories;
    
    public AdaptiveExtensionFactory() {
        ExtensionLoader loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
        List list = new ArrayList();
        for (String name : loader.getSupportedExtensions()) {
            list.add(loader.getExtension(name));
        }
        factories = Collections.unmodifiableList(list);
    }

    public  T getExtension(Class type, String name) {
        for (ExtensionFactory factory : factories) {
            T extension = factory.getExtension(type, name);
            if (extension != null) {
                return extension;
            }
        }
        return null;
    }

}

这里可以看到，扩展点自动注入的一句就是根据setter方法对应的参数类型和property名称从ExtensionFactory中查询，如果有返回扩展点实例，那么就进行注入操作。到这里getAdaptiveExtension方法就分析完毕了。

需要明白一点dubbo的内部传参基本上都是基于Url来实现的，也就是说Dubbo是基于URL驱动的技术

所以，适配器类的目的是在运行期获取扩展的真正实现来调用，解耦接口和实现，这样的话要不我们自己实现适配器类，要不dubbo帮我们生成，而这些都是通过Adpative来实现。

到目前为止，我们的AdaptiveExtension的主线走完了，可以简单整理一下他们的调用关系如下

总结

在整个过程中，最重要的两个方法getExtensionClasses和createAdaptiveExtensionClass

getExtensionClasses

这个方法主要是读取META-INF/services 、META-INF/dubbo、META-INF/internal目录下的文件内容

分析每一行，如果发现其中有哪个类的annotation是@Adaptive，就找到对应的AdaptiveClass。如果没有的话，就动态创建一个

createAdaptiveExtensionClass

该方法是在getExtensionClasses方法找不到AdaptiveClass的情况下被调用，该方法主要是通过字节码的方式在内存中新生成一个类，它具有AdaptiveClass的功能，Protocol就是通过这种方式获得AdaptiveClass类的。

源码分析

加载顺序

NamespaceHandler: 注册BeanDefinitionParser， 利用它来解析
BeanDefinitionParser： 解析配置文件的元素
spring会默认加载jar包下/META-INF/spring.handlers 找到对应的NamespaceHandler

initializingBean

当spring容器初始化完以后，会调用afterPropertiesSet方法

DisposableBean

bean被销毁的时候调用destory方法

ApplicationContextAware

容器初始化完成之后会主动注入applicationContext

ApplicationListener

事件监听

BeanNameAware

对象初始化完之后会获取bean的本身属性
delay能够控制延迟发布

源码解读要点

首先我们要关注的是服务的发布和服务的消费这两个主要的流程，那么就可以基于这个点去找到源码分析的突破口。那么自然而然我们就可以想到spring的配置

Dubbo的接入实现

Dubbo中spring扩展就是使用spring的自定义类型，所以同样也有NamespaceHandler、BeanDefinitionParser。而NamespaceHandler是DubboNamespaceHandler

public class DubboNamespaceHandler extends NamespaceHandlerSupport {  
  static {    
    Version.checkDuplicate(DubboNamespaceHandler.class);   
  }   

  public void init() {       
    registerBeanDefinitionParser("application", new DubboBeanDefinitionParser(ApplicationConfig.class, true));    
    registerBeanDefinitionParser("module", new DubboBeanDefinitionParser(ModuleConfig.class, true));   
    registerBeanDefinitionParser("registry", new DubboBeanDefinitionParser(RegistryConfig.class, true)); 
    registerBeanDefinitionParser("monitor", new DubboBeanDefinitionParser(MonitorConfig.class, true)); 
    registerBeanDefinitionParser("provider", new DubboBeanDefinitionParser(ProviderConfig.class, true)); 
    registerBeanDefinitionParser("consumer", new DubboBeanDefinitionParser(ConsumerConfig.class, true));        registerBeanDefinitionParser("protocol", new DubboBeanDefinitionParser(ProtocolConfig.class, true));
    registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));
    registerBeanDefinitionParser("reference", new DubboBeanDefinitionParser(ReferenceBean.class, false));  
    registerBeanDefinitionParser("annotation", new DubboBeanDefinitionParser(AnnotationBean.class, true)); 

  }
}

BeanDefinitionParser全部都使用了DubboBeanDefinitionParser，如果我们向看的配置，就直接看DubboBeanDefinitionParser中

这个里面主要做了一件事，把不同的配置分别转化成spring容器中的bean对象

application对应ApplicationConfig

registry对应RegistryConfig

monitor对应MonitorConfig

provider对应ProviderConfig

consumer对应ConsumerConfig

为了在spring启动的时候，也相应的启动provider发布服务注册服务的过程，而同时为了让客户端在启动的时候自动订阅发现服务，加入了两个bean

ServiceBean、ReferenceBean。

分别继承了ServiceConfig和ReferenceConfig

同时还分别实现了InitializingBean、DisposableBean, ApplicationContextAware, ApplicationListener, BeanNameAware

InitializingBean接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候会执行该方法。

DisposableBean bean被销毁的时候，spring容器会自动执行destory方法，比如释放资源

ApplicationContextAware 实现了这个接口的bean，当spring容器初始化的时候，会自动的将ApplicationContext注入进来

ApplicationListener ApplicationEvent事件监听，spring容器启动后会发一个事件通知

BeanNameAware 获得自身初始化时，本身的bean的id属性

那么基本的实现思路可以整理出来了

  1. 利用spring的解析收集xml中的配置信息，然后把这些配置信息存储到serviceConfig中
  2. 调用ServiceConfig的export方法来进行服务的发布和注册

服务的发布

ServiceBean

serviceBean是服务发布的切入点，通过afterPropertiesSet方法，调用export()方法进行发布。

export为父类ServiceConfig中的方法，所以跳转到SeviceConfig类中的export方法

public synchronized void export() {
  if (provider != null) {
    if (export == null) {
      export = provider.getExport();
    }
    if (delay == null) {
      delay = provider.getDelay();
    }
  }
  if (export != null && ! export.booleanValue()) {
    return;
  }
  if (delay != null && delay > 0) {
    Thread thread = new Thread(new Runnable() {
      public void run() {
        try {
          Thread.sleep(delay);
        } catch (Throwable e) {
        }
        doExport();
      }
    });
    thread.setDaemon(true);
    thread.setName("DelayExportServiceThread");
    thread.start();
  } else {
    doExport();
  }
}

我们发现，delay的作用就是延迟暴露，而延迟的方式也很直截了当，Thread.sleep(delay)

  1. export是synchronized修饰的方法。也就是说暴露的过程是原子操作，正常情况下不会出现锁竞争的问题，毕竟初始化过程大多数情况下都是单一线程操作，这里联想到了spring的初始化流程，也进行了加锁操作，这里也给我们平时设计一个不错的启示：初始化流程的性能调优优先级应该放的比较低，但是安全的优先级应该放的比较高！
  2. 继续看doExport()方法。同样是一堆初始化代码

export的过程

继续看doExport()，最终会调用到doExportUrls()中：

private void doExportUrls() {
  List registryURLs = loadRegistries(true);//是不是获得注册中心的配置
  for (ProtocolConfig protocolConfig : protocols) { //是不是支持多协议发布
    doExportUrlsFor1Protocol(protocolConfig, registryURLs);
  }
}

对应上述protocols长成这样protocols也是根据配置装配出来的，接下来进入对应的duExportUrlsFor1Protocol方法查看对应s具体实现

最终实现逻辑

//配置为none不暴露
if (! Constants.SCOPE_NONE.toString().equalsIgnoreCase(scope)) {

  //配置不是remote的情况下做本地暴露 (配置为remote，则表示只暴露远程服务)
  if (!Constants.SCOPE_REMOTE.toString().equalsIgnoreCase(scope)) {
    exportLocal(url);
  }
  //如果配置不是local则暴露为远程服务.(配置为local，则表示只暴露本地服务)
  if (! Constants.SCOPE_LOCAL.toString().equalsIgnoreCase(scope) ){
    if (logger.isInfoEnabled()) {
      logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
    }
    if (registryURLs != null && registryURLs.size() > 0
        && url.getParameter("register", true)) {
      for (URL registryURL : registryURLs) {
        url = url.addParameterIfAbsent("dynamic", registryURL.getParameter("dynamic"));
        URL monitorUrl = loadMonitor(registryURL);
        if (monitorUrl != null) {
          url = url.addParameterAndEncoded(Constants.MONITOR_KEY, monitorUrl.toFullString());
        }
        if (logger.isInfoEnabled()) {
          logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);
        }
        Invoker invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));

        Exporter exporter = protocol.export(invoker);
        exporters.add(exporter);
      }
    } else {
      Invoker invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, url);

      Exporter exporter = protocol.export(invoker);
      exporters.add(exporter);
    }
  }
}

从上述代码doExportUrlsFor1Protocol方法，先创建两个URL，分别如下

dubbo://192.168.xx.xx:20880/com.zzjson.IHello

registry://192.168.xx

其对应的url就是services的providers的信息

在上面这段代码中可以看到Dubbo的比较核心的抽象：Invoker， Invoker是一个代理类，从ProxyFactory中生成。这个地方可以做一个小结

  1. Invoker -执行具体的远程调用
  2. Protocol – 服务地址的发布和订阅
  3. Exporter – 暴露服务或取消暴露

Protocol$Adaptive

public class Protocol$Adaptive implements com.alibaba.dubbo.rpc.Protocol {
  public void destroy() {
    throw new UnsupportedOperationException("method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
  }

  public int getDefaultPort() {
    throw new UnsupportedOperationException("method public abstract int com.alibaba.dubbo.rpc.Protocol.getDefaultPort() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
  }

  public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) throws com.alibaba.dubbo.rpc.RpcException {
    if (arg1 == null) throw new IllegalArgumentException("url == null");
    com.alibaba.dubbo.common.URL url = arg1;
    String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
    if (extName == null)
      throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
    com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
    return extension.refer(arg0, arg1);
  }

  public com.alibaba.dubbo.rpc.Exporter export(com.alibaba.dubbo.rpc.Invoker arg0) throws com.alibaba.dubbo.rpc.RpcException {
    if (arg0 == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");
    if (arg0.getUrl() == null)
      throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");
    com.alibaba.dubbo.common.URL url = arg0.getUrl();
    String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
    if (extName == null)
      throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
    com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
    return extension.export(arg0);
  }
}

上述代码做两件事

  1. 从url中获得protocol的协议地址，如果protocol为空，表示通过dubbo协议发布服务，否则根据配置的谢意类型来发布服务
  2. 调用ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(extName)

getExtension()

public T getExtension(String name) {
  if (name == null || name.length() == 0)
    throw new IllegalArgumentException("Extension name == null");
  if ("true".equals(name)) {
    return getDefaultExtension();
  }
  Holder holder = cachedInstances.get(name);
  if (holder == null) {
    cachedInstances.putIfAbsent(name, new Holder());
    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;
} 
 
createExtension()
 
 
@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);
      //在loadFile中进行赋值的
        Set> wrapperClasses = cachedWrapperClasses;
        if (wrapperClasses != null && wrapperClasses.size() > 0) {
            for (Class wrapperClass : wrapperClasses) {
              //对实例进行包装，分别调用带Protocol参数的构造函数创建实例，然后进行依赖注入
                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. 根据name获取对应的class
    2.  
  
  2. 根据calss创建一个实例
    3.  
  
  3. 对获取的实例进行依赖注入
    4.  
  
  4. 对实例进行包装，分别调用带Protocol参数的构造函数创建实例，然后进行依赖注入
    5.  
  
  5. 在dubbo-rpc-api的resources路径下，找到com.alibaba.dubbo.rpc.Protocol文件中存在filter/listener 
    6.  
  
  6. 遍历cachedWrapperClass对DubboProtocol进行包装，会通过ProtocolFilterWrapper,ProtocolListenerWrapper包装
    7.  
 
 
 
private Map> getExtensionClasses() {
  Map> classes = cachedClasses.get();
  if (classes == null) {
    synchronized (cachedClasses) {
      classes = cachedClasses.get();
      if (classes == null) {
        classes = loadExtensionClasses();
        cachedClasses.set(classes);
      }
    }
  }
  return classes;
}
 
 
总结
 
 
在ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(extName);这段代码中，当extName为registry的时候，我们不需要再次去阅读这块代码了，直接可以在扩展点中找到相应的实现扩展类，/dubbo-registry-api/src/main/resources/META-INF/dubbo/internal/com.alibaba.dubbo.rpc.Protocol配置如下
 
 
registry=com.alibaba.dubbo.registry.integration.RegistryProtocol
 
 
所以我们定位到RegistryProtocolRegistryProtocol这个类中的export方法
 
 
public  Exporter export(final Invoker originInvoker) throws RpcException {
  //export invoker
  final ExporterChangeableWrapper exporter = doLocalExport(originInvoker);
  //registry provider
  final Registry registry = getRegistry(originInvoker);
  final URL registedProviderUrl = getRegistedProviderUrl(originInvoker);
  registry.register(registedProviderUrl);
  // 订阅override数据
  // FIXME 提供者订阅时，会影响同一JVM即暴露服务，又引用同一服务的的场景，因为subscribed以服务名为缓存的key，导致订阅信息覆盖。
  final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registedProviderUrl);
  final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl);
  overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
  registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
  //保证每次export都返回一个新的exporter实例
  return new Exporter() {
    public Invoker getInvoker() {
      return exporter.getInvoker();
    }
    public void unexport() {
      try {
        exporter.unexport();
      } catch (Throwable t) {
        logger.warn(t.getMessage(), t);
      }
      try {
        registry.unregister(registedProviderUrl);
      } catch (Throwable t) {
        logger.warn(t.getMessage(), t);
      }
      try {
        overrideListeners.remove(overrideSubscribeUrl);
        registry.unsubscribe(overrideSubscribeUrl, overrideSubscribeListener);
      } catch (Throwable t) {
        logger.warn(t.getMessage(), t);
      }
    }
  };
}
 
 
doLoalExport()
 
 
上述doLoaclExport源码为：
 
 
private Protocol protocol;

public void setProtocol(Protocol protocol) {
  this.protocol = protocol;
}
@SuppressWarnings("unchecked")
private  ExporterChangeableWrapper  doLocalExport(final Invoker originInvoker){
  String key = getCacheKey(originInvoker);
  ExporterChangeableWrapper exporter = (ExporterChangeableWrapper) bounds.get(key);
  if (exporter == null) {
    synchronized (bounds) {
      exporter = (ExporterChangeableWrapper) bounds.get(key);
      if (exporter == null) {
        final Invoker invokerDelegete = new InvokerDelegete(originInvoker, getProviderUrl(originInvoker));
        exporter = new ExporterChangeableWrapper((Exporter)protocol.export(invokerDelegete), originInvoker);
        bounds.put(key, exporter);
      }
    }
  }
  return (ExporterChangeableWrapper) exporter;
}
 
 
上述代码Protocol代码是怎么复制的呢，是在injectExtension方法中对已经加载的扩展点的属性进行依赖注入了
 
 
protocol发布服务
 
 
因此我们知道protocol是一个自适应扩展点，Protocol$Adaptive，然后调用这个自适应扩展点中的export方法，这个时候传入的协议地址应该是
 
 
dubbo://127.0.0.1/xxx因此在Protocol$Adaptive.export方法中，ExtensionLoader.getExtension(Protocol.class).getExtension就是基于DubboProtocol协议发布服务了么？当然不是，此处获取的不是一个单纯的DubboProtocol扩展点，而是会通过Wrapper对Protocl进行装饰，装饰器分别为ProtocolFilterWrapper或者是ProtoclListenerWrapper，至于为什么MockProtocol为什么不在装饰器里面呢？我们可以想到，在ExtensionLoader.loadFile这段代码的时候，装饰器必须要有一个Protocol的构造方法，如下
 
 
public ProtocolFilterWrapper(Protocol protocol){
  if (protocol == null) {
    throw new IllegalArgumentException("protocol == null");
  }
  this.protocol = protocol;
}
 
 
至此，我们可以知道Protocol$Adaptive中的export方法会调用ProtocolFilterWrapper以及ProtocolListenerWrapper类的方法
 
 
ProtocolFilterWrapper
 
 
public class ProtocolFilterWrapper implements Protocol {

  private final Protocol protocol;

  public ProtocolFilterWrapper(Protocol protocol) {
    if (protocol == null) {
      throw new IllegalArgumentException("protocol == null");
    }
    this.protocol = protocol;
  }
//此方法读取所有的filter类，利用这些类封装invoker
  private static  Invoker buildInvokerChain(final Invoker invoker, String key, String group) {
    Invoker last = invoker;
    //自动激活扩展点，根据条件获取当前扩展可自动激活的实现
    List filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);
    if (!filters.isEmpty()) {
      for (int i = filters.size() - 1; i >= 0; i--) {
        final Filter filter = filters.get(i);
        final Invoker next = last;
        last = new Invoker() {

          @Override
          public Class getInterface() {
            return invoker.getInterface();
          }

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

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

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

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

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

  @Override
  public int getDefaultPort() {
    return protocol.getDefaultPort();
  }

  @Override
  public  Exporter export(Invoker 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));
  }

  @Override
  public  Invoker refer(Class 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);
  }

  @Override
  public void destroy() {
    protocol.destroy();
  }

}
 
 
ProtocolFilterWrapper这个类非常重要
 
 
     
  
  1. 他有一个参数为Protocol protocol构造参数
    2.  
  
  2. 它实现了Protocol接口
    3.  
  
  3. 使用了责任链模式，对export和refer函数进行了封装
    4.  
 
 
 
我们查看如下文件dubbo-rpc-api/src/main/resources/META-INF/dubbo/internal/com.alibaba.dubbo.rpc.Filter
 
 
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
 
 
可以看到，invoker通过如下的Filter组装成一个责任链
 
 
其中涉及到很多功能，包括权限验证，异常，超时等等，当然可以预计计算调用时间等等应该也是在这其中的某个类实现的，这里我们可以看到export和refer过程都会被filter过滤
 
 
ProtocolListenerWrapper
 
 
在这里我们可以看到export和refer分别对应了不同的Wrapper;export对应的ListenerExporterWrapper这块暂不去分析，因为此地方并没有提供实现类
 
 
public class ProtocolListenerWrapper implements Protocol {

  private final Protocol protocol;

  public ProtocolListenerWrapper(Protocol protocol){
    if (protocol == null) {
      throw new IllegalArgumentException("protocol == null");
    }
    this.protocol = protocol;
  }

  public int getDefaultPort() {
    return protocol.getDefaultPort();
  }

  public  Exporter export(Invoker invoker) throws RpcException {
    if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
      return protocol.export(invoker);
    }
    return new ListenerExporterWrapper(protocol.export(invoker), 
                                          Collections.unmodifiableList(ExtensionLoader.getExtensionLoader(ExporterListener.class)
                                                                       .getActivateExtension(invoker.getUrl(), Constants.EXPORTER_LISTENER_KEY)));
  }

  public  Invoker refer(Class type, URL url) throws RpcException {
    if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
      return protocol.refer(type, url);
    }
    return new ListenerInvokerWrapper(protocol.refer(type, url), 
                                         Collections.unmodifiableList(
                                           ExtensionLoader.getExtensionLoader(InvokerListener.class)
                                           .getActivateExtension(url, Constants.INVOKER_LISTENER_KEY)));
  }

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

}
 
 
我们看一下dubboProtocol的export方法：openServer(url）
 
 
DuoProtocol.export()
 
 
通过上述代码分析完以后，我们能够定位到DubboProtocol.export()方法
 
 
public  Exporter export(Invoker invoker) throws RpcException {
  URL url = invoker.getUrl();

  // export service.
  String key = serviceKey(url);
  DubboExporter exporter = new DubboExporter(invoker, key, exporterMap);
  exporterMap.put(key, exporter);

  //export an stub service for dispaching event
  Boolean isStubSupportEvent = url.getParameter(Constants.STUB_EVENT_KEY,Constants.DEFAULT_STUB_EVENT);
  Boolean isCallbackservice = url.getParameter(Constants.IS_CALLBACK_SERVICE, false);
  if (isStubSupportEvent && !isCallbackservice){
    String stubServiceMethods = url.getParameter(Constants.STUB_EVENT_METHODS_KEY);
    if (stubServiceMethods == null || stubServiceMethods.length() == 0 ){
      if (logger.isWarnEnabled()){
        logger.warn(new IllegalStateException("consumer [" +url.getParameter(Constants.INTERFACE_KEY) +
                                              "], has set stubproxy support event ,but no stub methods founded."));
      }
    } else {
      stubServiceMethodsMap.put(url.getServiceKey(), stubServiceMethods);
    }
  }
//暴露服务
  openServer(url);

  return exporter;
}
 
 
接着调用openServer
 
 
private void openServer(URL url) {
  // find server.
  String key = url.getAddress();//116.62.221.6:20880
  //client 也可以暴露一个只有server可以调用的服务。
  boolean isServer = url.getParameter(Constants.IS_SERVER_KEY,true);
  if (isServer) {
    ExchangeServer server = serverMap.get(key);
    if (server == null) {//没有的话就创建服务
      serverMap.put(key, createServer(url));
    } else {
      //server支持reset,配合override功能使用
      server.reset(url);
    }
  }
}
 
 
createServer()
 
 
继续看其中的createServer方法：
 
 
private ExchangeServer createServer(URL url) {
  //默认开启server关闭时发送readonly事件
  url = url.addParameterIfAbsent(Constants.CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString());
  //默认开启heartbeat
  url = url.addParameterIfAbsent(Constants.HEARTBEAT_KEY, String.valueOf(Constants.DEFAULT_HEARTBEAT));
  String str = url.getParameter(Constants.SERVER_KEY, Constants.DEFAULT_REMOTING_SERVER);

  if (str != null && str.length() > 0 && ! ExtensionLoader.getExtensionLoader(Transporter.class).hasExtension(str))
    throw new RpcException("Unsupported server type: " + str + ", url: " + url);

  url = url.addParameter(Constants.CODEC_KEY, Version.isCompatibleVersion() ? COMPATIBLE_CODEC_NAME : DubboCodec.NAME);
  ExchangeServer server;
  try {
    server = Exchangers.bind(url, requestHandler);
  } catch (RemotingException e) {
    throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
  }
  str = url.getParameter(Constants.CLIENT_KEY);
  if (str != null && str.length() > 0) {
    Set supportedTypes = ExtensionLoader.getExtensionLoader(Transporter.class).getSupportedExtensions();
    if (!supportedTypes.contains(str)) {
      throw new RpcException("Unsupported client type: " + str);
    }
  }
  return server;
}
 
 
创建服务，然后开启心跳监测，默认使用netty 。组装url
 
 
Exchanger.bind()
 
 
发现ExchangeServer是通过Exchangers创建的，直接看Exchanger.bind方法
 
 
public static ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
  if (url == null) {
    throw new IllegalArgumentException("url == null");
  }
  if (handler == null) {
    throw new IllegalArgumentException("handler == null");
  }
  url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
  return getExchanger(url).bind(url, handler);
}
 
 
getExchanger方法实际上调用的是ExtensionLoader的相关方法，这里的ExtensionLoader是dubbo插件化的核心，我们会在后面的插件化讲解中详细讲解，这里我们只需要知道Exchanger的默认实现只有一个：HeaderExchanger。上面一段代码最终调用的是：
 
 
public static Exchanger getExchanger(URL url) {
  String type = url.getParameter(Constants.EXCHANGER_KEY, Constants.DEFAULT_EXCHANGER);
  return getExchanger(type);
}

public static Exchanger getExchanger(String type) {
  return ExtensionLoader.getExtensionLoader(Exchanger.class).getExtension(type);
}

 
 
public class HeaderExchanger implements Exchanger {

  public static final String NAME = "header";

  public ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
    return new HeaderExchangeClient(Transporters.connect(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
  }

  public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
    return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
  }

}
 
 
可以看到Server与Client实例均是在这里创建的，HeaderExchangeServer需要一个Server类型的参数，来自Transporters.bind()：
 
 
Transporters.bind()
 
 
public static Server bind(URL url, ChannelHandler... handlers) throws RemotingException {
  if (url == null) {
    throw new IllegalArgumentException("url == null");
  }
  if (handlers == null || handlers.length == 0) {
    throw new IllegalArgumentException("handlers == null");
  }
  ChannelHandler handler;
  if (handlers.length == 1) {
    handler = handlers[0];
  } else {
    handler = new ChannelHandlerDispatcher(handlers);
  }
  return getTransporter().bind(url, handler);
} 
 
 
getTransporter()获取的实例来源于配置，默认返回一个NettyTransporter：
 
 
NettyTransport.bind()
 
 
通过NettyTranport创建基于Netty的server服务
 
 
public class NettyTransporter implements Transporter {

  public static final String NAME = "netty";

  public Server bind(URL url, ChannelHandler listener) throws RemotingException {
    return new NettyServer(url, listener);
  }

  public Client connect(URL url, ChannelHandler listener) throws RemotingException {
    return new NettyClient(url, listener);
  }

}
 
 
在调用HeaderExchanger.bind()方法的时候，是先new一个HeaderExchangeServer这个server是干嘛呢，是对当前这个链接去建立心跳机制
 
 
public class HeaderExchangeServer implements ExchangeServer {

  protected final Logger        logger = LoggerFactory.getLogger(getClass());

  private final ScheduledExecutorService scheduled   = Executors.newScheduledThreadPool(1,new NamedThreadFactory("dubbo-remoting-server-heartbeat",  true);

  // 心跳定时器
  private ScheduledFuture heatbeatTimer;

  // 心跳超时，毫秒。缺省0，不会执行心跳。
  private int                            heartbeat;

  private int                            heartbeatTimeout;

  private final Server server;

  private volatile boolean closed = false;

  public HeaderExchangeServer(Server server) {
    if (server == null) {
      throw new IllegalArgumentException("server == null");
    }
    this.server = server;
    this.heartbeat = server.getUrl().getParameter(Constants.HEARTBEAT_KEY, 0);
    this.heartbeatTimeout = server.getUrl().getParameter(Constants.HEARTBEAT_TIMEOUT_KEY, heartbeat * 3);
    if (heartbeatTimeout < heartbeat * 2) {
      throw new IllegalStateException("heartbeatTimeout < heartbeatInterval * 2");
    }
    //心跳
    startHeatbeatTimer();
  }
  private void startHeatbeatTimer() {
    //关闭心跳定时
    stopHeartbeatTimer();
    if (heartbeat > 0) {
      //每隔heartbeat时间执行一次
      heatbeatTimer = scheduled.scheduleWithFixedDelay(
        new HeartBeatTask( new HeartBeatTask.ChannelProvider() {
          //获取channels
          public Collection getChannels() {
            return Collections.unmodifiableCollection(
              HeaderExchangeServer.this.getChannels() );
          }
        }, heartbeat, heartbeatTimeout),
        heartbeat, heartbeat,TimeUnit.MILLISECONDS);
    }
  }
    //关闭心跳定时
  private void stopHeartbeatTimer() {
    try {
      ScheduledFuture timer = heatbeatTimer;
      if (timer != null && ! timer.isCancelled()) {
        timer.cancel(true);
      }
    } catch (Throwable t) {
      logger.warn(t.getMessage(), t);
    } finally {
      heatbeatTimer =null;
    }
  }

}
 
 
心跳线程HeartBeatTask在超时时间之内发送数据，在超时时间之外，是客户端的话，重连；是服务端，那么关闭服务端发布。
 
 
 
 
服务的注册
 
 
前面我们知道，基于Spring的这个解析入口，到发布服务的过程，接着基于DubboProtocol去发布，最终调用Netty的api创建了一个NettyServer。
 
 
那么继续沿着RegistryProtocol.export这个方法，来看看注册服务的代码
 
 
RegistryProtocol.export()
 
 
public  Exporter export(final Invoker originInvoker) throws RpcException {
  //export invoker
  final ExporterChangeableWrapper exporter = doLocalExport(originInvoker);
  //registry provider
  final Registry registry = getRegistry(originInvoker);
  final URL registedProviderUrl = getRegistedProviderUrl(originInvoker);
  registry.register(registedProviderUrl);
  // 订阅override数据
  // FIXME 提供者订阅时，会影响同一JVM即暴露服务，又引用同一服务的的场景，因为subscribed以服务名为缓存的key，导致订阅信息覆盖。
  final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registedProviderUrl);
  final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl);
  overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
  registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
  //保证每次export都返回一个新的exporter实例
  return new Exporter() {
    public Invoker getInvoker() {
      return exporter.getInvoker();
    }
    public void unexport() {
      try {
        exporter.unexport();
      } catch (Throwable t) {
        logger.warn(t.getMessage(), t);
      }
      try {
        registry.unregister(registedProviderUrl);
      } catch (Throwable t) {
        logger.warn(t.getMessage(), t);
      }
      try {
        overrideListeners.remove(overrideSubscribeUrl);
        registry.unsubscribe(overrideSubscribeUrl, overrideSubscribeListener);
      } catch (Throwable t) {
        logger.warn(t.getMessage(), t);
      }
    }
  };
}
 
 
getRegistry()
 
 
private RegistryFactory registryFactory;

public void setRegistryFactory(RegistryFactory registryFactory) {
  this.registryFactory = registryFactory;
}
private Registry getRegistry(final Invoker originInvoker){
  URL registryUrl = originInvoker.getUrl();//获得registry://192.168.xx.xx:2181的协议地址
  if (Constants.REGISTRY_PROTOCOL.equals(registryUrl.getProtocol())) {
    //得到zk的谢意地址
    String protocol = registryUrl.getParameter(Constants.REGISTRY_KEY, Constants.DEFAULT_DIRECTORY);
    //registryUrl就会变成了zookeeper://192.168.xx.xx
    registryUrl = registryUrl.setProtocol(protocol).removeParameter(Constants.REGISTRY_KEY);
  }
  //registryFactory是什么
  return registryFactory.getRegistry(registryUrl);
}
 
 
上述代码很明显了，通过分析，其实就是把registry的协议头改成服务提供者配置的协议地址，就是我们配置
 
 
的
 
 
 
 
然后registryFactory.getRegistry的目的，就是通过协议地址匹配到对应的注册中心。那registryFactory是一个什么样的对象呢，从上述我们可以才，其是一个扩展点，并且我们能够注意到这里面的一个方法上有一个@Adaptive的注解，说明了其实一个自适应扩展点，按照我们之前看过的代码，自适应扩展点加在方法层面上，表示会动态生成一个自适应的适配器，所以这个自适应适配器应该是RegistryFactory$Adaptive
 
 
@SPI("dubbo")
public interface RegistryFactory {

  /**
     * 连接注册中心.
     * 
     * 连接注册中心需处理契约：

     * 1. 当设置check=false时表示不检查连接，否则在连接不上时抛出异常。

     * 2. 支持URL上的username:password权限认证。

     * 3. 支持backup=10.20.153.10备选注册中心集群地址。

     * 4. 支持file=registry.cache本地磁盘文件缓存。

     * 5. 支持timeout=1000请求超时设置。

     * 6. 支持session=60000会话超时或过期设置。

     * 
     * @param url 注册中心地址，不允许为空
     * @return 注册中心引用，总不返回空
     */
  @Adaptive({"protocol"})
  Registry getRegistry(URL url);

}
 
 
RegistryFactory$Adaptive
 
 
public class RegistryFactory$Adaptive implements com.alibaba.dubbo.registry.RegistryFactory {
  public com.alibaba.dubbo.registry.Registry getRegistry(com.alibaba.dubbo.common.URL arg0) {
    if (arg0 == null) throw new IllegalArgumentException("url == null");
    com.alibaba.dubbo.common.URL url = arg0;
    String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
    if (extName == null)
      throw new IllegalStateException("Fail to get     extension(com.alibaba.dubbo.registry.RegistryFactory) " +"name from url(" + url.toString() + ") usekeys([protocol])")";      
      com.alibaba.dubbo.registry.RegistryFactory extension =       (com.alibaba.dubbo.registry.RegistryFactory)
      ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.registry.Reg                               istryFactory.class).getExtension(extName);
    return extension.getRegistry(arg0);
  }
}
 
 
我们拿到这个动态生成的自适应扩展点，看看这段代码中的实现
 
 
     
  
  1. 从url中拿到协议头信息，这个时候的协议头是zookeeper:// 
    2.  
  
  2. 通过ExtensionLoader.getExtensionLoader(RegistryFactory.class).getExtension("zookeeper")去获得一个指定的扩展点，而这个扩展点的配置在
    3.  
 
 
 
/dubbo-registry/dubbo-registry-zookeeper/src/main/resources/META-INF/dubbo/internal/com.alibaba.dubbo.registry.RegistryFactory
 
 
内容为
 
 
zookeeper=com.alibaba.dubbo.registry.zookeeper.ZookeeperRegistryFactory
 
 
ZookeeperRegistryFactory
 
 
public class ZookeeperRegistryFactory extends AbstractRegistryFactory {

  private ZookeeperTransporter zookeeperTransporter;

  public void setZookeeperTransporter(ZookeeperTransporter zookeeperTransporter) {
    this.zookeeperTransporter = zookeeperTransporter;
  }

  public Registry createRegistry(URL url) {
    return new ZookeeperRegistry(url, zookeeperTransporter);
  }

}
 
 
此方法中并没有getRegistry方法，而是在父类AbstractRegistryFactory
 
 
public Registry getRegistry(URL url) {
  url = url.setPath(RegistryService.class.getName())
    .addParameter(Constants.INTERFACE_KEY, RegistryService.class.getName())
    .removeParameters(Constants.EXPORT_KEY, Constants.REFER_KEY);
  String key = url.toServiceString();
  // 锁定注册中心获取过程，保证注册中心单一实例
  LOCK.lock();
  try {
    Registry registry = REGISTRIES.get(key);
    if (registry != null) {
      return registry;
    }
    registry = createRegistry(url);
    if (registry == null) {
      throw new IllegalStateException("Can not create registry " + url);
    }
    REGISTRIES.put(key, registry);
    return registry;
  } finally {
    // 释放锁
    LOCK.unlock();
  }
}
 
 
上述方法
 
 
     
  
  1. 从缓存REGISTRIES中，根据key获得对应的Registry 
    2.  
  
  2. 如果不存在，则创建
    3.  
 
 
 
createRegistry
 
 
    public Registry createRegistry(URL url) {
        return new ZookeeperRegistry(url, zookeeperTransporter);
    }


 
 
public ZookeeperRegistry(URL url, ZookeeperTransporter zookeeperTransporter) {
  super(url);
  if (url.isAnyHost()) {
    throw new IllegalStateException("registry address == null");
  }
  String group = url.getParameter(Constants.GROUP_KEY, DEFAULT_ROOT);
  if (! group.startsWith(Constants.PATH_SEPARATOR)) {
    group = Constants.PATH_SEPARATOR + group;
  }
  this.root = group;
  zkClient = zookeeperTransporter.connect(url);
  zkClient.addStateListener(new StateListener() {
    public void stateChanged(int state) {
      if (state == RECONNECTED) {
        try {
          recover();
        } catch (Exception e) {
          logger.error(e.getMessage(), e);
        }
      }
    }
  });
}
 
 
代码分析到这，我们对于getRegistry得出结论根据当前注册中心的配置信息，获得一个匹配的注册中心，也就是ZookeeperRegistry registry.register(registedProviderUrl)
 
 
继续往下看会调用对应的registry.register去把dubbo://的谢意地址注册到zookeeper上，这个方法会调用FailbackRegistry类中的register,因为其父类FailbackRegistry中存在register方法，而这个类重写了此方法，所以我们可以直接定位到FailbackRegistry这个类中的register方法中
 
 
FailbackRegistry.register
 
 
@Override
public void register(URL url) {
  super.register(url);
  failedRegistered.remove(url);
  failedUnregistered.remove(url);
  try {
    // 向服务器端发送注册请求
    doRegister(url);
  } catch (Exception e) {
    Throwable t = e;

    // 如果开启了启动时检测，则直接抛出异常
    boolean check = getUrl().getParameter(Constants.CHECK_KEY, true)
      && url.getParameter(Constants.CHECK_KEY, true)
      && ! Constants.CONSUMER_PROTOCOL.equals(url.getProtocol());
    boolean skipFailback = t instanceof SkipFailbackWrapperException;
    if (check || skipFailback) {
      if(skipFailback) {
        t = t.getCause();
      }
      throw new IllegalStateException("Failed to register " + url + " to registry " + getUrl().getAddress() + ", cause: " + t.getMessage(), t);
    } else {
      logger.error("Failed to register " + url + ", waiting for retry, cause: " + t.getMessage(), t);
    }

    // 将失败的注册请求记录到失败列表，定时重试
    failedRegistered.add(url);
  }
}
 
 
从名字上来看，是一个失败重试机制，调用父类的register方法把当前url添加到缓存集合中，调用子类的doRegister方法
 
 
protected void doRegister(URL url) {
  try {
    zkClient.create(toUrlPath(url), url.getParameter(Constants.DYNAMIC_KEY, true));
  } catch (Throwable e) {
    throw new RpcException("Failed to register " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
  }
}
 
 
可以看到，调用了zkclient.create在zookeeper中创建节点
 
 
最后RegistryProtocol.export这个方法之后的代码不再分析了，就是去服务提供端注册一个zookeeper监听，当监听发生变化的时候，服务端做相应的处理。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(dubbo)

        

            

                
    
                    
  • Dubbo架构概览：服务注册与发现、远程调用、监控与管理
                        木南曌
dubbo架构
                        
    Dubbo是一个成熟的、高性能的、基于Java的微服务开发框架，它主要用于解决分布式系统中的服务治理问题，包括服务的注册与发现、远程过程调用（RPC）、服务监控与管理等多个关键环节。以下是Dubbo架构概览的详细介绍：服务注册与发现Dubbo的服务注册与发现机制是其核心功能之一，它依赖于注册中心来管理服务的生命周期和定位服务提供者。1.服务提供者（Provider）服务提供者是实际提供服务的节点，
    
                    
    • 
                    
  • 主流行架构
                        rainbowcheng
架构架构
                        
    nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
    
                    
    • 
                    
  • 深入解析 Dubbo 的 attachments 机制及其应用场景
                        molashaonian
dubboattachments隐式传参
                        
    背景在分布式系统中，服务之间的调用（RPC调用）是非常常见的。而在这种服务调用过程中，常常需要在不同服务之间传递一些上下文信息，比如用户身份信息、请求追踪ID、客户端IP等。Dubbo提供的attachments机制，能够帮助开发者在RPC调用时隐式传递这些数据，而不需要修改接口方法签名。通过分析架构图，我们可以看到，在服务调用链路中，使用Dubbo的attachments机制可以简化上下文信息的
    
                    
    • 
                    
  • 自己实现一个简易RPC调用框架
                        殷俊杰

                        
    最近在看dubbo，去创始人之一梁飞大神的博客搂了几眼，找到这个demo自己实现了一下，关于dubbo就不再介绍了，快速开始、框架设计、设计原则官网都有，有兴趣可以自己看Dubbo官网1.服务接口packagecom.yjj.my.api;/***@Description:*@Author:yinjunjie*@CreateDate:2018/8/713:16*@Version:1.0*/publ
    
                    
    • 
                    
  • Dubbo 与 Zookeeper 在项目中的应用：原理与实现详解
                        CopyLower
学习Javadubbozookeeper分布式
                        
    引言在微服务架构日益普及的今天，如何实现服务的高效调用和管理成为了关键问题。Dubbo作为阿里巴巴开源的高性能RPC框架，在分布式服务治理方面具有显著的优势。Zookeeper作为一款分布式协调服务，能够高效地管理和协调服务节点信息。因此，Dubbo与Zookeeper的结合不仅能够提供服务注册与发现机制，还能实现更高效的服务治理。在本文中，我们将深入探讨Dubbo和Zookeeper的原理、如何
    
                    
    • 
                    
  • dubbo整合nacos（狠狠踩坑 之 自己淋过雨不想让别人也一起）
                        程序员-珍
dubbo微服务springbootjava后端
                        
    快速入门1.dubbo官网强烈推荐小伙伴们去官网看看哪里写的都不如官网。我是看了网上的代码，狠狠踩坑，这个东西搞了好久~~~2.消费服务和提供服务都加上依赖org.apache.dubbodubbo3.0.9com.alibaba.nacosnacos-client2.1.03.创建一个DemoService接口和一个DemoServiceImpl实现类，DemoService类上面要加上注解@D
    
                    
    • 
                    
  • Dubbo服务自动Web化之路
                        搜狐技术产品小编2023
dubbo前端
                        
    本文字数：6047字预计阅读时间：40分钟01故障出现事情起源于一次故障，2023年12月14日14点26分，大量Dubbo服务报出异常，无法链接zookeeper集群：Session0x0 for serverdubboZk.xxx.com/10.x.x.x:2181, Closingsocketconnection. AttemptingreconnectexceptitisaSessionE
    
                    
    • 
                    
  • SpringBoot整合Dubbo(基于Nacos2)
                        KenithZhang

                        
    1.前言这是一个基于SpringBoot整合ApacheDubbo+Nacos的极简教程，笔者使用到的技术及版本如下：SpringBoot2.4.5Dubbo2.7.11Nacos2.0.1（自行安装）Dubbo官网：https://dubbo.apache.org/zh/Nacos官网：https://nacos.io/zh-cn/docs/quick-start.html2.目录结构dubbo
    
                    
    • 
                    
  • dubbo 服务消费原理分析之服务目录
                        DEARM LINER
dubbojava架构后端springboot
                        
    文章目录前言一、RegistryDirectory1、DynamicDirectory2、RegistryProtocol.doCreateInvoker2、RegistryProtocol.subscribe3、ListenerRegistryWrapper.subscribe4、FailbackRegistry.subscribe5、ZookeeperRegistry.doSubscribe6
    
                    
    • 
                    
  • dubbo spi 原理分析
                        DEARM LINER
dubbospringjavaspringboot后端
                        
    文章目录前言一、加载固定的扩展类1、ExtensionLoader.getExtension2、createExtension3、getExtensionClasses4、loadExtensionClasses5、cacheDefaultExtensionName6、loadDirectory7、loadResource8、loadClass二、加载自适应扩展类1、ExtensionLoader
    
                    
    • 
                    
  • dubbo k8s 服务发现_Dubbo 迈出云原生重要一步 - 应用级服务发现解析
                        weixin_39775127
dubbok8s服务发现
                        
    作者|刘军(陆龟)ApacheDubboPMC概述社区版本Dubbo从2.7.5版本开始，新引入了一种基于实例(应用)粒度的服务发现机制，这是我们为Dubbo适配云原生基础设施的一步重要探索。版本发布到现在已有近半年时间，经过这段时间的探索与总结，我们对这套机制的可行性与稳定性有了更全面、深入的认识；同时在Dubbo3.0的规划也在全面进行中，如何让应用级服务发现成为未来下一代服务框架Dubbo3
    
                    
    • 
                    
  • dubbo k8s 服务发现_Dubbo 迈出云原生重要一步 应用级服务发现解析
                        倩Sur
dubbok8s服务发现
                        
    作者|刘军(陆龟)ApacheDubboPMC概述社区版本Dubbo从2.7.5版本开始，新引入了一种基于实例(应用)粒度的服务发现机制，这是我们为Dubbo适配云原生基础设施的一步重要探索。版本发布到现在已有近半年时间，经过这段时间的探索与总结，我们对这套机制的可行性与稳定性有了更全面、深入的认识；同时在Dubbo3.0的规划也在全面进行中，如何让应用级服务发现成为未来下一代服务框架Dubbo3
    
                    
    • 
                    
  • springboot-2.3.3+dubbo-2.7.8+nacos-1.3.2+gateway-Hoxton.SR8
                        qjyn1314
dubbonacosspring-bootjavaspringbootspring后端
                        
    序言：此次介绍的实践是dubbo-2.7.8+nacos-1.3.2+gateway-Hoxton.SR81、升级注册中心，。其目的是项目中要从使用dubbo+zookeeper服务间调用升级为dubbo+nacos服务间调用。第一点可以参考：https://blog.csdn.net/lwb314/article/details/1082338632、升级网关，在升级之前有可能使用的是vue在前
    
                    
    • 
                    
  • Jmeter、Python、Postman测试工具对比
                        测试界的海飞丝
软件测试自动化测试测试工具jmeterpython
                        
    一、JMeter总结：适合对代码不敏感的使用人员，不会代码也可以完成接口自动化，设计框架。适合紧急迭代的项目。JMeter接口测试的优势小巧轻量级，并且开源免费，社区接受度高，比较容易入门支持多协议，并提供了比较高级的扩展能力，允许自己定义和扩展新的协议支持，比如扩展支持阿里提供的Dubbo协议的JMeter插件等学习者不需要会代码，不需要编程，熟悉http请求，熟悉业务流程，就可以根据页面中in
    
                    
    • 
                    
  • 零基础搭建一套完整的微服务框架【window版】
                        superswang
dockerjava微服务
                        
    技术栈：springboot+dubbo+docker零基础搭即可建微服务，完整运行本文你想学到什么?本文将以实战方式，首先对“微服务”相关的概念进行概要介绍，然后开始手把手教你搭建这一整套完整的微服务系统。项目完整代码下载地址https://github.com/gggcgba/mall微服务架构解决了什么问题此系统建立完以后，你的整个系统将被拆分成一个个独立的子系统，独立运行，系统与系统之间通
    
                    
    • 
                    
  • 【Java】已解决：com.alibaba.dubbo.rpc.RpcException: No provider available from registry
                        屿小夏
javadubborpc
                        
    文章目录一、分析问题背景二、可能出错的原因三、错误代码示例四、正确代码示例服务提供者配置服务消费者配置注册中心配置（application.properties）五、注意事项已解决：com.alibaba.dubbo.rpc.RpcException:Noprovideravailablefromregistry一、分析问题背景在分布式系统中，Dubbo是一个非常流行的RPC框架，用于实现高性能的
    
                    
    • 
                    
  • python 调用 nacos 注册dubbo服务
                        庞少东
pythondubbo开发语言
                        
    Python,配置,配置管理,微服务相关视频讲解：python的or运算赋值用法用python编程Excel有没有用处？011_编程到底好玩在哪？查看python文件_输出py文件_cat_运行python文件_shelPython调用Nacos注册Dubbo服务在微服务架构中，Dubbo作为一种高性能、轻量级的远程服务框架，被广泛应用于各种大型系统中。而Nacos则是一个动态服务发现、配置管理平
    
                    
    • 
                    
  • Dubbo下的多版本并行开发测试解决方案（服务路由）
                        2401_84850808
dubbo
                        
    returnregistry.lookup(DevVersionRegisterFactoryWrapper.changeApplication((url)));}}写一个RegistryFactory的包装类/**@authorshirenchuangRegistryFactory的包装类，在注册的时候修改一下Application如果是迭代环境则把Appliacation=Applicatio
    
                    
    • 
                    
  • 构建Dubbo工程详解
                        yongge
微服务dubbo
                        
    2.1框架依赖MavenSpringBoot2.6.11Dubbo3.1.8+zookeeper3.4.142.2搭建Zookeeper解压修改zk的配置文件进入conf，将文件zoo_sample.cfg改为zoo.cfg测试zk启动zookeeper执行zookeeper根目录下，bin文件中的zkServer.cmd上面的CMD窗口不要关闭，这样zookeeper就是出于运行状态了2.3创建
    
                    
    • 
                    
  • Sublime text3+python3配置及插件安装
                        raysonfang

                        
    作者：方雷个人博客：http://blog.chargingbunk.cn/微信公众号：rayson_666(Rayson开发分享)个人专研技术方向：微服务方向：springboot,springCloud,Dubbo分布式/高并发：分布式锁，消息队列RabbitMQ大数据处理：Hadoop,spark,HBase等python方向：pythonweb开发一，前言在网上搜索了一些Python开发的
    
                    
    • 
                    
  • Jmeter进阶-接口自动化
                        俊俏的萌妹纸
jmeter自动化运维
                        
    JMeter是一款广泛使用的开源软件，它不仅可以用于性能测试，还可以用于接口自动化测试。以下是JMeter进行接口自动化测试的一些优缺点：优点：易用性：JMeter上手简单，大部分操作都有对应的元件帮助完成，开源且社区接受度高。灵活性：提供BeanShell脚本能力，允许自定义扩展新的协议支持，比如Dubbo协议的JMeter插件。支持多种协议：除了HTTP，还支持JDBC等，能够将测试结果存入数
    
                    
    • 
                    
  • dubbo报错：not support none serializable class org.springframework.security.web.servletapi.HttpServlet3
                        JH3073
dubbo
                        
    Dubbo报错提示notsupportnoneserializableclass表示Dubbo在尝试序列化某个对象时遇到了问题。这里的问题是org.springframework.security.web.servletapi.HttpServlet3RequestFactory$Servlet3SecurityContextHolderAwareRequestWrapper类没有实现序列化接口，
    
                    
    • 
                    
  • 微服务--Nacos
                        顾以沫
微服务微服务架构云原生
                        
    一、Nacos简介Nacos（NamingandConfigurationService）是阿里巴巴开源的一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。它致力于帮助开发者快速实现动态服务发现、服务配置、服务元数据及流量管理。Nacos支持几乎所有主流类型的服务的发现、配置和管理，包括KubernetesService、gRPC&DubboRPCService、SpringClou
    
                    
    • 
                    
  • rpc详解rpc框架
                        思静语
网络通信rpc网络协议网络
                        
    文章目录概述rpc的优点组件工作流程&RPC的底层原理RPC的底层原理RPC框架rpc框架优点RPC的实现基础RPC的应用场景RPC使用了哪些关键技术rpc调用异常一般怎么处理rpc和http的区别为什么RPC要比HTTP更快一些Dubbo和openfeign区别远程调用RPC框架传输协议传输速度概述在互联网应用开发中，随着业务的复杂度增加，一般都会采用分布式架构。分布式架构的核心，就是利用多台普
    
                    
    • 
                    
  • Dubbo与Netty
                        蹩脚的小三

                        
    CodecCodecSupportAbstractCodecTransportCodecCodecAdapterDispacherChannelHandlersDispatcherAllDispatcherAllChannelHandlerChannelEventRunnableWrappedChannelHandlerChannelHandlerChannelHandlerAdapterChan
    
                    
    • 
                    
  • dubbo实战之一：准备和初体验
                        联旺

                        
    《dubbo实战》系列的父工程为了方便管理《dubbo实战》系列的代码和依赖库版本的管理，这里创建名为dubbopractice的父maven工程，整个系列的后续源码都会作为它的子工程；dubbopractice的pom.xml内容如下：practiceinterfacehelloxmldirectproviderhelloxmldirectconsumerspringbootzkprovider
    
                    
    • 
                    
  • 第15章 Dubbo 负载均衡的设计与实现
                        原水寒

                        
    image.pngLoadBalance：负载均衡SPI接口；AbstractLoadBalance：负载均衡模板基类；提供了“获取一个Invoker(filtered)的权重”的方式：获取当前Invoker设置的权重weight和预热时间warmup，并且计算启动至今时间uptime如果uptimewarmup，表示预热期过了，则直接返回weight=100，不再计算）RandomLoadBal
    
                    
    • 
                    
  • dubbo的负载均衡算法及使用
                        疾行的灬蜗牛
dubbo分布式
                        
    dubbo提供了额四种负载均衡策略，如果不填，默认使用random随机调用。1.RandomLoadBalance按照权重设置随机概率。在一个界面上碰撞的概率高，但调用量越大分布越均匀，按概率使用权重后也比较均匀，有利于动态调整服务提供者的权重2.RoundRobinLoadBalance轮询，按照在代码中的配置或者dubbo-admin中设置的权重设置轮询比率。存在的问题：响应请求慢或者卡住的机
    
                    
    • 
                    
  • dubbo负载均衡策略
                        小飞侠-2
java
                        
    负载均衡算法在集群负载均衡时，Dubbo提供了4种均衡策略，如：RandomLoadBalance(随机均衡算法)、；RoundRobinLoadBalance(权重轮循均衡算法)、LeastActionLoadBalance(最少活跃调用数均衡算法)、ConsistentHashLoadBalance(一致性Hash均衡算法)。缺省时为Random随机调用。这四种算法的原理简要介绍如下：1、Ro
    
                    
    • 
                    
  • Dubbo ZooKeeper Spring Boot整合
                        程序员T哥
分布式架构java-zookeeperdubbozookeeperjavaspringboot
                        
    依赖配置1.Dubbo起步依赖Dubbo是一款高性能的JavaRPC框架，用于快速开发高性能的服务。org.apache.dubbodubbo-spring-boot-starter${dubbo.version}2.ZooKeeperAPI管理依赖org.apache.curatorcurator-recipes${curator.version}3.ZooKeeper依赖org.apache.
    
                    
    • 
                                
  • 异常的核心类Throwable
                                    无量
java源码异常处理exception
                                    
    java异常的核心是Throwable，其他的如Error和Exception都是继承的这个类 里面有个核心参数是detailMessage，记录异常信息，getMessage核心方法，获取这个参数的值，我们可以自己定义自己的异常类，去继承这个Exception就可以了，方法基本上，用父类的构造方法就OK，所以这么看异常是不是很easy 
 
 
 
package com.natsu;



    
                                
    • 
                                
  • mongoDB 游标（cursor） 实现分页 迭代
                                    开窍的石头
mongodb
                                    
    上篇中我们讲了mongoDB 中的查询函数，现在我们讲mongo中如何做分页查询 
 
     如何声明一个游标 
       var mycursor = db.user.find({_id:{$lte:5}}); 
      迭代显示游标数
    
                                
    • 
                                
  • MySQL数据库INNODB 表损坏修复处理过程
                                    0624chenhong
tomcatmysql
                                    
    最近mysql数据库经常死掉，用命令net stop mysql命令也无法停掉，关闭Tomcat的时候，出现Waiting for N instance(s) to be deallocated 信息。查了下，大概就是程序没有对数据库连接释放，导致Connection泄露了。因为用的是开元集成的平台，内部程序也不可能一下子给改掉的，就验证一下咯。启动Tomcat,用户登录系统，用netstat -
    
                                
    • 
                                
  • 剖析如何与设计人员沟通
                                    不懂事的小屁孩
工作
                                    
    最近做图烦死了，不停的改图，改图……。烦，倒不是因为改，而是反反复复的改，人都会死。很多需求人员不知该如何与设计人员沟通，不明白如何使设计人员知道他所要的效果，结果只能是沟通变成了扯淡，改图变成了应付。 
 
那应该如何与设计人员沟通呢？ 
 
我认为设计人员与需求人员先天就存在语言障碍。对一个合格的设计人员来说，整天玩的都是点、线、面、配色，哪种构图看起来协调；哪种配色看起来合理心里跟明镜似的，
    
                                
    • 
                                
  • qq空间刷评论工具
                                    换个号韩国红果果
JavaScript
                                    
    

var a=document.getElementsByClassName('textinput');
					var b=[];
					for(var m=0;m<a.length;m++){
						if(a[m].getAttribute('placeholder')!=null)
							b.push(a[m])
					}
					var l
    
                                
    • 
                                
  • S2SH整合之session
                                    灵静志远
springAOPstrutssession
                                    
    错误信息： 
Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'cartService': Scope 'session' is not active for the current thread; consider defining a scoped
    
                                
    • 
                                
  • xmp标签
                                    a-john
标签
                                    
    今天在处理数据的显示上遇到一个问题： 
var html = '<li><div class="pl-nr"><span class="user-name">' + user
           + '</span>' + text + '</div></li>';
ulComme
    
                                
    • 
                                
  • Ajax的常用技巧（2）---实现Web页面中的级联菜单
                                    aijuans
Ajax
                                    
    在网络上显示数据，往往只显示数据中的一部分信息，如文章标题，产品名称等。如果浏览器要查看所有信息，只需点击相关链接即可。在web技术中，可以采用级联菜单完成上述操作。根据用户的选择，动态展开，并显示出对应选项子菜单的内容。 在传统的web实现方式中，一般是在页面初始化时动态获取到服务端数据库中对应的所有子菜单中的信息，放置到页面中对应的位置，然后再结合CSS层叠样式表动态控制对应子菜单的显示或者隐
    
                                
    • 
                                
  • 天-安-门，好高
                                    atongyeye
情感
                                    
        我是85后，北漂一族，之前房租1100，因为租房合同到期，再续，房租就要涨150。最近网上新闻，地铁也要涨价。算了一下，涨价之后，每次坐地铁由原来2块变成6块。仅坐地铁费用，一个月就要涨200。内心苦痛。 
 
    晚上躺在床上一个人想了很久，很久。 
   
    我生在农
    
                                
    • 
                                
  • android 动画
                                    百合不是茶
android透明度平移缩放旋转
                                    
    android的动画有两种  tween动画和Frame动画 
  
tween动画;,透明度,缩放,旋转,平移效果 
  
Animation   动画 
AlphaAnimation 渐变透明度 
RotateAnimation 画面旋转 
ScaleAnimation 渐变尺寸缩放 
TranslateAnimation 位置移动 
Animation
    
                                
    • 
                                
  • 查看本机网络信息的cmd脚本
                                    bijian1013
cmd
                                    
    @echo 您的用户名是：%USERDOMAIN%\%username%>"%userprofile%\网络参数.txt"
@echo 您的机器名是：%COMPUTERNAME%>>"%userprofile%\网络参数.txt"
@echo ___________________>>"%userprofile%\
    
                                
    • 
                                
  • plsql 清除登录过的用户
                                    征客丶
plsql
                                    
    tools---preferences----logon history---history  把你想要删除的删除 
 
 
-------------------------------------------------------------------- 
若有其他凝问或文中有错误，请及时向我指出， 
我好及时改正，同时也让我们一起进步。 
email ： binary_spac
    
                                
    • 
                                
  • 【Pig一】Pig入门
                                    bit1129
pig
                                    
    Pig安装 
1.下载pig 
  
wget http://mirror.bit.edu.cn/apache/pig/pig-0.14.0/pig-0.14.0.tar.gz 
  
2. 解压配置环境变量 
  
   如果Pig使用Map/Reduce模式，那么需要在环境变量中，配置HADOOP_HOME环境变量 
  
expor
    
                                
    • 
                                
  • Java 线程同步几种方式
                                    BlueSkator
volatilesynchronizedThredLocalReenTranLockConcurrent
                                    
    为何要使用同步？       java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），        将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，        从而保证了该变量的唯一性和准确性。    1.同步方法&
    
                                
    • 
                                
  • StringUtils判断字符串是否为空的方法（转帖）
                                    BreakingBad
nullStringUtils“”
                                    
    转帖地址：http://www.cnblogs.com/shangxiaofei/p/4313111.html 
  
public static boolean isEmpty(String str)      
　　判断某字符串是否为空，为空的标准是 str== 
null  
或 str.length()== 
0    
    
                                
    • 
                                
  • 编程之美-分层遍历二叉树
                                    bylijinnan
java数据结构算法编程之美
                                    
    

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LevelTraverseBinaryTree {

    /**
     * 编程之美 分层遍历二叉树
     * 之前已经用队列实现过二叉树的层次遍历，但这次要求输出换行，因此要
    
                                
    • 
                                
  • jquery取值和ajax提交复习记录
                                    chengxuyuancsdn
jquery取值ajax提交
                                    
    
// 取值
	// alert($("input[name='username']").val());
	// alert($("input[name='password']").val());
	// alert($("input[name='sex']:checked").val());
	// alert($("
    
                                
    • 
                                
  • 推荐国产工作流引擎嵌入式公式语法解析器-IK Expression
                                    comsci
java应用服务器工作Excel嵌入式
                                    
    这个开源软件包是国内的一位高手自行研制开发的，正如他所说的一样，我觉得它可以使一个工作流引擎上一个台阶。。。。。。欢迎大家使用，并提出意见和建议。。。 
----------转帖--------------------------------------------------- 
 IK Expression是一个开源的（OpenSource），可扩展的（Extensible），基于java语言
    
                                
    • 
                                
  • 关于系统中使用多个PropertyPlaceholderConfigurer的配置及PropertyOverrideConfigurer
                                    daizj
spring
                                    
    1、PropertyPlaceholderConfigurer 
Spring中PropertyPlaceholderConfigurer这个类，它是用来解析Java Properties属性文件值，并提供在spring配置期间替换使用属性值。接下来让我们逐渐的深入其配置。 
 
基本的使用方法是：(1) 
 
<bean id="propertyConfigurerForWZ&q
    
                                
    • 
                                
  • 二叉树:二叉搜索树
                                    dieslrae
二叉树
                                    
        所谓二叉树,就是一个节点最多只能有两个子节点,而二叉搜索树就是一个经典并简单的二叉树.规则是一个节点的左子节点一定比自己小,右子节点一定大于等于自己(当然也可以反过来).在树基本平衡的时候插入,搜索和删除速度都很快,时间复杂度为O(logN).但是,如果插入的是有序的数据,那效率就会变成O(N),在这个时候,树其实变成了一个链表. 
 
tree代码: 
 

    
                                
    • 
                                
  • C语言字符串函数大全
                                    dcj3sjt126com
cfunction
                                    
    C语言字符串函数大全 
  
  
函数名: stpcpy 
功 能: 拷贝一个字符串到另一个 
用 法: char *stpcpy(char *destin, char *source); 
程序例: 
  
#include <stdio.h> 
#include <string.h> 
  
int main
    
                                
    • 
                                
  • 友盟统计页面技巧
                                    dcj3sjt126com
技巧
                                    
    在基类调用就可以了, 基类ViewController示例代码 
-(void)viewWillAppear:(BOOL)animated
{
    [super viewWillAppear:animated];
    [MobClick beginLogPageView:[NSString stringWithFormat:@"%@",self.class]];

    
                                
    • 
                                
  • window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法
                                    flyvszhb
javajdk
                                    
    window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法 
 
本机已经安装了jdk1.7，而比较早期的项目需要依赖jdk1.6，于是同时在本机安装了jdk1.6和jdk1.7. 
 安装jdk1.6前，执行java -version得到 
C:\Users\liuxiang2>java -version 
java version "1.7.0_21&quo
    
                                
    • 
                                
  • Java在创建子类对象的同时会不会创建父类对象
                                    happyqing
java创建子类对象父类对象
                                    
      
1.在thingking in java 的第四版第六章中明确的说了，子类对象中封装了父类对象， 
  
2."When you create an object of the derived class, it contains within it a subobject of the base class. This subobject is the sam
    
                                
    • 
                                
  • 跟我学spring3 目录贴及电子书下载
                                    jinnianshilongnian
spring
                                    
      
  一、《跟我学spring3》电子书下载地址： 
《跟我学spring3》  （1-7 和 8-13） http://jinnianshilongnian.iteye.com/blog/pdf   
  
跟我学spring3系列 word原版 下载 
  
  二、
源代码下载  
最新依
    
                                
    • 
                                
  • 第12章 Ajax（上）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • BI and EIM 4.0 at a glance
                                    blueoxygen
BO
                                    
    http://www.sap.com/corporate-en/press.epx?PressID=14787 
  
有机会研究下EIM家族的两个新产品~~~~ 
  
New features of the 4.0 releases of BI and EIM solutions include:  
 
  Real-time in-memory computing – 
    
                                
    • 
                                
  • Java线程中yield与join方法的区别
                                    tomcat_oracle
java
                                    
    长期以来，多线程问题颇为受到面试官的青睐。虽然我个人认为我们当中很少有人能真正获得机会开发复杂的多线程应用(在过去的七年中，我得到了一个机会)，但是理解多线程对增加你的信心很有用。之前，我讨论了一个wait()和sleep()方法区别的问题，这一次，我将会讨论join()和yield()方法的区别。坦白的说，实际上我并没有用过其中任何一个方法，所以，如果你感觉有不恰当的地方，请提出讨论。 
&nb
    
                                
    • 
                                
  • android Manifest.xml选项
                                    阿尔萨斯
Manifest
                                    
    结构 
继承关系 
public final class Manifest extends Objectjava.lang.Objectandroid.Manifest 
内部类 
 
 
 class Manifest.permission权限 
 class Manifest.permission_group权限组 
 构造函数 
 
public Manifest () 详细  androi
    
                                
    • 
                                
  • Oracle实现类split函数的方
                                    zhaoshijie
oracle
                                    
    关键字：Oracle实现类split函数的方 
项目里需要保存结构数据，批量传到后他进行保存，为了减小数据量，子集拼装的格式，使用存储过程进行保存。保存的过程中需要对数据解析。但是oracle没有Java中split类似的函数。从网上找了一个，也补全了一下。 
 
CREATE OR REPLACE TYPE t_split_100 IS TABLE OF VARCHAR2(100); 
 
cr
    
                                
    •