致虑
致虑

1-dubbo源码分析之扩展机制

一.概览

整体描述
  • dubbo利用spi扩展机制实现大量的动态扩展，要想充分了解dubbo的扩展机制，首先必须弄明白三个注解：
  • @SPI: 被此注解标记的接口，便是是可扩展的接口，实现类便是动态抓取的了
  • @Adaptive: 自适应扩展~ 该注解可以作用在“类”上，也可以作用在方法上，除了AdaptiveCompiler、AdaptiveExtensionFactory两个类之外，所有的都是注解在方法上。ExtensionLoader根据接口定义动态的生成适配器代码，并实例化这个生成的动态类。被Adaptive注解的方法会生成具体的方法实现。没备注街自然不能成为自适应了。
  • @Activate: 激活扩展~ 可以注解在需要注解在类上或者方法上，并注明被激活的条件及指明排序信息。使用场景最多的就是dubbo的拦截器这一块了。
  • 扩展核心类：ExtensionLoader 加载扩展点就是靠这个类了，加载方式后面详叙，先弄清楚几个主要的变量：

  • SERVICES_DIRECTORY: 定义SPI文件的扫描路径,dubbo源码中设置了好几个：META-INF/services/、META-INF/dubbo/、META-INF/dubbo/internal/; 至于这些文件夹的文件格式如何看下图：


    1-dubbo源码分析之扩展机制_第1张图片
    image.png
    image.png

    文件名为需要扩展接口全路径，文件内容为自配key-->实现类的全路径，很简单；

  • EXTENSION_LOADERS: 拓展点加载器的缓存 --> 接口类型和ExtensionLoader实例的映射关系

  • EXTENSION_INSTANCES: 拓展点的缓存

  • cachedClasses: 扩展文件中的 key --> class

  • cachedInstances: 扩展文件中的 key --> Hold<反射出来的intance>

  • cachedDefaultName: 接口SPI默认的实现名(就是把接口上填的默认值), 这个扩展优先级最高就在这里体现了

二.扩展点加载流程

1-获取ExtensionLoader
  • 测试方法作为入口
    @Test
    public void testAdaptiveExtension() throws Exception {
        SimpleExt ext = ExtensionLoader.getExtensionLoader(SimpleExt.class).getAdaptiveExtension();

        Map map = new HashMap();
        map.put("key", "impl_wxshi");
        URL url = new URL("p1", "1.2.3.4", 1010, "path", map);

        String echo = ext.yell(url, "haha");
        assertEquals("xxxxx", echo);
    }
  • 方法内第一行很明显就是获取ExtensionLoader，进而进入主体：
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 loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
       if (loader == null) {
           /**
            * 取不到创建一个放入EXTENSION_LOADERS中
            */
           EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
           loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
       }
       return loader;
   }
  • 详细很简单：
  • 1.判断要获取的扩展接口是注解@SPI
  • 2.从缓存中获取EXTENSION_LOADERS，若没有直接创建并且放入缓存，即一类接口扩展点只需创建一次EXTENSION_LOADER
  • 3.返回EXTENSION_LOADER用于下一步getAdaptiveExtension()；

  • 这里首次加载扩展点肯定会创建ExtensionLoader了，这里也是个很重要的点，跟着上面的代码EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));进入构造器：

    /**
* 默认初始化一个ExtensionFactory，这个类是用来获取扩展点实体的，
* adaptive就是通过这个类取得扩展点，从而将请求委派给合适的实体完成请求
* Adaptive生成返回给用户后，用户对方法发起调用，adaptive通过getExtension取得provider。getExtension会通过cachedInstances判断此provider是否已cache。没有的话则通过createExtension生成。
*/
private ExtensionLoader(Class type) {
    this.type = type;
    /**
     * type如果是ExtensionFactory类型，那么objectFactory是null,否则是ExtensionFactory类型的适配器类型
     */
    objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}

  • 构造器里面又有一行这样的代码：ExtensionLoader.getExtensionLoader(ExtensionFactory.class)；可想而知这里也是获取自适应点ExtensionFactory.class 用以构造ExtensionLoader了。

  • 看看ExtensionFactory的接口和一个主要实现：

/**
 * ExtensionFactory自身也是个扩展点，它被SPI注解
 * 它有3个provider，分别是adaptive，spi和spring
 * ExtensionFactory是主要是用来加载被注入的类的实现，分为SpiExtensionFactory和SpringExtensionFactory两个，分别用来加载SPI扩展实现和Spring中bean的实现。
 */
@SPI
public interface ExtensionFactory {

    /**
     * Get extension.
     *
     * 获取指定类型的指定名称的扩展点
     *
     * @param type object type.
     * @param name object name.
     * @return object instance.
     */
    @Adaptive
     T getExtension(Class type, String name);
 }

/**
 * AdaptiveExtensionFactory
 * AdaptiveExtesnionFactory是dubbo自定义的adaptive，由于聚合了SpringExtensionFactory和SpiExtensionFactory，从而能对需要注入的对象的所有set方法进行注入
 */
@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);
    }

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

看见@SPI了，同时重点关注下 @Adaptive注解就明确了，这个注解在上面讲了，如果在类上，优先级最高，那取得自适应点就是这个AdaptiveExtensionFactory了，干的事情看后面的作用就知道了，获取扩展点的流程我们用自己的接口解释，这里基本都是一致的，继续往后划重点。

2-自定义扩展点加载

  • 主要进入测试方法中的第一句后半截getAdaptiveExtension()方法，看下图注释

    /**
 * 对于扩展类型是ExtensionFactory的，设置为null
 * getAdaptiveExtension方法获取一个运行时自适应的扩展类型
 * 每个Extension只能有一个@Adaptive类型的实现，如果么有，dubbo会自动生成一个类
 * objectFactory是一个ExtensionFactory类型的属性，主要用于加载需要注入的类型的实现
 * 这里记住非ExtensionFactory类型的返回的都是一个AdaptiveExtensionFactory
 */
