weixin_33923762
weixin_33923762

Dubbo源码分析（三）：ExtensionLoader

为什么80%的码农都做不了架构师？>>>   hot3.png

    dubbo框架的微内核+插件的机制，其中插件机制就是依赖ExtensionLoader来实现，可以说是dubbo的核心所在。通过插件机制解耦依赖来实现框架设计原则中的针对接口编程而不针对实现。 
熟悉ExtensionLoader就熟悉了Dubbo的扩展机制。

JDK的标准SPI对比dubbo的SPI

JDK的扩展SPI:

    新建接口，然后定义不同实现，然后/META-INF/services定义接口的全路径的文件，文件中写上接口的全部实现类，最后代码通过ServiceLoader加载，循环迭代得到所有实现类。标准SPI迭代时会加载所有实现，所以只希望加载某个的，就不现实了。 
Dubbo的扩展SPI：

    1. 单例，对于某个扩展，只会有一个ExtensionLoader； 
    2. 延迟加载，可以一次只获取想要的扩展点，一次获取想要的扩展点实现； 
    3. 对于扩展点的Ioc和Aop，就是一个扩展可以注入到另一个扩展中，也可以对一个扩展做wrap包装实现aop的功能； 
    4. 对于扩展点的调用，真正调用的时候才能确认具体使用的是那个实现。

源码解析

所有扩展必须加上SPI注解才能通过ExtensionLoader加载。对于一个扩展点只会加载一次，生成一个ExtensionLoader。通过ExtensionLoader.getExtensionLoader(class type)传入一个spi扩展返回一个ExtensionLoader实例。

    private ExtensionLoader(Class type) {
        this.type = type;
        // 也是利用扩展实现，后面会看到在注入其他扩展点或bean到当前扩展时使用
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    } 
    @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 loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        if (loader == null) {
            // 创建一个ExtensionLoader返回
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
            loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

Dubbo中的扩展点均有多个实现，而框架设计原则又让我们针对接口编程而不是实现，这就需要在运行期才能决定具体使用哪个扩展实现类。Dubbo提供了Adpative注解，让我们自行决定究竟是自己提供扩展的适配还是由Dubbo来帮我们生成动态适配。后面会给出2个自定义扩展实现Demo，一个是我们自定义适配，另一个是Dubbo提供动态适配。 

常用方式：ExtensionLoader.getExtensionLoader(扩展点class).getAdaptiveExtension()
 

     /** 获取扩展的适配器类 */     
     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;
    }
    /** 创建Adpative */
    private T createAdaptiveExtension() {
        try {
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can not create adaptive extenstion " + type + ", cause: " + e.getMessage(), e);
        }
    }

这里分两步：

