N_bug
N_bug

Dubbo SPI机制详解

什么是SPI？

扩展点 Dubbo作用灵活的框架，并不会强制所有用户都一定使用Dubbo提供的某些架构。例如注册中心（Registry），Dubbo提供了zk和redis，但是如果我们更倾向于其他的注册中心的话，我们可以替换掉Dubbo提供的注册中心。针对这种可被替换的技术实现点我们称之为扩展点，类似的扩展点有很多，例如Protocol，Filter，Loadbalance等等。

Wrapper Dubbo在加载某个接口的扩展类时候，如果某个实现中有一个拷贝类构造函数，那么该接口实现就是该接口的包装类，此时Dubbo会在真正的实现类上层包装上盖Wrapper。即这个时候从ExtensionLoader中返回的实际扩展类是被Wrapper包装的接口实现类。

Adaptive 这个自适应的扩展点比较难理解，所以这里直接以一个例子来讲解：在RegistryProtocol中有一个属性为Cluster，其中Protocol和Cluster都是Dubbo提供的扩展点，所以这时候当我们真正在操作中使用cluster的时候究竟使用的哪一个cluster的实现类呢？是FailbackCluster还是FailoverCluster？Dubbo在加载一个扩展点的时候如果发现其成员变量也是一个扩展点并且有相关的set方法，就会在这时候将该扩展点设置为一个自适应的扩展点，自适应扩展点（Adaptive）会在真正使用的时候从URL中获取相关参数，来调用真正的扩展点实现类。具体的实现会在下面的源码中详细解释。对于Adaptive的理解其实个人推荐的是Dubbo开发者指南，指南中有对于Adaptive的明确介绍

Activate 官网的叫法是自激活，其实这个更合适的叫法我认为是条件激活，我们还记得上一篇中有提到Filter的内容，其中Filter链的获取就是通过@Activate注解来确定的，所以Activate的作用主要是：提供一种选择性激活的条件，可以是我们通过相关的配置来确定激活哪些功能

1、java spi不能单独获得某个指定的实现类

比如，无法再配置文件里写入两个实现类，无法定位你要的某一个，只能是单个实现类

2、java spi 没有IOC和 AOP机制

比如，java类里依赖一个类的实例，是无法用spi机制加载，只能自己去加载，无法自动注入

但是Dubbo可以实现，具体这方面解析参考视频 https://www.bilibili.com/video/av61936651?p=5

3、JDK的spi要用for循环,然后if判断才能获取到指定的spi对象,dubbo用指定的key就可以获取

4、JDK 标准的 SPI 会一次性实例化扩展点所有实现，如果有扩展实现初始化很耗时，但如果没用上也加载，会很浪费资源

5、JDK的spi不支持默认值，Dubbo默认支持javassit

 

换句话说SPI机制，Dubbo改进了JDK标准的SPI机制

  • 如果扩展点加载失败，连扩展点的名称都拿不到了。比如：JDK标准的ScriptEngine，通过getName();获取脚本类型的名称，但如果RubyScriptEngine因为所依赖的jruby.jar不存在，导致RubyScriptEngine类加载失败，这个失败原因被吃掉了，和ruby对应不起来，当用户执行ruby脚本时，会报不支持ruby，而不是真正失败的原因。

  • 增加了对扩展点IoC和AOP的支持，一个扩展点可以直接setter注入其它扩展点。