@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;
}

    这里就是创建自定义自适应扩展点的入口了，很简单

    • 1.从缓存中获取
    • 2.获取不到直接创建，再加入缓存

  • 直接进入 cachedAdaptiveInstance.set(instance);方法，创建扩展点

    /**
 * 获取到适配器类的Class,利用反射创建适配器类的实例
 * 如果需要自己声明一个adaptive，一定要有个无参构造方法。其实除了wrapper外的所有provider都必须要有个无参构造方法
 */
@SuppressWarnings("unchecked")
private T createAdaptiveExtension() {
    try {
        return injectExtension((T) getAdaptiveExtensionClass().newInstance());
    } catch (Exception e) {
        throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
    }
}

  • 此处主要点就出现了：Class getAdaptiveExtensionClass()；

    private Class getAdaptiveExtensionClass() {
    /**
     * 触发SPI流程的扫描
     */
    getExtensionClasses();

    /**
     * 如果通过上面的步骤可以获取到cachedAdaptiveClass直接返回，如果不行的话，就得考虑自己进行利用动态代理创建一个了
     * 什么情况下不为空？当扩展类上打上@Adaptive注解的时候，就会将这个类直接返回。如果没有上注解，怎么办，就得自己生成了，也就是createAdaptiveExtensionClass
     */
    if (cachedAdaptiveClass != null) {
        return cachedAdaptiveClass;
    }

    /**
     * 利用动态代理创建一个扩展类
     * 如果用户没有声明adaptive（cachedAdaptiveClass为空）则dubbo自动生成一个adaptive
     */
    return cachedAdaptiveClass = createAdaptiveExtensionClass();
}

    看注释一目了然，继续跟踪getExtensionClasses()，该方法没有返回值，从前面那么多缓存就可以看出，这个必然是出发了各种相关缓存的动作，为后面return作用。

  • 继续看重点：SPI流程的扫描 getExtensionClasses();

    /** 当cachedClasses为空时则开始load spi classes */
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;
}

    风格跟之前的一个入口完全相似，先从缓存中取，没有就创建再加缓存，那重点就在加载处了；

  • 继续跟进重点：loadExtensionClasses();

    // synchronized in getExtensionClasses
private Map> loadExtensionClasses() {
    /**
     * 获取到类型的SPI注解，所以利用SPI扩展点的地方，需要加入SPI注解
     */
    final SPI defaultAnnotation = type.getAnnotation(SPI.class);
    if (defaultAnnotation != null) {
        String value = defaultAnnotation.value();
        if ((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));
            }
            /**
             * 如果注解中有value，说明有默认的实现，那么将value放到cachedDefaultName中
             */
            if (names.length == 1) cachedDefaultName = names[0];
        }
    }

    /**
     * 开始load spi文件了，这是整个过程中最为关键也重要的一部
     * 从下面的地址中加在这个类型的数据的extensionClasses中，地址包括
     * META-INF/dubbo/internal/
     * META-INF/dubbo/
     * META-INF/services/
     */
    Map> extensionClasses = new HashMap>();
    loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
    loadDirectory(extensionClasses, DUBBO_DIRECTORY);
    loadDirectory(extensionClasses, SERVICES_DIRECTORY);
    return extensionClasses;
}

    该方法做了两件事：
    - 1.获取默认的注解值（即@SPI(XXX)）中的这个XXX，并缓存；
    - 2.扫描默认路径，加载扩展点

    还记得概览中的三个文件路径吗，这个就是主要的配置扩展点的文件路径了，dubbo会全局扫描所有该路径，遍历加载扩展点。至于加载出来的优先级，最后当然比不上类上配置@Adaptive了，但如果指明了key，那优先级也就不管了。

  • 看loadDirectory(Map> extensionClasses, String dir)

    /**
 * load spi文件
 * dubbo spi的文件位置位于META-INF/dubbo/, META-INF/dubbo/internal和META-INF/services/，文件名就是接口class的full name
 * 对所有文件按行循环，读取的每行内容，以”=”号做分割，前面的是扩展点名称，后面的是实体处理类full name
 */
private void loadDirectory(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 resourceURL = urls.nextElement();
                loadResource(extensionClasses, classLoader, resourceURL);
            }
        }
    } catch (Throwable t) {
        logger.error("Exception when load extension class(interface: " + type + ", description file: " + fileName + ").", t);
    }
}

    加载资源，获取urls，遍历解析扩展类，放入缓存，跟核心方法

  • loadResource(extensionClasses, classLoader, resourceURL);

     private void loadResource(Map> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
     try {
         BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), "utf-8"));
         try {
             String line;
             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.forName(line, true, classLoader)-->加载解析出来的类的全限定名称
                              */
                             loadClass(extensionClasses, resourceURL, Class.forName(line, true, classLoader), name);
                         }
                     } catch (Throwable t) {
                         IllegalStateException e = new IllegalStateException("Failed to load extension class(interface: " + type + ", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);
                         exceptions.put(line, e);
                     }
                 }
             }
         } finally {
             reader.close();
         }
     } catch (Throwable t) {
         logger.error("Exception when load extension class(interface: " + type + ", class file: " + resourceURL + ") in " + resourceURL, t);
     }
}

无非就是解析配置项，获取扩展点类路径，通过类加载器加载，继续

  • loadClass(extensionClasses, resourceURL, Class.forName(line, true, classLoader), name);

    /** 开始进入loadAdaptive */