1. getAdaptiveExtensionClass：获取适配器类； 
2. injectExtension：为适配器类的setter方法插入其他扩展点或实现bean。

    /** 获取适配器类 */
    private Class getAdaptiveExtensionClass() {
        // 加载所有扩展点实现类
        getExtensionClasses();
        // 如果用户有自定义适配器实现类，return
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        // dubbo帮我们动态创建一个适配器类
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }

    /** 加载扩展类 */
    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;
    }

    /** 从不同目录加载扩展实现 */
    private Map> loadExtensionClasses() {
        // Dubbo的扩展接口必须实现SPI注解
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        // 这里是解析SPI注解，看是否有默认实现，后期Dubbo获取扩展的实现，如果获取不到就会有使用这个默认实现
        if (defaultAnnotation != null) {
            String value = defaultAnnotation.value();
            if (value != null && (value = value.trim()).length() > 0) {
                String[] names = NAME_SEPARATOR.split(value);
                if (names.length > 1) {
                    throw new IllegalStateException("more than 1 default extension name on extension " + type.getName()
                            + ": " + Arrays.toString(names));
                }
                if (names.length == 1) cachedDefaultName = names[0];
            }
        }

        //从3个目录加载
        Map> extensionClasses = new HashMap>();
        loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);//META-INF/dubbo/internal/
        loadFile(extensionClasses, DUBBO_DIRECTORY);//META-INF/dubbo/
        loadFile(extensionClasses, SERVICES_DIRECTORY);//META-INF/services/
        return extensionClasses;
    }
    /** 从目录加载扩展实现 */
    private void loadFile(Map> extensionClasses, String dir) {
        String fileName = dir + type.getName();
        try {
            Enumeration urls;
            ClassLoader classLoader = findClassLoader();
            if (classLoader != null) {
                urls = classLoader.getResources(fileName);
            } else {
                urls = ClassLoader.getSystemResources(fileName);
            }
            if (urls != null) {
                while (urls.hasMoreElements()) {
                    java.net.URL url = urls.nextElement();
                    try {
                        BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));
                        try {
                            String line = null;
                            while ((line = reader.readLine()) != null) {
                                final int ci = line.indexOf('#');
                                if (ci >= 0) line = line.substring(0, ci);
                                line = line.trim();
                                if (line.length() > 0) {
                                    try {
                                        String name = null;
                                        int i = line.indexOf('=');
                                        if (i > 0) {
                                            // 文件采用properties方式的配置，name=实现类的全路径
                                            name = line.substring(0, i).trim();
                                            line = line.substring(i + 1).trim();
                                        }
                                        if (line.length() > 0) {
                                            Class clazz = Class.forName(line, true, classLoader);               
                                            // 必须是该扩展点的实现
                                            if (!type.isAssignableFrom(clazz)) {
                                                throw new IllegalStateException("Error when load extension class(interface: " +
                                                        type + ", class line: " + clazz.getName() + "), class "
                                                        + clazz.getName() + "is not subtype of interface.");
                                            }
                                            // 这里判断是否有自定义的适配器类，如果有，后面获取适配器的时候，就可以直接用这个创建返回，不用dubbo动态创建
                                            if (clazz.isAnnotationPresent(Adaptive.class)) {
                                                if (cachedAdaptiveClass == null) {
                                                    cachedAdaptiveClass = clazz;
                                                } else if (!cachedAdaptiveClass.equals(clazz)) {
                                                    throw new IllegalStateException("More than 1 adaptive class found: "
                                                            + cachedAdaptiveClass.getClass().getName()
                                                            + ", " + clazz.getClass().getName());
                                                }
                                            } else {
                                                try {
                                                    // 这里处理的是，实现类的包裹类，必须是构造器注入扩展点，这里后期获取具体扩展点的实现类时，会使用包裹类封装下
                                                    clazz.getConstructor(type);
                                                    Set> wrappers = cachedWrapperClasses;
                                                    if (wrappers == null) {
                                                        cachedWrapperClasses = new ConcurrentHashSet>();
                                                        wrappers = cachedWrapperClasses;
                                                    }
                                                    wrappers.add(clazz);
                                                } catch (NoSuchMethodException e) { 
                                                    // 处理不是包裹类的情况
                                                    clazz.getConstructor();
                                                    if (name == null || name.length() == 0) {
                                                        name = findAnnotationName(clazz);
                                                        if (name == null || name.length() == 0) {
                                                            if (clazz.getSimpleName().length() > type.getSimpleName().length()
                                                                    && clazz.getSimpleName().endsWith(type.getSimpleName())) {
                                                                name = clazz.getSimpleName().substring(0, clazz.getSimpleName().length() - type.getSimpleName().length()).toLowerCase();
                                                            } else {
                                                                throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + url);
                                                            }
                                                        }
                                                    }
                                                    String[] names = NAME_SEPARATOR.split(name);
                                                    if (names != null && names.length > 0) {
                                                        // 判断下Activate注解，后面讲，这里只需要知道，会缓存Activate注解的实现
                                                        Activate activate = clazz.getAnnotation(Activate.class);
                                                        if (activate != null) {
                                                            cachedActivates.put(names[0], activate);
                                                        }
                                                        for (String n : names) {
                                                            if (!cachedNames.containsKey(clazz)) {
                                                                cachedNames.put(clazz, n);
                                                            }
                                                            Class c = extensionClasses.get(n);
                                                            if (c == null) {
                                                                // 缓存扩展实现
                                                                extensionClasses.put(n, clazz);
                                                            } else if (c != clazz) {
                                                                throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    } catch (Throwable t) {
                                        IllegalStateException e = new IllegalStateException("Failed to load extension class(interface: " + type + ", class line: " + line + ") in " + url + ", cause: " + t.getMessage(), t);
                                        exceptions.put(line, e);
                                    }
                                }
                            } // end of while read lines
                        } finally {
                            reader.close();
                        }
                    } catch (Throwable t) {
                        logger.error("Exception when load extension class(interface: " +
                                type + ", class file: " + url + ") in " + url, t);
                    }
                } // end of while urls
            }
        } catch (Throwable t) {
            logger.error("Exception when load extension class(interface: " +
                    type + ", description file: " + fileName + ").", t);
        }
    }
    /** Dubbo生成适配类 */
    private Class createAdaptiveExtensionClass() {
        // 动态生成适配器代码
        String code = createAdaptiveExtensionClassCode();
        ClassLoader classLoader = findClassLoader();
        // 动态编译生成适配器类
        com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        return compiler.compile(code, classLoader);
    }

createAdaptiveExtensionClassCode方法生成扩展接口的适配： 
1. 解析Adpative注解，从url或扩展接口获取扩展接口实现类的名称； 
2. 根据名称，获取实现类ExtensionLoader.getExtensionLoader(扩展接口类).getExtension(扩展接口实现类名称)，然后调用实现类的方法。

createAdaptiveExtensionClassCode生成适配器代码，可以自己debug看看。主要是处理Adpative注解在方法上的方式，（需要明白一点dubbo的内部传参基本上都是基于Url来实现的，例如注册服务的地址，订阅服务的地址啊什么的都是一串url）：

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

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Adaptive {

    /**
     * 从{@link URL}的Key名，对应的Value作为要Adapt成的Extension名。
     * 

     * 如果{@link URL}这些Key都没有Value，使用 用 缺省的扩展（在接口的{@link SPI}中设定的值）。

     * 比如，String[] {"key1", "key2"}，表示
     * 
    
     * 
  1. 先在URL上找key1的Value作为要Adapt成的Extension名；
     * 
  2. key1没有Value，则使用key2的Value作为要Adapt成的Extension名。
     * 
  3. key2没有Value，使用缺省的扩展。
     * 
  4. 如果没有设定缺省扩展，则方法调用会抛出{@link IllegalStateException}。
     * 

     * 

     * 如果不设置则缺省使用Extension接口类名的点分隔小写字串。

     * 即对于Extension接口{@code com.alibaba.dubbo.xxx.YyyInvokerWrapper}的缺省值为String[] {"yyy.invoker.wrapper"}
     *
     * @see SPI#value()
     */
    String[] value() default {};

}

这里给出2个适配生成的代码，体会下。

  • protocol协议
@SPI("dubbo")
public interface Protocol {

    int getDefaultPort();

    @Adaptive
     Exporter export(Invoker invoker) throws RpcException;

    @Adaptive
     Invoker refer(Class type, URL url) throws RpcException;

    void destroy();
}

生成的代码：

package com.alibaba.dubbo.rpc;

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

public class Protocol$Adpative implements com.alibaba.dubbo.rpc.Protocol {

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

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

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

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

    @Adaptive(Constants.VALIDATION_KEY)
    Validator getValidator(URL url);

}

生成的代码：

package com.alibaba.dubbo.validation;

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

public class Validation$Adpative implements com.alibaba.dubbo.validation.Validation {

  public com.alibaba.dubbo.validation.Validator getValidator(com.alibaba.dubbo.common.URL arg0) {
    if (arg0 == null) {
      throw new IllegalArgumentException("url == null");
    }
    com.alibaba.dubbo.common.URL url = arg0;
    String extName = url.getParameter("validation", "jvalidation");
    if (extName == null) {
      throw new IllegalStateException(
          "Fail to get extension(com.alibaba.dubbo.validation.Validation) name from url(" + url
              .toString() + ") use keys([validation])");
    }
    com.alibaba.dubbo.validation.Validation extension = (com.alibaba.dubbo.validation.Validation) ExtensionLoader
        .getExtensionLoader(com.alibaba.dubbo.validation.Validation.class).getExtension(extName);
    return extension.getValidator(arg0);
  }
}

injectExtension

    /** 插入该扩展需要其他扩展或bean */
    private T injectExtension(T instance) {
        try {
            // objectFactory也是一个扩展点，在new ExtensionLoader的时候创建
            if (objectFactory != null) {
                for (Method method : instance.getClass().getMethods()) {
                    // 必须是set方法注入
                    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) : "";
                            // objectFactory获取扩展点或bean注入到当前扩展点
                            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;
    }

这里的objectFactory.getExtension(pt, property)，objectFactory（ExtensionFactory）在new ExtensionLoader时会创建

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

看下ExtensionFactory这个扩展点。 

Dubbo源码分析（三）：ExtensionLoader_第1张图片

注解Adpative加载AdaptiveExtensionFactory类上表示这是个自定义的适配器类，有2个实现类，一个是Spi（从dubbo 的扩展中获取），一个spring（获取spring的bean），AdaptiveExtensionFactory轮询这2个，从一个中获取到就返回。

getActivateExtension

getActivateExtension方法基本都会传入url作为参数，用法是获取激活条件的所有扩展点实现类。例如：获取当前消费端所有的filter。

这里用到了另一个注解Activate:

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Activate {
    /**
     * Group过滤条件。
     * 

     * 包含{@link ExtensionLoader#getActivateExtension}的group参数给的值，则返回扩展。
     * 

     * 如没有Group设置，则不过滤。
     */
    String[] group() default {};

    /**
     * Key过滤条件。包含{@link ExtensionLoader#getActivateExtension}的URL的参数Key中有，则返回扩展。
     * 

     * 示例：

     * 注解的值 @Activate("cache,validatioin")，
     * 则{@link ExtensionLoader#getActivateExtension}的URL的参数有cacheKey，或是validatioin则返回扩展。
     * 

     * 如没有设置，则不过滤。
     */
    String[] value() default {};

    /**
     * 排序信息，可以不提供。
     */
    String[] before() default {};

    /**
     * 排序信息，可以不提供。
     */
    String[] after() default {};

    /**
     * 排序信息，可以不提供。
     */
    int order() default 0;
}

group基本表示用在服务端还是消费端，value表示激活这个扩展点的条件，before、after、order用于排序。

    /**获取满足激活条件的扩展实现*/
    public List getActivateExtension(URL url, String[] values, String group) {
        List exts = new ArrayList();
        List names = values == null ? new ArrayList(0) : Arrays.asList(values);
        if (!names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) {
            // 加载扩展
            getExtensionClasses();
            // 上一步会缓存所有Active注解的实现类到cachedActivates
            for (Map.Entry entry : cachedActivates.entrySet()) {
                String name = entry.getKey();
                Activate activate = entry.getValue();
                // 匹配group，provider还是consumer
                if (isMatchGroup(group, activate.group())) {
                    // 获取扩展实现类
                    T ext = getExtension(name);
                    // isActive匹配激活条件
                    if (!names.contains(name)
                            && !names.contains(Constants.REMOVE_VALUE_PREFIX + name)
                            && isActive(activate, url)) {
                        exts.add(ext);
                    }
                }
            }
            // 这里会重新排序，用到Active里面before、after和order
            Collections.sort(exts, ActivateComparator.COMPARATOR);
        }
        List usrs = new ArrayList();
        for (int i = 0; i < names.size(); i++) {
            String name = names.get(i);
            if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX)
                    && !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) {
                if (Constants.DEFAULT_KEY.equals(name)) {
                    if (usrs.size() > 0) {
                        exts.addAll(0, usrs);
                        usrs.clear();
                    }
                } else {
                    T ext = getExtension(name);
                    usrs.add(ext);
                }
            }
        }
        if (usrs.size() > 0) {
            exts.addAll(usrs);
        }
        return exts;
    }

isMatchGroup：

/** group匹配，provider还是consumer端 */
private boolean isMatchGroup(String group, String[] groups) {
    // group没有，那就是不管Active是provider还是consumer端的都可以
    if (group == null || group.length() == 0) {
        return true;
    }
    // Active的注解group值，必须配置，不配置，那就都不能使用，配置后匹配
    if (groups != null && groups.length > 0) {
        for (String g : groups) {
            if (group.equals(g)) {
                return true;
            }
        }
    }
    return false;
}

isActive:

    /** Activate激活条件匹配 */
    private boolean isActive(Activate activate, URL url) {
        String[] keys = activate.value();
        // 如果Active注解的value为null，那就表示不需要条件都可以使用
        if (keys == null || keys.length == 0) {
            return true;
        }
        // value不为null，那就跟url里面的参数匹配下
        for (String key : keys) {
            for (Map.Entry entry : url.getParameters().entrySet()) {
                String k = entry.getKey();
                String v = entry.getValue();
                if ((k.equals(key) || k.endsWith("." + key))
                        && ConfigUtils.isNotEmpty(v)) {
                    return true;
                }
            }
        }
        return false;
    }

getExtension

生成的适配器类和getActiveExtension里面都有getExtension方法，用于获取扩展的实现类。

/** 根据名称获取扩展 */
public T getExtension(String name) {
    if (name == null || name.length() == 0)
        throw new IllegalArgumentException("Extension name == null");
    // 如果为名称为true，则获取默认    
    if ("true".equals(name)) {
        return getDefaultExtension();
    }
    // 实例会缓存，所以先从缓存取
    Holder holder = cachedInstances.get(name);
    if (holder == null) {
        cachedInstances.putIfAbsent(name, new Holder());
        holder = cachedInstances.get(name);
    }
    Object instance = holder.get();
    if (instance == null) {
        synchronized (holder) {
            instance = holder.get();
            if (instance == null) {
                //没有就创建一个并放到缓存中
                instance = createExtension(name);
                holder.set(instance);
            }
        }
    }
    return (T) instance;
}


createExtension


/** 创建扩展点实例 */
private T createExtension(String name) {
    Class clazz = getExtensionClasses().get(name);
    if (clazz == null) {
        throw findException(name);
    }
    try {
        T instance = (T) EXTENSION_INSTANCES.get(clazz);
        if (instance == null) {
            EXTENSION_INSTANCES.putIfAbsent(clazz, (T) clazz.newInstance());
            instance = (T) EXTENSION_INSTANCES.get(clazz);
        }
        //注入其他扩展点或bean
        injectExtension(instance);
        //包裹类封装
        Set> wrapperClasses = cachedWrapperClasses;
        if (wrapperClasses != null && wrapperClasses.size() > 0) {
            for (Class wrapperClass : wrapperClasses) {
                instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
            }
        }
        return instance;
    } catch (Throwable t) {
        throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
                type + ")  could not be instantiated: " + t.getMessage(), t);
    }
}



2种自定义扩展实现


在上一个dmeo的新建spi module。


Dubbo源码分析（三）：ExtensionLoader_第2张图片



Dubbo提供Adpative动态适配


扩展点1，DirExtension.java


@SPI("dirDefault")
public interface DirExtension {

    @Adaptive({SpiConstants.DIR_DEFAULT, SpiConstants.DIR_FIRST})
    String sayHello(URL url, String name);
}



2个扩展点实现 
 DirExtensionDefaultImpl.java


public class DirExtensionDefaultImpl implements DirExtension {

    @Override
    public String sayHello(URL url, String name) {
        return name + "-defualt";
    }
}


    

  • DirExtensionFirstImpl.java
    • 



public class DirExtensionFirstImpl implements DirExtension {

    @Override
    public String sayHello(URL url, String name) {
        return name + "-first";
    }
}


    

  • 常量类SpiConstants.java
    • 



public class SpiConstants {

    public static final String DIR_DEFAULT = "dirDefault";

    public static final String DIR_FIRST = "dirFirst";

    public static final String DIR2_DEFAULT = "dir2Default";

    public static final String DIR2_FIRST = "dir2First";

}


    

  • 配置的扩展点com.qbb.spi.DirExtension
    • 



dirDefault=com.qbb.spi.DirExtensionDefaultImpl
dirFirst=com.qbb.spi.DirExtensionFirstImpl


    

  • 测试类DirExtensionTest.java：
    • 



public class DirExtensionTest {

    public static void main(String[] args){
        ExtensionLoader extensionLoader = ExtensionLoader.getExtensionLoader(DirExtension.class);
        //DirExtension dirExtension = (DirExtension)extensionLoader.getExtension("dirFirst");
        DirExtension dirExtension = (DirExtension)extensionLoader.getAdaptiveExtension();

        Map parameters = new HashMap();
        //parameters.put("dirFirst", "dirFirst");
        parameters.put("dirDefault", "dirDefault");

        URL url = new URL("dubbo", "127.0.0.1", 8089, parameters);

        System.out.println(dirExtension.sayHello(url, "qbb"));
    }
}


    

  • 自定义Adpative适配
    • 



扩展点2，Dir2Extension.java


@SPI("dir2Default")
public interface Dir2Extension {

    String sayHello(String name, String type);
}


    

  • 2个扩展点2的实现 
     Dir2ExtensionDefaultImpl.java
    • 



public class Dir2ExtensionDefaultImpl implements Dir2Extension {

    @Override
    public String sayHello(String name, String type) {
        return "dir2Extension-" + name + "-default";
    }
}


    

  • Dir2ExtensionFirstImpl.java
    • 



public class Dir2ExtensionFirstImpl implements Dir2Extension {

    @Override
    public String sayHello(String name, String type) {
        return "dir2Extension-" + name + "-first";
    }
}


    

  • 自定义Adpative 
     Dir2ExtensionAdaptive.java
    • 



@Adaptive
public class Dir2ExtensionAdaptive implements Dir2Extension{


    @Override
    public String sayHello(String name, String type) {
        ExtensionLoader extensionLoader = ExtensionLoader.getExtensionLoader(Dir2Extension.class);
        Dir2Extension dir2Extension = (Dir2Extension)extensionLoader.getDefaultExtension();

        if (type != null && SpiConstants.DIR2_FIRST.equalsIgnoreCase(type.trim())) {
            dir2Extension = (Dir2ExtensionDefaultImpl)extensionLoader.getExtension(SpiConstants.DIR2_FIRST);
        }

        return dir2Extension.sayHello(name, type);
    }

}


    

  • 扩展点2的配置
    • 



adaptive=com.qbb.spi2.Dir2ExtensionAdaptive
dir2Default=com.qbb.spi2.Dir2ExtensionDefaultImpl
dir2First=com.qbb.spi2.Dir2ExtensionFirstImpl


    

  • 测试类 
     Dir2ExtensionTest.java
    • 



public class Dir2ExtensionTest {

    public static void main(String[] args){
        ExtensionLoader extensionLoader = ExtensionLoader.getExtensionLoader(Dir2Extension.class);
        Dir2Extension dirExtension = (Dir2Extension)extensionLoader.getAdaptiveExtension();

        String type = null;

        //type = SpiConstants.DIR2_DEFAULT;
        //type = SpiConstants.DIR2_FIRST;

        System.out.println(dirExtension.sayHello("qbb2", type));
    }
}












转载于:https://my.oschina.net/jzgycq/blog/1589772

























你可能感兴趣的:(Dubbo源码分析（三）：ExtensionLoader)






    

  • 铭刻于星（四十二）
随风至

    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    

    • 

  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
造命者说

    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    

    • 

  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断
尐尐呅

    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    

    • 

  • 《策划经理回忆录之二》
路基雅虎

    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
    

    • 

  • 三大师传
beca酱

    巴尔扎克的作品被誉为“法国社会的一面镜子”。文学大师维克多·雨果对巴尔扎克的评价是：“在最伟大的人物中间，巴尔扎克是名列前茅者；在最优秀的人物中间，巴尔扎克是佼佼者之一。”一个原本寂寂无名的小人物，从地中海的某个海岛上，只身一人来到巴黎，没有朋友，也没有名望。作为一个一文不名的外乡人，凭着赤手空拳赢得了巴黎，征服了整个法兰西，并且赢得了世界。这个人就是十九世纪法国伟大的军事家、政治家，法兰西第一帝
    

    • 

  • 开心
蒋泳频

    从无比抗拒来上课到接受，感动，收获～看着波哥成长，晶晶幸福笑容满面。感觉自己做的事情很有意义，很开心！还有3个感召目标就是还有三个有缘人，哈哈。明天感召去明日计划：8：30-11：00小公益11：00-21点上班，感召图片发自App图片发自App图片发自App
    

    • 

  • 《大清方方案》| 第二话
谁佐清欢

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

    • 

  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言

    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    

    • 

  • Google earth studio 简介
陟彼高冈yu
旅游

    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
    

    • 

  • 谁家酒器最绝唱，藏在酒厂人未知？景阳冈酒厂先秦藏品大揭秘
李虓酒评论

    文/王赛时中国的酒器酒具历史久远，举世闻名。从北京的故宫博物院、中国国家博物馆，到世界各国的大型博物馆，都以能够收藏中国古代酒具而夸耀。但很少有人知道，在山东阳谷景阳冈酒厂，默默地收藏了两千件中国酒器。这些酒器，就封藏在景阳冈的酒道馆里。其中有一些青铜酒器，一睡就是三、四千年，堪称无声国宝，堪作无字史书！今天，我将引领诸位首先窥视一下景阳冈酒道馆的9件先秦藏品，你自己来说震撼不震撼。提示：这只是景
    

    • 

  • 我的黑历史
袖手围观有来有去

    孩子同学与我们一起共进晚餐，俩孩子加我三个人。小同学是一个大方率性礼貌的小孩，我们也都非常喜欢。好了，回到正题上来让我把这个故事讲完。俩孩子都喜欢吃鱼，所以就发生了小孩子之间常会发生的事。我狠狠的盯了我家孩子，孩子表情有些狼狈。和孩子单独一起的时候，见她尚未释怀，并谴责我不该狠盯她，让她没面子。也许是她触动了我的童年往事吧。由此，一狠心，给她讲了一段埋藏心里极深的黑历史：我奶奶有四个儿子，四个儿子
    

    • 

  • 关于提高复杂业务逻辑代码可读性的思考
编程经验分享
开发经验java数据库开发语言

    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
    

    • 

  • 直返最高等级与直返APP：无需邀请码的返利新体验
古楼

    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
    

    • 

  • 如果做到轻松在股市赚钱？只要坚持这三个原则。
履霜之人

    大A股里向来就有七亏二平一赚的说法，能赚钱的都是少数人。否则股市就成了慈善机构，人人都有钱赚，谁还要上班？所以说亏钱是正常的，或者说是应该的。那么那些赚钱的人又是如何做到的呢？普通人能不能找到捷径去分一杯羹呢？方法是有的，但要做到需要你有极高的自律。第一，控制仓位，散户最大的问题是追涨杀跌，只要涨起来，就把钱往股票上砸，然后被套，隔天跌的受不了，又一刀切，全部割肉。来来回回间，遍体鳞伤。所以散户首
    

    • 

  • 《人世间》
南询yi

    今日分享十点推文，《人世间》有感苏格拉底说：“天地只有三尺，而人在五尺开外，所以人人都要懂得低头。”深以为然。懂得低头，不是认输。而是于人世间找寻温存的成熟，于困境中寻觅柳暗花明的智慧，于争执中展示屈伸自如的格局。正如仰头不是骄傲，是要看见自己的天空；低头也不是认输，而是要看清自己的路。成大事者，不仅要抬头挺胸，还得低头看路。懂得低头，进退有度，不是认输，而是竭尽全力过好这一生。宫崎骏说过：“所有
    

    • 

  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业

    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    

    • 

  • 运城寻访重逢石头纪实【严建设老照片395 集】 我简直能把你想透， 当我走进运城的时候。 我已急得热汗直流， 访问了十九个老头， 把晋南的小城转了三周。 虽然是悠久的思旧， 我仍然是牛样的执...
严建设

    运城寻访重逢石头纪实【严建设老照片395集】我简直能把你想透，当我走进运城的时候。我已急得热汗直流，访问了十九个老头，把晋南的小城转了三周。虽然是悠久的思旧，我仍然是牛样的执拗。说什么变换的世情，泛起了过去的逝流，你就是真正的故友。踏破铁鞋的淡愁，已化为不废功夫的范畴，是就像远在天涯近在咫尺，就像是梦乡的邂逅，我紧紧地攥着你的手。你已长成了高高的个头，俊逸的容颜却很清瘦，你那样顽皮的童音，已变到老
    

    • 

  • 勇士赢了，我把掌声给了骑士
复角度的生活

    今天，不参加高考，只看NBA总决赛第三场的较量。这么说有点得罪高考生了，不过我没有当他们面秀，也没有跑到考点外面得瑟，所以我内心毫无波澜。毫无疑问，考场里不乏骑士和勇士球迷，在紧张作答语文考卷同时还心系着球队，不过我希望今天的比赛不会让你们有所分心，毕竟高考不会像比赛录像那样可以再来。今天，好像起来赶考一样，我起得很早，然而事实是睡不着，挺郁闷的，又不是我高考，我紧张什么？九点我并没有准时打开浏览
    

    • 

  • 东南林氏之九牧林候选父系
祖缘树TheYtree

    渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
    

    • 

  • 把握“三度”打造“三有”干部队伍
辛德瑞拉卡卡卡

    “胜败兴亡之分，不得不归咎于人事也”。干部队伍建设工作的好坏，关系到党和国家的发展全局。近日，新疆维吾尔自治区党委书记马兴瑞在部分党群单位走访调研时强调，要努力培养造就忠诚干净担当的高素质专业化干部队伍。各级组织部门应当在培养选拔干部、吸收优秀青年到党内来、培养造就优秀人才上下功夫，切实增强干部投身实践、解决问题、推进工作的能力，着力打造高素质专业化干部队伍。“天生我材必有用”，增强选育有“准度”
    

    • 

  • 【JS】执行时长(100分) |思路参考+代码解析（C++）
l939035548
JS算法数据结构c++

    题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
    

    • 

  • 人工智能时代，程序员如何保持核心竞争力？
jmoych
人工智能

    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
    

    • 

  • Python快速入门 —— 第三节：类与对象
孤华暗香
Python快速入门python开发语言

    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
    

    • 

  • 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
    

    • 

  • ARM中断处理过程
落汤老狗
嵌入式linux

    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
    

    • 

  • node.js学习
小猿L
node.jsnode.js学习vim

    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    

    • 

  • 心有蓝天白云，爱情便会晴空万里，然后有花香有鸟鸣有美好的未来
曹十二吖

    丁南的婚姻，来自于一场她对生命的对比。她曾经说过，当她最爱的母亲用生命去逼迫她结婚的时候，她曾一度不理解到愤怒，甚至于想过用轻生来对抗母亲的不理智。庆幸的是，丁南是一个自我调节能力非常强的人，她想如果我连死亡都不怕，还怕不能经营好一段婚姻吗？抱着这样的念头，24年没有谈过恋爱的她，用短短三个月的时间，完成了少女到女人的蜕变。她曾经说过：“我要把自己最珍贵的东西留给自己命中注定的那个人。”闺蜜几人中
    

    • 

  • 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//三
    

    • 

  • 多线程编程之理财
周凡杨
java多线程生产者消费者理财

          现实生活中，我们一边工作，一边消费，正常情况下会把多余的钱存起来，比如存到余额宝，还可以多挣点钱，现在就有这个情况：我每月可以发工资20000万元 （暂定每月的1号），每月消费5000（租房+生活费）元（暂定每月的1号），其中租金是大头占90%，交房租的方式可以选择（一月一交，两月一交、三月一交），理财：1万元存余额宝一天可以赚1元钱，
    

    • 

  • [Zookeeper学习笔记之三]Zookeeper会话超时机制
bit1129
zookeeper

    首先，会话超时是由Zookeeper服务端通知客户端会话已经超时，客户端不能自行决定会话已经超时，不过客户端可以通过调用Zookeeper.close()主动的发起会话结束请求，如下的代码输出内容
Created /zoo-739160015
CONNECTEDCONNECTED
.............CONNECTEDCONNECTED
CONNECTEDCLOSEDCLOSED

    

    • 

  • SecureCRT快捷键
daizj
secureCRT快捷键

    ctrl + a : 移动光标到行首ctrl + e ：移动光标到行尾crtl + b: 光标前移1个字符crtl + f: 光标后移1个字符crtl + h : 删除光标之前的一个字符ctrl + d ：删除光标之后的一个字符crtl + k ：删除光标到行尾所有字符crtl + u : 删除光标至行首所有字符crtl + w:  删除光标至行首
    

    • 

  • Java 子类与父类这间的转换
周凡杨
java 父类与子类的转换

        最近同事调的一个服务报错，查看后是日期之间转换出的问题。代码里是把 java.sql.Date 类型的对象 强制转换为 java.sql.Timestamp 类型的对象。报java.lang.ClassCastException。
 
    代码：
            
    

    • 

  • 可视化swing界面编辑
朱辉辉33
eclipseswing

          今天发现了一个WindowBuilder插件，功能好强大，啊哈哈，从此告别手动编辑swing界面代码，直接像VB那样编辑界面，代码会自动生成。
      首先在Eclipse中点击help，选择Install New Software,然后在Work with中输入WindowBui
    

    • 

  • web报表工具FineReport常用函数的用法总结（文本函数）
老A不折腾
finereportweb报表工具报表软件java报表

    文本函数
CHAR
CHAR(number):根据指定数字返回对应的字符。CHAR函数可将计算机其他类型的数字代码转换为字符。
Number:用于指定字符的数字，介于1Number:用于指定字符的数字，介于165535之间（包括1和65535）。
示例:
CHAR(88)等于“X”。
CHAR(45)等于“-”。
 
CODE
CODE(text):计算文本串中第一个字
    

    • 

  • mysql安装出错
林鹤霄
mysql安装

    [root@localhost ~]# rpm -ivh MySQL-server-5.5.24-1.linux2.6.x86_64.rpm Preparing...                #####################
    

    • 

  • linux下编译libuv
aigo
libuv

    下载最新版本的libuv源码，解压后执行：
./autogen.sh
 
这时会提醒找不到automake命令，通过一下命令执行安装（redhat系用yum，Debian系用apt-get）：
# yum -y install automake
# yum -y install libtool
 
 
如果提示错误：make: *** No targe
    

    • 

  • 中国行政区数据及三级联动菜单
alxw4616

    近期做项目需要三级联动菜单,上网查了半天竟然没有发现一个能直接用的!
呵呵,都要自己填数据....我了个去这东西麻烦就麻烦的数据上.
哎,自己没办法动手写吧.
现将这些数据共享出了,以方便大家.嗯,代码也可以直接使用
  文件说明
lib\area.sql -- 县及县以上行政区划分代码（截止2013年8月31日)来源：国家统计局 发布时间：2014-01-17 15:0
    

    • 

  • 哈夫曼加密文件
百合不是茶
哈夫曼压缩哈夫曼加密二叉树

     在上一篇介绍过哈夫曼编码的基础知识,下面就直接介绍使用哈夫曼编码怎么来做文件加密或者压缩与解压的软件,对于新手来是有点难度的,主要还是要理清楚步骤;
 
加密步骤:
 1,统计文件中字节出现的次数,作为权值
 
2,创建节点和哈夫曼树
 
3,得到每个子节点01串
 
4,使用哈夫曼编码表示每个字节
 

    

    • 

  • JDK1.5 Cyclicbarrier实例
bijian1013
javathreadjava多线程Cyclicbarrier

    CyclicBarrier类
一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。
CyclicBarrier支持一个可选的 Runnable 命令，
    

    • 

  • 九项重要的职业规划
bijian1013
工作学习

    一. 学习的步伐不停止        古人说，活到老，学到老。终身学习应该是您的座右铭。        世界在不断变化，每个人都在寻找各自的事业途径。        您只有保证了足够的技能储
    

    • 

  • 【Java范型四】范型方法
bit1129
java

    范型参数不仅仅可以用于类型的声明上，例如
 
package com.tom.lang.generics;
import java.util.List;
public class Generics<T> {
private T value;
public Generics(T value) {
this.value = 
    

    • 

  • 【Hadoop十三】HDFS Java API基本操作
bit1129
hadoop

     
package com.examples.hadoop;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoo
    

    • 

  • ua实现split字符串分隔
ronin47
lua split

    LUA并不象其它许多"大而全"的语言那样，包括很多功能，比如网络通讯、图形界面等。但是LUA可以很容易地被扩展：由宿主语言(通常是C或 C++)提供这些功能，LUA可以使用它们，就像是本来就内置的功能一样。LUA只包括一个精简的核心和最基本的库。这使得LUA体积小、启动速度快，从 而适合嵌入在别的程序里。因此在lua中并没有其他语言那样多的系统函数。习惯了其他语言的字符串分割函
    

    • 

  • java-从先序遍历和中序遍历重建二叉树
bylijinnan
java

    
public class BuildTreePreOrderInOrder {
/**
* Build Binary Tree from PreOrder and InOrder
* _______7______
/ \
__10__ ___2
/ \ /
4
    

    • 

  • openfire开发指南《连接和登陆》
开窍的石头
openfire开发指南smack

    第一步
    官网下载smack.jar包
    下载地址：http://www.igniterealtime.org/downloads/index.jsp#smack
第二步
    把smack里边的jar导入你新建的java项目中
开始编写smack连接openfire代码
p
    

    • 

  • [移动通讯]手机后盖应该按需要能够随时开启
comsci
移动

        看到新的手机，很多由金属材质做的外壳，内存和闪存容量越来越大，CPU速度越来越快，对于这些改进，我们非常高兴，也非常欢迎
     但是，对于手机的新设计，有几点我们也要注意
     第一：手机的后盖应该能够被用户自行取下来，手机的电池的可更换性应该是必须保留的设计,
    

    • 

  • 20款国外知名的php开源cms系统
cuiyadll
cms

    内容管理系统，简称CMS，是一种简易的发布和管理新闻的程序。用户可以在后端管理系统中发布，编辑和删除文章，即使您不需要懂得HTML和其他脚本语言，这就是CMS的优点。
在这里我决定介绍20款目前国外市面上最流行的开源的PHP内容管理系统，以便没有PHP知识的读者也可以通过国外内容管理系统建立自己的网站。
1. Wordpress
WordPress的是一个功能强大且易于使用的内容管
    

    • 

  • Java生成全局唯一标识符
darrenzhu
javauuiduniqueidentifierid

    How to generate a globally unique identifier in Java
http://stackoverflow.com/questions/21536572/generate-unique-id-in-java-to-label-groups-of-related-entries-in-a-log
http://stackoverflow
    

    • 

  • php安装模块检测是否已安装过, 使用的SQL语句
dcj3sjt126com
sql

    
SHOW [FULL] TABLES [FROM db_name] [LIKE 'pattern']
SHOW TABLES列举了给定数据库中的非TEMPORARY表。您也可以使用mysqlshow db_name命令得到此清单。
本命令也列举数据库中的其它视图。支持FULL修改符，这样SHOW FULL TABLES就可以显示第二个输出列。对于一个表，第二列的值为BASE T
    

    • 

  • 5天学会一种 web 开发框架
dcj3sjt126com
Web框架framework

    web framework层出不穷，特别是ruby/python,各有10+个,php/java也是一大堆 根据我自己的经验写了一个to do list,按照这个清单，一条一条的学习，事半功倍，很快就能掌握 一共25条，即便很磨蹭，2小时也能搞定一条，25*2=50。只需要50小时就能掌握任意一种web框架
各类web框架大同小异:现代web开发框架的6大元素，把握主线，就不会迷路
建议把本文
    

    • 

  • Gson使用三(Map集合的处理,一对多处理)
eksliang
jsongsonGson mapGson 集合处理

    转载请出自出处：http://eksliang.iteye.com/blog/2175532 一、概述
       Map保存的是键值对的形式，Json的格式也是键值对的，所以正常情况下，map跟json之间的转换应当是理所当然的事情。 二、Map参考实例
package com.ickes.json;
import java.lang.refl
    

    • 

  • cordova实现“再点击一次退出”效果
gundumw100
android

    基本的写法如下：
document.addEventListener("deviceready", onDeviceReady, false);
function onDeviceReady() {
//navigator.splashscreen.hide();
document.addEventListener("b
    

    • 

  • openldap configuration leaning note
iwindyforest
configuration

    hostname // to display the computer name
hostname <changed name> // to change
go to: /etc/sysconfig/network, add/modify HOSTNAME=NEWNAME to change permenately
dont forget to change /etc/hosts
    

    • 

  • Nullability and Objective-C
啸笑天
Objective-C

    https://developer.apple.com/swift/blog/?id=25
 
http://www.cocoachina.com/ios/20150601/11989.html
 
http://blog.csdn.net/zhangao0086/article/details/44409913
 
http://blog.sunnyxx
    

    • 

  • jsp中实现参数隐藏的两种方法
macroli
JavaScriptjsp

    在一个JSP页面有一个链接，//确定是一个链接?点击弹出一个页面，需要传给这个页面一些参数。//正常的方法是设置弹出页面的src="***.do?p1=aaa&p2=bbb&p3=ccc"//确定目标URL是Action来处理?但是这样会在页面上看到传过来的参数，可能会不安全。要求实现src="***.do"，参数通过其他方法传！//////
    

    • 

  • Bootstrap A标签关闭modal并打开新的链接解决方案
qiaolevip
每天进步一点点学习永无止境bootstrap纵观千象

    Bootstrap里面的js modal控件使用起来很方便，关闭也很简单。只需添加标签 data-dismiss="modal" 即可。
可是偏偏有时候需要a标签既要关闭modal，有要打开新的链接，尝试多种方法未果。只好使用原始js来控制。
 
<a href="#/group-buy" class="btn bt
    

    • 

  • 二维数组在Java和C中的区别
流淚的芥末
javac二维数组数组

    Java代码：
 
public class test03 {
public static void main(String[] args) {
int[][] a = {{1},{2,3},{4,5,6}};
System.out.println(a[0][1]);
}
}
 运行结果：
Exception in thread "mai
    

    • 

  • systemctl命令用法
wmlJava
linuxsystemctl

    对比表，以 apache / httpd 为例 任务 旧指令 新指令 使某服务自动启动 chkconfig --level 3 httpd on systemctl enable httpd.service 使某服务不自动启动 chkconfig --level 3 httpd off systemctl disable httpd.service 检查服务状态 service h
    

    •