ExtensionLoader

 //在Dubbo源码中大面积使用这种写法，都是获得某个接口的适配类，在真正执行的时候才决定最终的作用类
    private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
    
    //因为每一个扩展类加载器只能加载特定的SPI扩展的实现，所以要获得某个扩展的实现的话首先要找到他对应的扩展类加载器(ExtensionLoader)
    //一个扩展接口的所有实现都是被同一个扩展类加载器来加载的
    @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!");
        }
        //获得某个扩展类加载器的时候该接口必须被@SPI修饰才可以
        if(!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type(" + type + 
                    ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
        }
        // 先从静态缓存中获取对应的ExtensionLoader实例，每个接口对应一个ExtensionLoader并且把映射关系都存储在缓存之中
        ExtensionLoader loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        if (loader == null) {
            // 为Extension类型创建ExtensionLoader实例，并放入静态缓存
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
            loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }
    
    public T getAdaptiveExtension() {
        Object instance = cachedAdaptiveInstance.get();
        if (instance == null) {
            if(createAdaptiveInstanceError == null) {
                //采用单例模式的双重判断，这种模式感觉使用的范围都比较广泛
                //cachedAdaptiveInstance作为一个Holder（只有简单的get和set方法），也是一个锁对象
                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;
    }
    
    // 创建一个接口的适配类
    private T createAdaptiveExtension() {
        try {
            //获取AdaptiveExtensionClass并完成注入
            //基本分两步：1.获取适配器类 2.在适配器里面注入其他的扩展点
            return injectExtension((T) getAdaptiveExtensionClass().newInstance()); 
        } catch (Exception e) {
            throw new IllegalStateException("Can not create adaptive extenstion " + type + ", cause: " + e.getMessage(), e);
        }
    }
    
    //获得适配类有两种途径，第一就是某个实现类上被@Adaptive注解，第二就是没有实现类被注解，因此Dubbo会自动生成一个某个接口的适配类
    private Class getAdaptiveExtensionClass() {
         //如果能找到被@Adaptive注解实现类
        getExtensionClasses();
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        //找不到的话就自行创建一个适配类
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }
    
     //加载当前扩展所有实现，看是否有实现类上被标注为@Adaptive
    private Map> getExtensionClasses() {
        //多次判断是为了防止同一个扩展点被多次加载
        Map> classes = cachedClasses.get();
        if (classes == null) {
            synchronized (cachedClasses) {
                classes = cachedClasses.get();
                if (classes == null) {
                //loadExtensionClasses会加载所有的配置文件，将配置文件中对应的的类加载到当前的缓存中
                    //load完之后该classes已经保留了所有的扩展类映射关系
                    classes = loadExtensionClasses();
                    cachedClasses.set(classes);
                }
            }
        }
        return classes;
    }  
    private Map> loadExtensionClasses() {
        //所有的扩展点接口都必须被SPI注释标注
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if(defaultAnnotation != null) {
            String value = defaultAnnotation.value();
            if(value != null && (value = value.trim()).length() > 0) {
                //一个@SPI注解的值只能有一个
                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));
                }
                //cachedDefaultName表示该扩展点对应的默认适配类的key
                //逻辑运行到这里就意味着该扩展点有定义的适配类，不需要Dubbo框架自己生成适配类
                if(names.length == 1) cachedDefaultName = names[0];
            }
        }
        
        Map> extensionClasses = new HashMap>();
        //加载对应目录下的配置文件，三个目录分别为：META-INF/services/，META-INF/dubbo，META-INF/dubbo/internal
        loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
        loadFile(extensionClasses, DUBBO_DIRECTORY);
        loadFile(extensionClasses, SERVICES_DIRECTORY);
        return extensionClasses;
    }
    
    //加载相关路径下的类文件
    private void loadFile(Map> extensionClasses, String dir) {
        String fileName = dir + type.getName();
        try {
            Enumeration urls;
            //加载这些问价你的classloader要和加载当前类的classloader一致,这个类似与Java默认的类加载器和类的加载关系
            ClassLoader classLoader = findClassLoader();
            if (classLoader != null) {
               //该步骤就加载所有的classpath下面的同名文件（包含你的项目本地classpath和依赖jar包）
                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) {
                                            //SPI扩展文件中的key
                                            name = line.substring(0, i).trim();
                     //SPI扩展文件中配置的value  ExtensionLoader是根据key和value同时加载的                  							   
                                            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.");
                                            }
                                            //如果配置的类是被@Adaptive注解的话
         if (clazz.isAnnotationPresent(Adaptive.class)) {
                             if(cachedAdaptiveClass == null) {
                             //将缓存的AdaptiveClass设置成此类
                             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);
                                                            }
                                                        }
                                                    }
                                                    //将配置的key名字根据逗号来区分
                     String[] names = NAME_SEPARATOR.split(name);
                       if (names != null && names.length > 0) {
                           Activate activate = clazz.getAnnotation(Activate.class);
                                 if (activate != null) {
                        //自激活的实现类只会将第一个name进行存储，原因到现在还有点不清楚
                                  cachedActivates.put(names[0], activate);
                                                        }
                  for (String n : names) {
    //假如说配置了name1,name2=com.alibaba.DemoInterface,这时候在cachedNames中只会存储一个name1
                          if (! cachedNames.containsKey(clazz)) {
                                    cachedNames.put(clazz, n);
                              }
                                 Class c = extensionClasses.get(n);
                                 if (c == null) {
                                          extensionClasses.put(n, clazz);
                    //防止同一个扩展类实现被两个key共同使用
                                    } 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);
        }
    }
    
    //通过反射自动调用instance的set方法把自身的属性注入进去，解决的扩展类依赖问题，也就是说解决扩展类依赖扩展类的问题
    private T injectExtension(T instance) {
        try {
            if (objectFactory != null) {
                for (Method method : instance.getClass().getMethods()) {
                    if (method.getName().startsWith("set")
                            && method.getParameterTypes().length == 1
                            && Modifier.isPublic(method.getModifiers())) { //如果该扩展点实例有Set开头的公共方法
                        Class pt = method.getParameterTypes()[0];//得到set方法的参数类型
                        try {
                            //得到属性名称，比如setName方法就得到name属性名称
                            String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
                            Object object = objectFactory.getExtension(pt, property);//从获得属性值
                            if (object != null) {
                                method.invoke(instance, object);// 如果不为空，说明set方法的参数是扩展点类型，那么进行注入，意思也就是说扩展点里面还有依赖其他扩展点
                            }
                        } catch (Exception e) {
                            logger.error("fail to inject via method " + method.getName()
                                    + " of interface " + type.getName() + ": " + e.getMessage(), e);
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return instance;
    }
    //通过反射自动调用instance的set方法把自身的属性注入进去，解决的扩展类依赖问题，也就是说解决扩展类依赖扩展类的问题
    private T injectExtension(T instance) {
        try {
            if (objectFactory != null) {
                for (Method method : instance.getClass().getMethods()) {
                    if (method.getName().startsWith("set")
                            && method.getParameterTypes().length == 1
                            && Modifier.isPublic(method.getModifiers())) { //如果该扩展点实例有Set开头的公共方法
                        Class pt = method.getParameterTypes()[0];//得到set方法的参数类型
                        try {
                            //得到属性名称，比如setName方法就得到name属性名称
                            String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
                            Object object = objectFactory.getExtension(pt, property);//从获得属性值
                            if (object != null) {
                                method.invoke(instance, object);// 如果不为空，说明set方法的参数是扩展点类型，那么进行注入，意思也就是说扩展点里面还有依赖其他扩展点
                            }
                        } catch (Exception e) {
                            logger.error("fail to inject via method " + method.getName()
                                    + " of interface " + type.getName() + ": " + e.getMessage(), e);
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return instance;
    }

 

基本上讲到之类，一个适配类已经可以被加载出来了，但是由于上面的逻辑比较深，下面给出简单文字逻辑：

1.为了获得一个扩展点的适配类，首先会看缓存中有没有已经加载过的适配类，如果有的话就直接返回，没有的话就进入第2步。

2.加载所有的配置文件，将所有的配置类都load进内存并且在ExtensionLoader内部做好缓存，如果配置的文件中有适配类就缓存起来，如果没有适配类就自行通过代码自行创建适配类并且缓存起来（代码之后给出样例）。

3.在加载配置文件的时候，会依次将包装类，自激活的类都进行缓存。

4.将获取完适配类时候，如果适配类的set方法对应的属性也是扩展点话，会依次注入对应的属性的适配类（循环进行）。

 

Dubbo自己生成的适配类代码是怎样的(以Protocol为例)：

Protocol refprotocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();

使用协议Protocol根据上述的url和服务接口来引用服务，创建出一个Invoker对象

默认实现的DubboProtocol也会经过ProtocolFilterWrapper、ProtocolListenerWrapper、RegistryProtocol的包装

首先看下RegistryProtocol.refer()方法，它干了哪些事呢？

  • 将客户端的信息注册到注册中心上

  • 创建一个RegistryDirectory，从注册中心中订阅自己引用的服务，将订阅到的url在RegistryDirectory内部转换成Invoker。

  • RegistryDirectory是Directory的实现，Directory代表多个Invoker，可以把它看成List类型的Invoker，但与List不同的是，它的值可能是动态变化的，比如注册中心推送变更RegistryDirectory内部含有两者重要属性：

  • 注册中心服务Registry

  • Protocol 它会利用注册中心服务Registry来获取最新的服务器端注册的url地址，然后再利用协议Protocol将这些url地址转换成一个具有远程通信功能的Invoker对象，如DubboInvoker

  • 在Directory的基础上使用Cluster将上述多个Invoker对象聚合成一个集群版的Invoker对象

     

本质上的做法就是通过方法的参数获得URL信息，从URL中获得对应的value对应值，然后从ExtensionLoader的缓存中找到value对应的具体实现类，然后用该实现类进行工作。可以看到上面的核心就是getExtension方法了，下面来看一下该方法的实现：

  public T getExtension(String name) {
        if (name == null || name.length() == 0)
            throw new IllegalArgumentException("Extension name == null");
        //DefaultExtension就是自适应的扩展类
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        //先从缓存中去取
        Holder holder = cachedInstances.get(name);
        if (holder == null) {
            //如果缓存中没有的话在创建一个然后放进去，但是此时并没有实际内容，只有一个空的容器Holder
            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;
    }   
    private T createExtension(String name) {
        //获取name类型对应的扩展类型，从cachedClasses根据key获取对应的class，cachedClasses已经在load操作的时候初始化过了。
        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方法的作用就是通过set方法注入其他的属性扩展点，上面已经讲过
            injectExtension(instance);
            Set> wrapperClasses = cachedWrapperClasses;
            if (wrapperClasses != null && wrapperClasses.size() > 0) {
                for (Class wrapperClass : wrapperClasses) {
                    //循环遍历所有wrapper实现，实例化wrapper并进行扩展点注入
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);
        }
    } 
  
getExtension的步骤就是根据之前load操作生成的class缓存，找到对应的Class信息，然后根据Class生成具体的实例，生成之后通过反射注入其他的属性扩展点，将包装类进行层层包装，最终返回包装过的类。（包装逻辑可以参考Protocol的包装实例）
 
  
2、消费者构造Invoker
 
  
消费者动态的构造Invoker是通过监听器，在注册中心服务变化后通过Directory调用DubboProtocol的refer方法来构造Invoker
 
  
案例介绍
 
  
先看一个简单的客户端引用服务的例子，HelloService，dubbo配置如下：
 
  




 
  
     
   
  •  
    使用Zookeeper作为注册中心
     
    •  
   
  •  
    引用远程的HelloService接口服务
     
    •  
  
 
  
根据之前的介绍，在Spring启动的时候，根据``配置会创建一个ReferenceBean，该bean又实现了Spring的FactoryBean接口，所以我们如下方式使用时：
 
  
@Autowired
private HelloService helloService;
 
  
使用的不是ReferenceBean对象，而是ReferenceBean的getObject()方法返回的对象，该对象通过代理实现了HelloService接口，所以要看服务引用的整个过程就需要从ReferenceBean.getObject()方法开始入手。
 
  
将ReferenceConfig.init()中的内容拆成具体的步骤，如下：
 
  
第一步：收集配置参数
 
  
methods=hello,
timestamp=1443695417847,
dubbo=2.5.3
application=consumer-of-helloService
side=consumer
pid=7748
interface=com.demo.dubbo.service.HelloService
 
  
第二步：从注册中心获取服务地址，返回Invoker对象
 
  
如果是单个注册中心，代码如下：
 
  
Protocol refprotocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();

invoker = refprotocol.refer(interfaceClass, url);
 
  
第三步：使用ProxyFactory创建出Invoker的代理对象
 
  
ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();

proxyFactory.getProxy(invoker);
 
  
下面就详细说明下上述提到的几个概念：Protocol、Invoker、ProxyFactory
 
  
Invoker
 
  
Invoker是一个可执行对象，有三种类型的Invoker：
 
  
     
   
  1.  
    本地执行的Invoker（服务端使用）
     
    2.  
   
  2.  
    远程通信执行的Invoker（客户端使用）
     
    3.  
   
  3.  
    多个类型2的Invoker聚合成的集群版Invoker（客户端使用）
     
    4.  
  
 
  
ProxyFactory
 
  
服务引用的第三步就是：
 
  
proxyFactory.getProxy(invoker);
 
  
对于Server端，ProxyFactory主要负责将服务如HelloServiceImpl统一进行包装成一个Invoker，这些Invoker通过反射来执行具体的HelloServiceImpl对象的方法
 
  
对于client端，则是将上述创建的集群版Invoker（Cluster）创建出代理对象
 
  
代码如下：
 
  
public class JavassistProxyFactory extends AbstractProxyFactory {

    @SuppressWarnings("unchecked")
    public  T getProxy(Invoker invoker, Class[] interfaces) {
        return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
    }
 
  
可以看到是利用jdk自带的Proxy来动态代理目标对象Invoker，所以我们调用创建出来的代理对象如HelloService的方法时，会执行InvokerInvocationHandler中的逻辑：
 
  
public class InvokerInvocationHandler implements InvocationHandler {
    private final Invoker invoker;
    public InvokerInvocationHandler(Invoker handler){
        this.invoker = handler;
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        Class[] parameterTypes = method.getParameterTypes();
        if (method.getDeclaringClass() == Object.class) {
            return method.invoke(invoker, args);
        }
        if ("toString".equals(methodName) && parameterTypes.length == 0) {
            return invoker.toString();
        }
        if ("hashCode".equals(methodName) && parameterTypes.length == 0) {
            return invoker.hashCode();
        }
        if ("equals".equals(methodName) && parameterTypes.length == 1) {
            return invoker.equals(args[0]);
        }
        //AbstractClusterInvoker.invoke()
        return invoker.invoke(new RpcInvocation(method, args)).recreate();
    }

}
 
  
3、总结Dubbo
 
  
消费端的初始化过程
 
  
1、把服务引用的信息封装成URL并注册到zk注册中心; 2、监听注册中心的服务的上下线; 3、连接服务提供端，创建NettyClient对象; 4、将这些信息包装成DubboInvoker消费端的调用链，创建消费端Invoker实例的服务代理并返回;
 
  
消费端的服务引用过程
 
  
1、经过负载均衡策略，调用提供者; 2、选择其中一个服务的URL与提供者netty建立连接，使用ProxyFactory 创建远程通信，或者本地通信的，Invoker发到netty服务端; 3、服务器端接收到该Invoker信息后，找到对应的本地Invoker，处理Invocation请求; 4、获取异步，或同步处理结果;
 
  
     
   
  •  
    异步 不需要返回值：直接调用ExchangeClient.send()方法;
     
    •  
   
  •  
    同步 需要返回值：使用ExchangeClient.request()方法，返回一个ResponseFuture，一直阻塞到服务端返回响应结果;
     
    •  
  
 
  
服务暴露
 
  
1、需要被暴露的服务的接口类首先会通过proxyFactory代理工厂获得代理的对象invoker，而暴露之后的服务被调用，也将都会通过这个invoker来调用相关的类。
 
  
在dubbo中默认采用javassistProxyFactory来获取由javassist代理的invoker。
 
  
2、根据所要代理的类名产生相应的wrapper来对所要代理的类进行包装。
 
  
在getWrapper中，会先根据所要包装的类是否已经被包装过。如果已经包装过，则会直接在来保存已经生成的包装类的map里去寻找，否则会直接生成新的包装类。
 
  
makeWrapper()根据传递的类获取新的包装类。
 
  
在makeWrapper()方法中，通过javassist根据所需要包装的类动态生成了包装类。由于Invoker的作用，大概在这里动态实现的最重要的方法应该是invokeMothed()方法
 
  
3、在这段动态生成了invokeMethod的方法体。将会根据方法名调用包装类中真正所需要被调用的类的方法。
 
  
4、在得到了包装类之后，在javassistProxyFactory的getInvoker()方法最后会生成新的AbstractProxyInvoker()，重写了doInvoke()方法，会直接调用刚刚生成的包装类的invokeMethod()方法
 
  
5、在得到invoker之后，会根据获得的invoker开始服务的暴露，通过protocol的export()方法。配置有filter或者listener的情况下，会在这里产生关于具体服务暴露操作的过滤与监听。值得一提的是，如果采用的是registry协议，那么并不会经过ProtocolListenerWrapper的监听，而是直接进入export()方法开始服务的暴露。
 
  
6、会通过doLocalExport()方法开始本地服务的暴露。
 
  
7、本地暴露的过程中，首先会根据传入的invoker获取其提供方的url来获得key，根据获得的key来尝试获得ExporterChangeableWrapper，如果没有，则会先通过原本采用的protocol协议进行服务暴露，默认dubbo。
 
  
在dubboProtocol的export()方法中，会根据url生成server key，根据invoker和key生成新的dubboExporter并根据key和exporter存放在map里。但是最关键的是，将在这里调用openServer()方法开启与注册中心的连接。
 
  
在openServer中，如果已经建立过与服务器的连接，那么会直接在这里返回，否则会通过netty新建与注册中心的网络连接
 
  
8、在这里会通过生成ExchangeServer开始监听相应的channel并绑定对应的requestHandler进行相关的回调处理。
 
  
可见，在dubboProtocol的服务暴露过程中，完成了对网络监听的配置与开启。
 
  
在完成dubboProtocol的export()方法之后，回到RegistryProtocol的doLocalExport()方法，根据dubboProtocol暴露生成 的dubboExporter()以及invoker生成新的ExportChangeableWrapper返回。
 
  
之后，通过getRegistry获得注册中心的实例。会根据配置的registryFactory生成对应的registry实例
 
  
9、以zookeeper为例，在其构造方法当中会根据url新生成一个zkClient得到与zookeeper注册中心的连接。
 
  
在得到了注册中心的实例之后，通过register()方法正式注册服务到注册中心当中去。
 
  
在调用注册方法的过程中，被注册的url将会在zookeeperRegistry的父类的父类AbstractRegistry中保存被注册的url。
 
  
创建zk【持久型节点】、并监听如下节点，对服务提供者的configurators节点配置监听器OverrideListener /dubbo ----/com.alibaba.dubbo.demo.DemoService （providers） --------/configurators
 
  
如果URL有变化，则会触发监听器重新暴露服务
 
  
然后在zookeeperRegistry的父类当中调用zookeeperRegistry的doRegistry()方法。也就说在zookeeperRegistry的doRegistry方法当中，会将要暴露的服务信息提交给注册中心
 
  
本地暴露
 
  
假如服务没有配置了scope属性，或者配置了但是值不是”remote“，就会执行本地暴露。自同一个jvm内部，调用本jvm中存在的服务，就可以直接调用，而不需要走网络，减少响应时间
 
  
Dubbo SPI机制详解_第1张图片
 
  
暴露的时候会区别：remote的话就是远程，不是就是本地暴露
 
  
url的协议已经从dubbo变成了injvm 第二步：将ref【interfaceClass的实现类】包装成一个Wrapper，并返回一个Invoker JavassistProxyFactory#getInvoker
 
  
Dubbo SPI机制详解_第2张图片
 
  
Dubbo SPI机制详解_第3张图片
 
  
@Adaptive注解
 
  
打在类上和方法上，他们是有区别的，Adaptive设计目的是为了识别固定已知类和扩展未知类
 
  
1、注解在类上：代表人工实现，实现一个装饰类（装饰模式），主要用于固定已知类
 
  
目前系统只有两个，AdaptiveCompiler（因为整个框架只支持Javassit和JdkComiler）、AdaptiveExtensionFactory（因为框架只支持spi和spring）
 
  
2、注解在方法上：代表自动生成和编译一个动态的Adaptive类，主要用于SPI，因为SPI的类不固定、未知的扩展类
 
  
Dubbo SPI机制详解_第4张图片
 
  
由上图知道，本地暴露的url是以injvm开头的，下面来看下远程暴露,其实这个也是回答本地暴露和远程暴露区别的一个回答点
 
  
 
 
  
6、本地暴露和远程暴露
 
  
为什么会有本地暴露和远程暴露呢?不从场景考虑讨论技术的没有意义是.在dubbo中我们一个服务可能既是Provider,又是Consumer,因此就存在他自己调用自己服务的情况,如果再通过网络去访问,那自然是舍近求远,因此他是有本地暴露服务的这个设计.从这里我们就知道这个两者的区别
 
  
     
   
  •  
    本地暴露是暴露在JVM中,不需要网络通信。
     
    •  
   
  •  
    远程暴露是将IP，端口等信息暴露给远程客户端,调用时需要网络通信。
     
    •  
  
 
  
操作java字节码的工具有两个比较流行，一个是ASM，一个是Javassit 。
 
  
     
   
  •  
    ASM ：直接操作字节码指令，执行效率高，要是使用者掌握Java类字节码文件格式及指令，对使用者的要求比较高。
     
    •  
   
  •  
    Javassit : 提供了更高级的API，执行效率相对较差，但无需掌握字节码指令的知识，对使用者要求较低。
     
    •  
  
 
  
服务提供者能实现失效踢出是什么原理
 
  
服务失效踢出基于 zookeeper 的临时节点原理
 
  
服务调用超时问题怎么解决
 
  
dubbo在调用服务不成功时，默认是会重试两次的。这样在服务端的处理时间超过了设定的超时时间时，就会有 重复请求，比如在发邮件时，可能就会发出多份重复邮件，执行注册请求时，就会插入多条重复的注册数据，那么怎么解决超时问题呢？如下
 
  
对于核心的服务中心，去除dubbo超时重试机制，并重新评估设置超时时间。业务处理代码必须放在服务端，客户端只做参数验证和服务调用，不涉及业务流程处理 全局配置实例
 
  
当然Dubbo的重试机制其实是非常好的QOS保证，它的路由机制，是会帮你把超时的请求路由到其他机器上，而不是本机尝试，所以 dubbo的重试机器也能一定程度的保证服务的质量。但是请一定要综合线上的访问情况，给出综合的评估
 
  
Dubbo-SPI和AOP
 
  
开篇说下AOP，正常来说为了不暴露最底层的接口服务，我们可以使用静态代理进行代理，问题是，总不能新增一个接口我就要去新增代理Proxy的方法，所以用动态代理（动态代理是程序运行时由JVM通过反射等机制动态生成，所以不存在代理类的字节码文件）
 
  
再来说一说Dubbo-SPI-AOP
 
  
instance = injectExtension((T) WrapperClass.getConstructor(type).newInstance(instance));
 //ExtensionLoader在加载扩展点时，如果加载到扩展点由拷贝构造函数，则判定为扩展点Wrapper类
 
  
//通过 Wrapper 类可以把所有扩展点公共逻辑移至 Wrapper 中。新加的 Wrapper 在所有的扩展点上添加了逻辑，有些类似 AOP，即 Wrapper 代理了扩展点
 
  
dubbo里面的spi增加的aop，其实就是装饰者模式，但是还有弊端，这时候引入了Adaptive（扩展点自适应）。
 
  
Dubbo-SPI和IOC
 
  
 //因为每一个扩展类加载器只能加载特定的SPI扩展的实现，所以要获得某个扩展的实现的话首先要找到他对应的扩展类加载器(ExtensionLoader)
    //一个扩展接口的所有实现都是被同一个扩展类加载器来加载的
    @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!");
        }
        //获得某个扩展类加载器的时候该接口必须被@SPI修饰才可以,否则异常
        if(!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type(" + type + 
                    ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
        }
        // 先从静态缓存中获取对应的ExtensionLoader实例，每个接口对应一个ExtensionLoader并且把映射关系都存储在缓存之中
        ExtensionLoader loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        if (loader == null) {
            // 为Extension类型创建ExtensionLoader实例，并放入静态缓存
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
            loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Dubbo)

        

            

                
    
                    
  • 《微服务王国的守护者：Spring Cloud Dubbo的奇幻冒险》
                        Geek_H
Java面试热点微服务springclouddubbojava云原生缓存hystrix
                        
    5.经典问题与解决方案5.3服务追踪与链路监控在微服务架构的广袤宇宙中，服务间的调用关系错综复杂，如同一张庞大的星系网络。当一个请求穿越这个星系，经过多个服务节点时，如何追踪它的路径，如何监控整个链路的健康状况，成为了确保系统稳定运行的关键。服务追踪的必要性想象一下，你是一位星际探险家，你的任务是追踪一艘飞船穿越星系的轨迹。如果飞船在某个星系节点出现了问题，你需要迅速定位问题发生的位置，并了解它之
    
                    
    • 
                    
  • spring cloud-之入门技术选型的抉择
                        weixin_30699831
java大数据数据库
                        
    一、个人理解之技术选型：首先在当前的大环境下，微服务已经是大趋势所在，目前微服务有两个解决方案，dubbo和springcloud，下面将对比一下两个解决方案的优缺点，然后在说一下为何我最终会选择springcloud。但是我们不必在这个方便过于纠结，这两个方案在当下都有很多的公司在采用，所以无论学习哪一个都是可以保证能够找到工作的，所以在选择的时候选择自己拿手的喜欢的就可以了，当然如果有心仪的公
    
                    
    • 
                    
  • 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中设置的权重设置轮询比率。存在的问题：响应请求慢或者卡住的机
    
                    
    • 
                                
  • scala的option和some
                                    矮蛋蛋
编程scala
                                    
    原文地址： 
http://blog.sina.com.cn/s/blog_68af3f090100qkt8.html 
对于学习 Scala 的 Java™ 开发人员来说，对象是一个比较自然、简单的入口点。在 本系列 前几期文章中，我介绍了 Scala 中一些面向对象的编程方法，这些方法实际上与 Java 编程的区别不是很大。我还向您展示了 Scala 如何重新应用传统的面向对象概念，找到其缺点
    
                                
    • 
                                
  • NullPointerException
                                    Cb123456
androidBaseAdapter
                                    
      
  java.lang.NullPointerException: Attempt to invoke virtual method 'int android.view.View.getImportantForAccessibility()' on a null object reference 
  
  出现以上异常.然后就在baidu上
    
                                
    • 
                                
  • PHP使用文件和目录
                                    天子之骄
php文件和目录读取和写入php验证文件php锁定文件
                                    
    PHP使用文件和目录 
1.使用include()包含文件 
(1)：使用include()从一个被包含文档返回一个值 
(2)：在控制结构中使用include() 
  
include_once()函数需要一个包含文件的路径，此外，第一次调用它的情况和include()一样，如果在脚本执行中再次对同一个文件调用，那么这个文件不会再次包含。 
  
在php.ini文件中设置
    
                                
    • 
                                
  • SQL SELECT DISTINCT 语句
                                    何必如此
sql
                                    
    SELECT DISTINCT 语句用于返回唯一不同的值。 
 
SQL SELECT DISTINCT 语句 
在表中，一个列可能会包含多个重复值，有时您也许希望仅仅列出不同（distinct）的值。 
 
DISTINCT 关键词用于返回唯一不同的值。 
 
SQL SELECT DISTINCT 语法 
 
SELECT DISTINCT column_name,column_name 
F
    
                                
    • 
                                
  • java冒泡排序
                                    3213213333332132
java冒泡排序
                                    
    package com.algorithm;

/**
 * @Description 冒泡
 * @author FuJianyong
 * 2015-1-22上午09:58:39
 */
public class MaoPao {
	public static void main(String[] args) {
		int[] mao = {17,50,26,18,9,10
    
                                
    • 
                                
  • struts2.18 +json,struts2-json-plugin-2.1.8.1.jar配置及问题！
                                    7454103
DAOspringAjaxjsonqq
                                    
    struts2.18  出来有段时间了！ （貌似是 稳定版） 
  
闲时研究下下！  貌似 sruts2 搭配 json 做 ajax 很吃香！ 
  
实践了下下！ 不当之处请绕过！ 呵呵 
  
网上一大堆 struts2+json  不过大多的json 插件 都是 jsonplugin.34.jar  
  
strut
    
                                
    • 
                                
  • struts2 数据标签说明
                                    darkranger
jspbeanstrutsservletScheme
                                    
    数据标签主要用于提供各种数据访问相关的功能，包括显示一个Action里的属性，以及生成国际化输出等功能 
数据标签主要包括： 
action ：该标签用于在JSP页面中直接调用一个Action，通过指定executeResult参数，还可将该Action的处理结果包含到本页面来。 
bean ：该标签用于创建一个javabean实例。如果指定了id属性，则可以将创建的javabean实例放入Sta
    
                                
    • 
                                
  • 链表.简单的链表节点构建
                                    aijuans
编程技巧
                                    
    /*编程环境WIN-TC*/ #include "stdio.h" #include "conio.h" 
#define NODE(name, key_word, help) \  Node name[1]={{NULL, NULL, NULL, key_word, help}} 
typedef struct node {  &nbs
    
                                
    • 
                                
  • tomcat下jndi的三种配置方式
                                    avords
tomcat
                                    
    jndi(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。命名服务将名称和对象联系起来，使得我们可以用名称 
访问对象。目录服务是一种命名服务，在这种服务里，对象不但有名称，还有属性。 
         tomcat配置
    
                                
    • 
                                
  • 关于敏捷的一些想法
                                    houxinyou
敏捷
                                    
    从网上看到这样一句话：“敏捷开发的最重要目标就是：满足用户多变的需求，说白了就是最大程度的让客户满意。” 
感觉表达的不太清楚。 
感觉容易被人误解的地方主要在“用户多变的需求”上。 
第一种多变，实际上就是没有从根本上了解了用户的需求。用户的需求实际是稳定的，只是比较多，也比较混乱，用户一般只能了解自己的那一小部分，所以没有用户能清楚的表达出整体需求。而由于各种条件的，用户表达自己那一部分时也有
    
                                
    • 
                                
  • 富养还是穷养，决定孩子的一生
                                    bijian1013
教育人生
                                    
        是什么决定孩子未来物质能否丰盛？为什么说寒门很难出贵子，三代才能出贵族？真的是父母必须有钱，才能大概率保证孩子未来富有吗？-----作者：@李雪爱与自由
    事实并非由物质决定，而是由心灵决定。一朋友富有而且修养气质很好，兄弟姐妹也都如此。她的童年时代，物质上大家都很贫乏，但妈妈总是保持生活中的美感，时不时给孩子们带回一些美好小玩意，从来不对孩子传递生活艰辛、金钱来之不易、要懂得珍惜
    
                                
    • 
                                
  • oracle 日期时间格式转化
                                    征客丶
oracle
                                    
    oracle 系统时间有 SYSDATE 与 SYSTIMESTAMP； 
SYSDATE：不支持毫秒，取的是系统时间； 
SYSTIMESTAMP：支持毫秒，日期，时间是给时区转换的，秒和毫秒是取的系统的。 
 
日期转字符窜： 
一、不取毫秒： 
TO_CHAR(SYSDATE, 'YYYY-MM-DD HH24:MI:SS') 
简要说明， 
YYYY 年 
MM   月
    
                                
    • 
                                
  • 【Scala六】分析Spark源代码总结的Scala语法四
                                    bit1129
scala
                                    
    1. apply语法 
  
FileShuffleBlockManager中定义的类ShuffleFileGroup，定义： 
  
private class ShuffleFileGroup(val shuffleId: Int, val fileId: Int, val files: Array[File]) {
  ...
  def apply(bucketId
    
                                
    • 
                                
  • Erlang中有意思的bug
                                    bookjovi
erlang
                                    
      
代码中常有一些很搞笑的bug，如下面的一行代码被调用两次（Erlang beam） 
  
commit f667e4a47b07b07ed035073b94d699ff5fe0ba9b
Author: Jovi Zhang <[email protected]>
Date:   Fri Dec 2 16:19:22 2011 +0100

    erts:
    
                                
    • 
                                
  • 移位打印10进制数转16进制-2008-08-18
                                    ljy325
java基础
                                    
    
/**

 * Description 移位打印10进制的16进制形式

 * Creation Date 15-08-2008 9:00

 * @author 卢俊宇

 * @version 1.0

 *

 */

public class PrintHex {

 

    // 备选字符

    static final char di
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-组合模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 


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

abstract class Component {
	
	public abstract void printStruct(Str
    
                                
    • 
                                
  • 利用cmd命令将.class文件打包成jar
                                    chenyu19891124
cmdjar
                                    
    cmd命令打jar是如下实现： 
在运行里输入cmd，利用cmd命令进入到本地的工作盘符。(如我的是D盘下的文件有此路径 D:\workspace\prpall\WEB-INF\classes) 
现在是想把D:\workspace\prpall\WEB-INF\classes路径下所有的文件打包成prpall.jar。然后继续如下操作： 
cd D: 回车 
cd workspace/prpal
    
                                
    • 
                                
  • [原创]JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明
                                    comsci
eclipse设计模式算法工作swing
                                    
         
 
                  JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明 
 
    &nb
    
                                
    • 
                                
  • SecureCRT右键粘贴的设置
                                    daizj
secureCRT右键粘贴
                                    
    一般都习惯鼠标右键自动粘贴的功能，对于SecureCRT6.7.5 ，这个功能也已经是默认配置了。 
老版本的SecureCRT其实也有这个功能，只是不是默认设置，很多人不知道罢了。 
 
菜单： 
Options->Global Options ...->Terminal 
 
右边有个Mouse的选项块。 
Copy on Select 
Paste on Right/Middle
    
                                
    • 
                                
  • Linux 软链接和硬链接
                                    dongwei_6688
linux
                                    
    1.Linux链接概念Linux链接分两种，一种被称为硬链接（Hard Link），另一种被称为符号链接（Symbolic Link）。默认情况下，ln命令产生硬链接。 
【硬连接】硬连接指通过索引节点来进行连接。在Linux的文件系统中，保存在磁盘分区中的文件不管是什么类型都给它分配一个编号，称为索引节点号(Inode Index)。在Linux中，多个文件名指向同一索引节点是存在的。一般这种连
    
                                
    • 
                                
  • DIV底部自适应
                                    dcj3sjt126com
JavaScript
                                    
    <!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/1999/xhtml&q
    
                                
    • 
                                
  • Centos6.5使用yum安装mysql——快速上手必备
                                    dcj3sjt126com
mysql
                                    
    第1步、yum安装mysql
[root@stonex ~]#  yum -y install mysql-server
安装结果：
Installed:
    mysql-server.x86_64 0:5.1.73-3.el6_5                   &nb
    
                                
    • 
                                
  • 如何调试JDK源码
                                    frank1234
jdk
                                    
    相信各位小伙伴们跟我一样，想通过JDK源码来学习Java，比如collections包，java.util.concurrent包。 
 
可惜的是sun提供的jdk并不能查看运行中的局部变量，需要重新编译一下rt.jar。 
 
下面是编译jdk的具体步骤： 
        1.把C:\java\jdk1.6.0_26\sr
    
                                
    • 
                                
  • Maximal Rectangle
                                    hcx2013
max
                                    
    Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing all ones and return its area. 
  
public class Solution {
    public int maximalRectangle(char[][] matrix)
    
                                
    • 
                                
  • Spring MVC测试框架详解——服务端测试
                                    jinnianshilongnian
spring mvc test
                                    
    随着RESTful Web Service的流行，测试对外的Service是否满足期望也变的必要的。从Spring 3.2开始Spring了Spring Web测试框架，如果版本低于3.2，请使用spring-test-mvc项目（合并到spring3.2中了）。 
  
Spring MVC测试框架提供了对服务器端和客户端（基于RestTemplate的客户端）提供了支持。 
&nbs
    
                                
    • 
                                
  • Linux64位操作系统（CentOS6.6）上如何编译hadoop2.4.0
                                    liyong0802
hadoop
                                    
    一、准备编译软件 
  1.在官网下载jdk1.7、maven3.2.1、ant1.9.4，解压设置好环境变量就可以用。 
    环境变量设置如下： 
  
（1）执行vim /etc/profile
（2）在文件尾部加入:
   export JAVA_HOME=/home/spark/jdk1.7
   export MAVEN_HOME=/ho
    
                                
    • 
                                
  • StatusBar 字体白色
                                    pangyulei
status
                                    
    
[[UIApplication sharedApplication] setStatusBarStyle:UIStatusBarStyleLightContent];
/*you'll also need to set UIViewControllerBasedStatusBarAppearance to NO in the plist file if you use this method
    
                                
    • 
                                
  • 如何分析Java虚拟机死锁
                                    sesame
javathreadoracle虚拟机jdbc
                                    
    英文资料：  
Thread Dump and Concurrency Locks  
  
Thread dumps are very useful for diagnosing synchronization related problems such as deadlocks on object monitors. Ctrl-\ on Solaris/Linux or Ctrl-B
    
                                
    • 
                                
  • 位运算简介及实用技巧（一）：基础篇
                                    tw_wangzhengquan
位运算
                                    
    http://www.matrix67.com/blog/archives/263 
   去年年底写的关于位运算的日志是这个Blog里少数大受欢迎的文章之一，很多人都希望我能不断完善那篇文章。后来我看到了不少其它的资料，学习到了更多关于位运算的知识，有了重新整理位运算技巧的想法。从今天起我就开始写这一系列位运算讲解文章，与其说是原来那篇文章的follow-up，不如说是一个r
    
                                
    • 
                                
  • jsearch的索引文件结构
                                    yangshangchuan
搜索引擎jsearch全文检索信息检索word分词
                                    
    jsearch是一个高性能的全文检索工具包，基于倒排索引，基于java8，类似于lucene，但更轻量级。 
  
jsearch的索引文件结构定义如下： 
    1、一个词的索引由=分割的三部分组成：        第一部分是词        第二部分是这个词在多少
    
                                
    •