private void loadClass(Map> extensionClasses, java.net.URL resourceURL, Class clazz, String name) throws NoSuchMethodException {

    /**
     * 判断是新加载clazz是否是type的子类，不是报错
     */
    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.");
    }
    /**
     * 如果class上有@Adaptive，则是一个adaptive，此时开始下一个循环
     * 注意这个点，查询type类型适配器类的时候会优先寻找cachedAdaptiveClass，因为是系统指定的适配器类，优先级最高
     *
     */
    if (clazz.isAnnotationPresent(Adaptive.class)) {
        if (cachedAdaptiveClass == null) {
            cachedAdaptiveClass = clazz;
        }
        /**
         * 多个adaptive类的实例，报错
         * 标准的适配器类只能有一个
         */
        else if (!cachedAdaptiveClass.equals(clazz)) {
            throw new IllegalStateException("More than 1 adaptive class found: " + cachedAdaptiveClass.getClass().getName() + ", " + clazz.getClass().getName());
        }
    }

    /**
     * 如果不是则开始loadWrapper。判断wrapper的标准是class有没有一个参数为接口类型的构造参数。如果是wrapper则塞入到cachedWrapperClasses中
     * 不是wrapper时会抛出NoSuchMethodException异常，从而进入loadActivation和loadEntity的过程
     *
     * 如果这个扩展类没有打上@Adaptive注解就更有意思了。
     * 首先第一步会验证下有没有type这个类型作为入参的构造方法，为什么要这么做？因为Wrapper，有的类型需要包装一下，例如type=Protocol.class 就会看到有DubboProtocol真实的Protocal类
     * 还会有ProtocolFilterWrapper和ProtocolListenerWrapper这种Wrapper类，这种Wrapper类的共同点就是构造函数的入参是type类型，所以在解析的时候有这么一步
     * 如果有这种构造函数的就是Warpper类，将这些Warpper类型的数据放到cachedWrapperClasses这个集合中缓存
     * 如果没有这种类型的构造函数，就是正常的type类型的实例了
     *
     */
    else if (isWrapperClass(clazz)) {
        Set> wrappers = cachedWrapperClasses;
        if (wrappers == null) {
            cachedWrapperClasses = new ConcurrentHashSet>();
            wrappers = cachedWrapperClasses;
        }
        /**
         * 将此wrapper放入wrappers容器里面，也就是cachedWrapperClasses里面
         */
        wrappers.add(clazz);
    }


    /** 进入loadActivation和loadEntity的过程 */
    else {

        /** 到了这里，说明是个正常的类 */
        clazz.getConstructor();

        /**
         * 1.处理name为null的情况，为空时截取provider的simpleName的一部分作为name。即:如果在文件中没有声明这个扩展的名称（=左边的部分），就会根据这个类名创建一个名称
         * 2.上面提到过dubbo从三个文件夹，其中包括META-INF/services。熟悉jdk spi的对这个应该不陌生，这是jdk spi的默认加载路径，但是jdk声明provider只要声明一个full name就行。通过这一步dubbo spi就可以兼容jdk语法的spi了。
         */
        if (name == null || name.length() == 0) {
            name = findAnnotationName(clazz);
            if (name.length() == 0) {
                throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
            }
        }

        /**
         * 看下这个类上有没有Activate注解
         * 被@Activate声明的provider会被cache到cachedActivates里
         *
         *
         * 然后进入下一个环节@Activate数据的解析。
         * 1.查看type类上有没有@Activate注解，如果有的话，将名称与注解放到cachedActivates这个Map中进行缓存。
         * 2.将扩展类和名称放入cachedNames这个Map中进行缓存，将名称和扩展类的class放入传递进来的extensionClasses中
         * 3.最后这个extensionClasses会被返回出来被使用
         */
        String[] names = NAME_SEPARATOR.split(name);
        if (names != null && names.length > 0) {
            Activate activate = clazz.getAnnotation(Activate.class);

            //存在，就往cachedActivates里面添加名称与注解
            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);
                /**
                 * 非wrapper和adaptive的class都会被put到extensionClasses里，它是个map，这个map会被返回，然后被cache到cachedClasses。
                 */
                if (c == null) {
                    //最后往extensionClasses添加名称与class
                    extensionClasses.put(n, clazz);
                } else if (c != clazz) {
                    throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
                }
            }
        }
    }
}

    注释很清楚，这里说明几个主要的点:

    • 1.判断当前类上是否有@Adaptive注解，如果有则记录下，因为毕竟次注解优先级最高，但是该注解既然是默认优先级，因此肯定只能存在一个，多了就不知道找谁了。
    • 2.是不是WrapperClass,从词义就知道这是一个包装类，其实类似于Spring的切面，将真正的扩展点类以构造方式包在其中，这样就可以实现一些额外逻辑了，即Wrapper 代理了扩展点。
    • 3.当然是解析正常类了，现获取类名，判断是否有@Activate注解，加入缓存等。

  • 到这里getExtensionClasses()就告一段落了，将刚才这里的出发点再贴一下，防止不能回头

 private Class getAdaptiveExtensionClass() {
     /**
      * 触发SPI流程的扫描
      */
     getExtensionClasses();

     /**
      * 如果通过上面的步骤可以获取到cachedAdaptiveClass直接返回，如果不行的话，就得考虑自己进行利用动态代理创建一个了
      * 什么情况下不为空？当扩展类上打上@Adaptive注解的时候，就会将这个类直接返回。如果没有上注解，怎么办，就得自己生成了，也就是createAdaptiveExtensionClass
      */
     if (cachedAdaptiveClass != null) {
         return cachedAdaptiveClass;
     }

     /**
      * 利用动态代理创建一个扩展类
      * 如果用户没有声明adaptive（cachedAdaptiveClass为空）则dubbo自动生成一个adaptive
      */
     return cachedAdaptiveClass = createAdaptiveExtensionClass();
 }

往下走就会发现，如果cachedAdaptiveClass != null,直接返回，这个就是体现优先级的地方了。若没有，继续深入createAdaptiveExtensionClass()

  • 利用动态代理创建一个扩展类

     /**
  * 将类以字符串的形式拼接出来，然后利用编译器进行编译，返回编译后的class对象
  */
 private Class createAdaptiveExtensionClass() {
     /**
      * 创建代码的字符串形式
      */
     String code = createAdaptiveExtensionClassCode();
     /**
      * 寻找类加载器
      */
     ClassLoader classLoader = findClassLoader();
     /**
      * 寻找Compiler的适配器扩展类
      */
     com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
     /**
      * 进行编译成Class的实例返回
      */
     return compiler.compile(code, classLoader);
 }

    核心就在那个code的解释了，这里的code形式如下:

     package com.alibaba.dubbo.common.extensionloader.ext1;
 import com.alibaba.dubbo.common.extension.ExtensionLoader;
 
 public class SimpleExt$Adaptive implements com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt {
     
     public java.lang.String yell(com.alibaba.dubbo.common.URL arg0, java.lang.String arg1) {
         if (arg0 == null) throw new IllegalArgumentException("url == null");
         com.alibaba.dubbo.common.URL url = arg0;
         String extName = url.getParameter("key1", url.getParameter("key2", "impl1"));
         if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt) name from url(" + url.toString() + ") use keys([key1, key2])");
         com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt extension = (com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt.class).getExtension(extName);
         return extension.yell(arg0, arg1);
     }
     
     public java.lang.String echo(com.alibaba.dubbo.common.URL arg0, java.lang.String arg1) {
         if (arg0 == null) throw new IllegalArgumentException("url == null");
         com.alibaba.dubbo.common.URL url = arg0;
         String extName = url.getParameter("simple.ext", "impl1");
         if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt) name from url(" + url.toString() + ") use keys([simple.ext])");
         com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt extension = (com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt.class).getExtension(extName);
         return extension.echo(arg0, arg1);
     }
     public java.lang.String bang(com.alibaba.dubbo.common.URL arg0, int arg1) {
         throw new UnsupportedOperationException("method public abstract java.lang.String com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt.bang(com.alibaba.dubbo.common.URL,int) of interface com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt is not adaptive method!");
     }
 }

code还是字符串形式，那后面的代码就清楚了

  • 1.寻找类加载器

  • 2.再利用自适应扩展点（javassist）寻找编译器Compiler

  • 3.将字符串code生成具体的类，这个类就是最终的扩展点代理类啦。
    对于第二点为啥是javassist，看下图:

    /**
 * Compiler. (SPI, Singleton, ThreadSafe)
 */
@SPI("javassist")
public interface Compiler {

    /**
     * Compile java source code.
     *
     * @param code        Java source code
     * @param classLoader classloader
     * @return Compiled class
     */
    Class compile(String code, ClassLoader classLoader);
}

    该@SPI("javassist")应该足以说明默认取的是哪个代理器了。

  • 到此扩展点的代理就产生了，后面执行具体方法的时候，执行的实际是代理的方法体，再去执行具体逻辑，看字节码就清楚了执行过程。
3.执行具体的方法

  • String echo = ext.echo(url, "haha");其实执行的代理的如下方法体，看上图字节码

     public java.lang.String echo(com.alibaba.dubbo.common.URL arg0, java.lang.String arg1) {
        if (arg0 == null) throw new IllegalArgumentException("url == null");
        com.alibaba.dubbo.common.URL url = arg0;
        String extName = url.getParameter("simple.ext", "impl1");
        if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt) name from url(" + url.toString() + ") use keys([simple.ext])");
        com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt extension = (com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt.class).getExtension(extName);
        return extension.echo(arg0, arg1);
}

看到执行逻辑如下:
- 1.获取扩展点的Extensionloader，之前的流程中已经缓存了，所以直接获取
- 2.调用getExtension(extName)方法获取具体的扩展点，这个就是最后获取真正代理的时候了

  • 获取实际扩展点的真正代理

    /**
 * Find the extension with the given name. If the specified name is not found, then {@link IllegalStateException}
 * will be thrown.
 */
@SuppressWarnings("unchecked")
public T getExtension(String name) {
    if (name == null || name.length() == 0)
        throw new IllegalArgumentException("Extension name == null");
    if ("true".equals(name)) {
        return getDefaultExtension();
    }
    Holder 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;
}
 
    重点代码就是instance = createExtension(name); 返回instance，且缓存。继续跟踪：
     
    /**
 * 1.getExtensionClasses在cachedClasses有值时直接返回cachedClasses。上一节介绍过，loadFile结束后会把provider calss都cache到cachedClasses上
 * 2.通过cachedClasses就可以获得name对应的provider了
 * 3.国际惯例还是要inject
 * 4.存在wrapper的话则迭代包装，上一节也介绍过，先定义的包装后定义的。
 */
@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, clazz.newInstance());
            instance = (T) EXTENSION_INSTANCES.get(clazz);
        }
        injectExtension(instance);
        Set> wrapperClasses = cachedWrapperClasses;
        if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
            for (Class wrapperClass : wrapperClasses) {
                instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
            }
        }
        return instance;
    } catch (Throwable t) {
        throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
                type + ")  could not be instantiated: " + t.getMessage(), t);
    }
}

     
    风格完全不变，依然先尝试从缓存中获取，没有则EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
     这里就根据具体的class newInstance()出一个对象了，这个对象就是指定的具体的实际调用对象了。
     这里还有一个小的点,就是注释描述的那样，inject + wrapper,wrapper前面介绍过，inject如下:
     
    /**
 * 如果适配器类有属性的set方法，会自动注入
 * 生成provider后 通过injectExtension对其进行注入。注入是通过ExtensionFactory完成的
 * */
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())) {
                    Class pt = method.getParameterTypes()[0];
                    try {
                        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);
                        }
                    } 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就执行具体的方法。
    •  
  

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(1-dubbo源码分析之扩展机制)
    
        
    
            
    
                
      
                    
    • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
      功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
      
                    
      • 
                    
    • 扫地机类清洁产品之直流无刷电机控制
                        悟空胆好小
清洁服务机器人单片机人工智能
                        
      扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
      
                    
      • 
                    
    • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
                        小鹿_33

                        
      预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
      
                    
      • 
                    
    • 《大清方方案》| 第二话
                        谁佐清欢

                        
      和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
      
                    
      • 
                    
    • 《庄子.达生9》
                        钱江潮369

                        
      【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
      
                    
      • 
                    
    • 腾讯云技术深度探索：构建高效云原生微服务架构
                        我的运维人生
云原生架构腾讯云运维开发技术共享
                        
      腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
      
                    
      • 
                    
    • 高端密码学院笔记285
                        柚子_b4b4

                        
      高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
      
                    
      • 
                    
    • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
      不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
      
                    
      • 
                    
    • 【加密社】Solidity 中的事件机制及其应用
                        加密社
闲侃区块链智能合约区块链
                        
      加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
      
                    
      • 
                    
    • 东南林氏之九牧林候选父系
                        祖缘树TheYtree

                        
      渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
      
                    
      • 
                    
    • MYSQL面试系列-04
                        king01299
面试mysql面试
                        
      MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
      
                    
      • 
                    
    • 大伟说成语之唉声叹气
                        求索大伟

                        
      ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
      
                    
      • 
                    
    • libyuv之linux编译
                        jaronho
Linuxlinux运维服务器
                        
      文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
      
                    
      • 
                    
    • 怎么做淘客赚钱(2022最新免费淘客盈利的方法)
                        高省_飞智666600

                        
      很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
      
                    
      • 
                    
    • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
      文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
      
                    
      • 
                    
    • 锁之缘
                        尘缘诗词原创作品

                        
      是谁追寻梦的足迹，是谁在偷偷的哭泣，日月隔离在黑白天地情感在心中蔓延的痕迹天与地的距离有多远流失的星晨落入哪片空间不要让泪水模糊双眼心牢中一样充满温暖谁说爱情没有永远白娘子又为何爱许仙蝴蝶墓地展翅翩翩轻歌慢舞袖卷人间传奇千古留爱万年…………月落星飞徘徊是选择不去问自已为合舍不得寂寞本就是痛苦的不在追寻梦中的痕迹才不会失去真实的自已
      
                    
      • 
                    
    • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
      ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
      
                    
      • 
                    
    • ARM驱动学习之5 LEDS驱动
                        JT灬新一
嵌入式C底层arm开发学习单片机
                        
      ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
      
                    
      • 
                    
    • ARM驱动学习之4小结
                        JT灬新一
嵌入式C++arm开发学习linux
                        
      ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
      
                    
      • 
                    
    • C++ | Leetcode C++题解之第409题最长回文串
                        Ddddddd_158
经验分享C++Leetcode题解
                        
      题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
      
                    
      • 
                    
    • 2020-12-24
                        我和我的天使们

                        
      阅读《老子的心事》391—403“将欲取之，必固与之”：想要得到什么，首先就要送出什么。我常常对孩子们说，你希望别人怎样对你你就怎样对待别人。想要得到别人的尊重，首先要尊重别人。我希望她们可以不迟到，因为不迟到是对别人的尊重，我就自己就先做到不迟到。哪怕是约朋友逛街，我尽量准时赴约。我严格要求孩子们，也同样严格要求自己，我跟孩子们一起把好的品格变成习惯。“是谓微明”：这就是微妙的智慧。看起来很少很
      
                    
      • 
                    
    • 18、架构-可观测性之聚合度量
                        大树~~
架构javapython后端架构
                        
      聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
      
                    
      • 
                    
    • 学习“论语”-第59天
                        春峰轩

                        
      12.14子张问政。子曰：“居之无倦，行之以忠。”子张问为政之道。孔子说：“在位尽职不懈怠，执行政令要忠诚。”12.15子曰：“博学于文，约之以礼，亦可以弗畔矣夫！”孔子说：“君子广泛地学习文献，并且用礼节约束自己，也就不会离经叛道了。”12.16子曰：“君子成人之美，不成人之恶。小人反是。”孔子说：“君子成全别人的好事，而不助长别人的坏处。小人则与此相反行事。”知识点:“成人之美，不成人之恶”贯
      
                    
      • 
                    
    • nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
      Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
      
                    
      • 
                    
    • 2021-11-15
                        宙火

                        
      我给宋小姐写了首诗，是我在课上因思恋宋小姐而写的。“自古多情是唐宋，从来双飞归巢燕。邻家小女相聘婷，常使春意荡漾我。不知单思可为爱，惟愿一心付之汝。”我拿给宋小姐看了，她说我写得很棒。我很开心，但又不是那么开心。宋小姐是回复我了，但也只是说我写得很棒，对我诗句中蕴藏的真切感情，不知道是真的没发现，还是装作没发现。但我不深究，只是这样，我就很开心了。我答应宋小姐，一天给她写一首诗。
      
                    
      • 
                    
    • 《我的青葱岁月之缘来是你》 第二章 迎新晚会
                        思源思缘思怨

                        
      “怎么你也来了这里？”我愉快的问到，想着这是上天给的缘分吗？我还没去找他竟然就相遇了。那个让我开心的老乡。“你好，我也是舞蹈社的新人啊！”他说，笑起来回答我，眼睛弯弯的。“这么巧，我叫吴倩，你叫啥？”“我叫韩欢，你也是B市人吧，c中毕业的？”“我不是，我是f中的，不然肯定会认识你的”“是吗？以后多多关照了”他还冲我眨了眨眼睛。内心一阵悸动，这是……回到寝室，我兴奋的告诉我的室友这个事情，我再次觉得
      
                    
      • 
                    
    • 数据结构之哈希表
                        X同学的开始
数据结构数据结构散列表
                        
      哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
      
                    
      • 
                    
    • 厦门自由行之第一天:
                        大苏子在广漂

                        
      厦门三人行之杂记出发前一天:12️28日下午15:00从广州粗发，来深圳集合！但是中间发生一个小插曲，验票时候发现车票不见了，或许也是一场恶作剧，对于不排队的人，忍不住说了一下，接下来就发现车票不见了，已经是拿在手上！不过还好，可以凭借购票订单查看到信息，所以有惊无险，顺利进站！晚上三个人一起去吃了柠檬鱼，说实话，那会，感觉美吃饱，啊哈哈！晚上回来，两个人又开始彻夜长谈，发现身边优秀的人，一大把，
      
                    
      • 
                    
    • “这才好”麻辣香锅 能够增加人身体的免疫能力
                        小补文知

                        
      我就来介绍一种香锅，那就是“这才好”麻辣香锅，它产出于著名的蜀地文化，具有悠久的历史土家风味，麻辣鲜香，健康安全。采用传统秘制麻辣香锅油辣子，还有贴心加料“孜然包”满足人们的不同口味需求，香锅底料辣椒，微辣且香，含有丰富微量元素和维生素，具有辣而不躁，味道纯正，醇厚温和。花椒采用历史悠久，被列为宫廷供品的“贡椒”的汉源花椒。我们还挑选了“川菜之魂”郫县豆瓣的鼻祖品牌豆瓣，保留最原始的郫县豆瓣味道，
      
                    
      • 
                    
    • 《太虚游》第六十二章。玄牝之威。
                        古楼臭道士

                        
      “好好好，流云这孩子深得我心，想必长爻知道是你的话定然会惊喜不已的。”白玄牝听得风流云应了下来，脸色慈和，伸手在他头顶轻轻抚了抚，如同抚在怀中九尾小狐一样自然，极其温柔。身后的四位青丘长老同时一怔，嘴角微动，似要开口劝阻。风流云只感到一道霞光瑞气如有实质一般顺着头顶百会大穴直沉在下丹田内，随后这股气息又逐渐凝聚，似乎给自己吃了什么东西一般。啊喔不好，这祖奶奶该不会是看中我这肉身，像人魔一样，要给她
      
                    
      • 
                                
    • 多线程编程之卫生间
                                    周凡杨
java并发卫生间线程厕所
                                    
      如大家所知，火车上车厢的卫生间很小，每次只能容纳一个人，一个车厢只有一个卫生间，这个卫生间会被多个人同时使用，在实际使用时，当一个人进入卫生间时则会把卫生间锁上，等出来时打开门，下一个人进去把门锁上，如果有一个人在卫生间内部则别人的人发现门是锁的则只能在外面等待。问题分析：首先问题中有两个实体，一个是人，一个是厕所，所以设计程序时就可以设计两个类。人是多数的，厕所只有一个（暂且模拟的是一个车厢）。
      
                                
      • 
                                
    • How to Install GUI to Centos Minimal
                                    sunjing
linuxInstallDesktopGUI
                                    
      http://www.namhuy.net/475/how-to-install-gui-to-centos-minimal.html 
  
I have centos 6.3 minimal running as web server. I’m looking to install gui to my server to vnc to my server. You can insta
      
                                
      • 
                                
    • Shell 函数
                                    daizj
shell函数
                                    
      Shell 函数 
linux shell 可以用户定义函数，然后在shell脚本中可以随便调用。 
shell中函数的定义格式如下： 
[function] funname [()]{

    action;
  
     [return int;]

} 
说明： 
 
 1、可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。 
 2、参数返回
      
                                
      • 
                                
    • Linux服务器新手操作之一
                                    周凡杨
Linux 简单 操作
                                    
      1.whoami 
     当一个用户登录Linux系统之后，也许他想知道自己是发哪个用户登录的。 
     此时可以使用whoami命令。 
     [ecuser@HA5-DZ05 ~]$ whoami 
      e
      
                                
      • 
                                
    • 浅谈Socket通信（一）
                                    朱辉辉33
socket
                                    
      在java中ServerSocket用于服务器端，用来监听端口。通过服务器监听，客户端发送请求，双方建立链接后才能通信。当服务器和客户端建立链接后，两边都会产生一个Socket实例，我们可以通过操作Socket来建立通信。 
   首先我建立一个ServerSocket对象。当然要导入java.net.ServerSocket包 
   ServerSock
      
                                
      • 
                                
    • 关于框架的简单认识
                                    西蜀石兰
框架
                                    
      入职两个月多，依然是一个不会写代码的小白，每天的工作就是看代码，写wiki。 
前端接触CSS、HTML、JS等语言，一直在用的CS模型，自然免不了数据库的链接及使用，真心涉及框架，项目中用到的BootStrap算一个吧，哦，JQuery只能算半个框架吧，我更觉得它是另外一种语言。 
后台一直是纯Java代码，涉及的框架是Quzrtz和log4j。 
 
都说学前端的要知道三大框架，目前node.
      
                                
      • 
                                
    • You have an error in your SQL syntax; check the manual that corresponds to your
                                    林鹤霄

                                    
      You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'option,changed_ids  ) values('0ac91f167f754c8cbac00e9e3dc372
      
                                
      • 
                                
    • MySQL5.6的my.ini配置
                                    aigo
mysql
                                    
      注意：以下配置的服务器硬件是：8核16G内存  
  
[client] 
  
port=3306 
  
[mysql] 
  
default-character-set=utf8 
  
  
[mysqld] 
  
port=3306 
  
basedir=D:/mysql-5.6.21-win
      
                                
      • 
                                
    • mysql 全文模糊查找 便捷解决方案
                                    alxw4616
mysql
                                    
      mysql 全文模糊查找 便捷解决方案 
2013/6/14 by 半仙 [email protected] 
 
目的: 项目需求实现模糊查找. 
原则: 查询不能超过 1秒. 
 
问题: 目标表中有超过1千万条记录. 使用like '%str%' 进行模糊查询无法达到性能需求. 
解决方案: 使用mysql全文索引. 
 1.全文索引 : MySQL支持全文索引和搜索功能。MySQL中的全文索
      
                                
      • 
                                
    • 自定义数据结构 链表(单项 ,双向,环形)
                                    百合不是茶
单项链表双向链表
                                    
        
   链表与动态数组的实现方式差不多,    数组适合快速删除某个元素    链表则可以快速的保存数组并且可以是不连续的 
  
    
单项链表;数据从第一个指向最后一个 
  
实现代码: 
  
     
//定义动态链表
clas
      
                                
      • 
                                
    • threadLocal实例
                                    bijian1013
javathreadjava多线程threadLocal
                                    
      实例1： 
package com.bijian.thread;

public class MyThread extends Thread {

	private static ThreadLocal tl = new ThreadLocal() {
		protected synchronized Object initialValue() {
			return new Inte
      
                                
      • 
                                
    • activemq安全设置—设置admin的用户名和密码
                                    bijian1013
javaactivemq
                                    
              ActiveMQ使用的是jetty服务器, 打开conf/jetty.xml文件，找到 
<bean id="adminSecurityConstraint" class="org.eclipse.jetty.util.security.Constraint">
        <p
      
                                
      • 
                                
    • 【Java范型一】Java范型详解之范型集合和自定义范型类
                                    bit1129
java
                                    
      本文详细介绍Java的范型，写一篇关于范型的博客原因有两个，前几天要写个范型方法(返回值根据传入的类型而定)，竟然想了半天，最后还是从网上找了个范型方法的写法；再者，前一段时间在看Gson, Gson这个JSON包的精华就在于对范型的优雅简单的处理，看它的源代码就比较迷糊，只其然不知其所以然。所以，还是花点时间系统的整理总结下范型吧。 
  范型内容 
 
 范型集合类 
 范型类 
 
      
                                
      • 
                                
    • 【HBase十二】HFile存储的是一个列族的数据
                                    bit1129
hbase
                                    
      在HBase中，每个HFile存储的是一个表中一个列族的数据，也就是说，当一个表中有多个列簇时，针对每个列簇插入数据，最后产生的数据是多个HFile，每个对应一个列族，通过如下操作验证 
  
1. 建立一个有两个列族的表 
  
create 'members','colfam1','colfam2' 
  
2. 在members表中的colfam1中插入50*5
      
                                
      • 
                                
    • Nginx 官方一个配置实例
                                    ronin47
nginx 配置实例
                                    
      user       www www;
worker_processes  5;
error_log  logs/error.log;
pid        logs/nginx.pid;
worker_rlimit_nofile 8192;

events {
  worker_connections  4096;}

http {
  include    conf/mim
      
                                
      • 
                                
    • java-15.输入一颗二元查找树，将该树转换为它的镜像， 即在转换后的二元查找树中，左子树的结点都大于右子树的结点。 用递归和循环
                                    bylijinnan
java
                                    
      
//use recursion
	public static void mirrorHelp1(Node node){
		if(node==null)return;
		swapChild(node);
		mirrorHelp1(node.getLeft());
		mirrorHelp1(node.getRight());
	}
	//use no recursion bu
      
                                
      • 
                                
    • 返回null还是empty
                                    bylijinnan
javaapachespring编程
                                    
      第一个问题，函数是应当返回null还是长度为0的数组（或集合）？ 
第二个问题，函数输入参数不当时，是异常还是返回null？ 
 
先看第一个问题 
 
有两个约定我觉得应当遵守： 
 
1.返回零长度的数组或集合而不是null（详见《Effective Java》） 
 
理由就是，如果返回empty，就可以少了很多not-null判断： 
 

List<Person> list
      
                                
      • 
                                
    • [科技与项目]工作流厂商的战略机遇期
                                    comsci
工作流
                                    
       
 
      在新的战略平衡形成之前，这里有一个短暂的战略机遇期，只有大概最短6年，最长14年的时间，这段时间就好像我们森林里面的小动物，在秋天中，必须抓紧一切时间存储坚果一样，否则无法熬过漫长的冬季。。。。 
 
 
        在微软，甲骨文，谷歌，IBM,SONY
      
                                
      • 
                                
    • 过度设计-举例
                                    cuityang
过度设计
                                    
      过度设计，需要更多设计时间和测试成本，如无必要，还是尽量简洁一些好。 
未来的事情，比如 访问量，比如数据库的容量，比如是否需要改成分布式  都是无法预料的 
 
再举一个例子，对闰年的判断逻辑： 
　　1、 if($Year%4==0) return True; else return Fasle; 
　　2、if (   ($Year%4==0  &am
      
                                
      • 
                                
    • java进阶，《Java性能优化权威指南》试读
                                    darkblue086
java性能优化
                                    
      记得当年随意读了微软出版社的.NET 2.0应用程序调试，才发现调试器如此强大，应用程序开发调试其实真的简单了很多，不仅仅是因为里面介绍了很多调试器工具的使用，更是因为里面寻找问题并重现问题的思想让我震撼，时隔多年，Java已经如日中天，成为许多大型企业应用的首选，而今天，这本《Java性能优化权威指南》让我再次找到了这种感觉，从不经意的开发过程让我刮目相看，原来性能调优不是简单地看看热点在哪里，
      
                                
      • 
                                
    • 网络学习笔记初识OSI七层模型与TCP协议
                                    dcj3sjt126com
学习笔记
                                    
         协议：在计算机网络中通信各方面所达成的、共同遵守和执行的一系列约定   　　计算机网络的体系结构：计算机网络的层次结构和各层协议的集合。   　　两类服务：   　　面向连接的服务通信双方在通信之前先建立某种状态，并在通信过程中维持这种状态的变化，同时为服务对象预先分配一定的资源。这种服务叫做面向连接的服务。   　　面向无连接的服务通信双方在通信前后不建立和维持状态，不为服务对象
      
                                
      • 
                                
    • mac中用命令行运行mysql
                                    dcj3sjt126com
mysqllinuxmac
                                    
      参考这篇博客：http://www.cnblogs.com/macro-cheng/archive/2011/10/25/mysql-001.html  感觉workbench不好用（有点先入为主了）。 
1，安装mysql 
在mysql的官方网站下载 mysql 5.5.23 http://www.mysql.com/downloads/mysql/，根据我的机器的配置情况选择了64
      
                                
      • 
                                
    • MongDB查询（1）——基本查询[五]
                                    eksliang
mongodbmongodb 查询mongodb find
                                    
      MongDB查询 
转载请出自出处：http://eksliang.iteye.com/blog/2174452 一、find简介 
MongoDB中使用find来进行查询。 
API:如下 
function ( query , fields , limit , skip, batchSize, options ){.....} 
 参数含义： 
 
 query:查询参数 
 fie
      
                                
      • 
                                
    • base64，加密解密 经融加密，对接
                                    y806839048
经融加密对接
                                    
      String data0 = new String(Base64.encode(bo.getPaymentResult().getBytes(("GBK")))); 
 String data1 = new String(Base64.decode(data0.toCharArray()),"GBK"); 
 
// 注意编码格式，注意用于加密，解密的要是同
      
                                
      • 
                                
    • JavaWeb之JSP概述
                                    ihuning
javaweb
                                    
        
什么是JSP？为什么使用JSP？ 
JSP表示Java Server Page，即嵌有Java代码的HTML页面。使用JSP是因为在HTML中嵌入Java代码比在Java代码中拼接字符串更容易、更方便和更高效。 
  
JSP起源  
  
在很多动态网页中，绝大部分内容都是固定不变的，只有局部内容需要动态产生和改变。  
如果使用Servl
      
                                
      • 
                                
    • apple watch 指南
                                    啸笑天
apple
                                    
      1. 文档 
 
  WatchKit Programming Guide（中译在线版 By @CocoaChina）    译文 译者 原文   概览 - 开始为 Apple Watch 进行开发 @星夜暮晨 Overview - Developing for Apple Watch   概览 - 配置 Xcode 项目 - Overview - Configuring Yo
      
                                
      • 
                                
    • java经典的基础题目
                                    macroli
java编程
                                    
      1.列举出 10个JAVA语言的优势 a:免费，开源，跨平台(平台独立性)，简单易用，功能完善，面向对象，健壮性，多线程，结构中立，企业应用的成熟平台, 无线应用 2.列举出JAVA中10个面向对象编程的术语 a:包，类，接口，对象，属性，方法，构造器，继承，封装，多态，抽象，范型 3.列举出JAVA中6个比较常用的包 Java.lang;java.util;java.io;java.sql;ja
      
                                
      • 
                                
    • 你所不知道神奇的js replace正则表达式
                                    qiaolevip
每天进步一点点学习永无止境纵观千象regex
                                    
      var v = 'C9CFBAA3CAD0';
console.log(v);
var arr = v.split('');
for (var i = 0; i < arr.length; i ++) {
  if (i % 2 == 0) arr[i] = '%' + arr[i];
}
console.log(arr.join(''));

console.log(v.r
      
                                
      • 
                                
    • [一起学Hive]之十五-分析Hive表和分区的统计信息(Statistics)
                                    superlxw1234
hivehive分析表hive统计信息hive Statistics
                                    
      关键字：Hive统计信息、分析Hive表、Hive Statistics 
  
类似于Oracle的分析表，Hive中也提供了分析表和分区的功能，通过自动和手动分析Hive表，将Hive表的一些统计信息存储到元数据中。 
  
表和分区的统计信息主要包括：行数、文件数、原始数据大小、所占存储大小、最后一次操作时间等； 
  14.1 新表的统计信息 
对于一个新创建
      
                                
      • 
                                
    • Spring Boot 1.2.5 发布
                                    wiselyman
spring boot
                                    
        
  
Spring Boot 1.2.5已在7月2日发布，现在可以从spring的maven库和maven中心库下载。 
  
这个版本是一个维护的发布版，主要是一些修复以及将Spring的依赖提升至4.1.7(包含重要的安全修复)。 
  
官方建议所有的Spring Boot用户升级这个版本。 
  
项目首页 | 源
      
                                
      •