weixin_34122548
weixin_34122548

dubbo源码分析系列——dubbo的SPI机制源码分析

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

dubbo的SPI机制

关于dubbo的SPI机制请参阅dubbo开发者文档 -> http://dubbo.io/Developer+Guide-zh.htm#DeveloperGuide-zh-%E6%89%A9%E5%B1%95%E7%82%B9%E5%8A%A0%E8%BD%BD

我只把我自己理解的SPI与大家分享一下：

SPI是面向dubbo开发者角色的扩展接口，开发者可以通过它来扩展dubbo的功能和技术实现。相对而言API是面向dubbo使用者角色编程接口。

SPI解决的是扩展内容配置和动态加载的问题。在java中解决相同或者类似问题的技术有OSGI，JDK自带的SPI，以及IOC框架Spring也能够解决类似的问题，各种解决方案各有特点，我们不展开讲。而dubbo的SPI是从JDK标准的SPI(Service Provider Interface)扩展点发现机制加强而来，它做了如下改进：（这些内容引用自dubbo官方开发者手册）

  • JDK标准的SPI会一次性实例化扩展点所有实现，如果有扩展实现初始化很耗时，但如果没用上也加载，会很浪费资源。
  • 如果扩展点加载失败，连扩展点的名称都拿不到了。比如：JDK标准的ScriptEngine，通过getName();获取脚本类型的名称，但如果RubyScriptEngine因为所依赖的jruby.jar不存在，导致RubyScriptEngine类加载失败，这个失败原因被吃掉了，和ruby对应不起来，当用户执行ruby脚本时，会报不支持ruby，而不是真正失败的原因。
  • 增加了对扩展点IoC和AOP的支持，一个扩展点可以直接setter注入其它扩展点。

那么dubbo的SPI是如何实现的呢？让我们直接看源码一探究竟，SPI的源码位于工程dubbo-common的包com.alibaba.dubbo.common.extension下。

dubbo的SPI源码实现分析

ExtensionLoader

该类是dubbo的SPI机制实现的最为核心的一个类，绝大多数实现逻辑均位于该类中，因此我们从该类入手研究。为了简化，该类是一个将使用api及核心逻辑实现都封装同一个类中。通常获得一个扩展接口的实例使用如下接口方法获得。

ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(DubboProtocol.NAME);

静态工厂方法getExtensionLoader

该方法是一个静态工厂方法，是一个编程api，通过该方法获得一个某个参数制定的扩展类的ExtensionLoader对象。

    private static  boolean withExtensionAnnotation(Class type) {
        return type.isAnnotationPresent(SPI.class);
    }
   
    @SuppressWarnings("unchecked")
    public static  ExtensionLoader getExtensionLoader(Class type) {
        if (type == null)
            throw new IllegalArgumentException("Extension type == null");
        if(!type.isInterface()) {
            throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
        }
        if(!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type(" + type + 
                    ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
        }
        
        ExtensionLoader loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        if (loader == null) {
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
            loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

从看源码我们得出几个结论。

  1. dubbo的SPI扩展点必须是接口。
  2. dubbo的SPI扩展点接口必须用注解SPI标注。
  3. 某个扩展点的ExtensionLoader是获取的时候延迟生成，并且会进行缓存。

获得扩展实例方法getExtension

 /**
     * 返回指定名字的扩展。如果指定名字的扩展不存在，则抛异常 {@link IllegalStateException}.
     *
     * @param name
     * @return
     */
	@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;
	} 
   
     
    
  1. 扩展点名称不能空，否则抛出异常。
    2.  
    
  2. 扩展点名称传入true则表示获取默认扩展点实例。
    3.  
    
  3. 扩展点支持缓存，说明扩展点对象在SPI容器中单例的，需要考虑线程安全。
    4.  
    
  4. 扩展点对象生成时延迟创建的，实现了对jdk的spi的改进。
    5.  
   
 
    
   
获取默认扩展对象方法getDefaultExtension
 
   
/**
	 * 返回缺省的扩展，如果没有设置则返回null。 
	 */
	public T getDefaultExtension() {
	    getExtensionClasses();
        if(null == cachedDefaultName || cachedDefaultName.length() == 0
                || "true".equals(cachedDefaultName)) {
            return null;
        }
        return getExtension(cachedDefaultName);
	}


 
   
获得默认的扩展对象，属性cachedDefaultName的值并不是参数传递进来的，它是在方法获得扩展类getExtensionClasses()中赋值的。稍后我们一起看看该方法的实现。如果没有加载到默认的扩展点实现，则返回null。
 
   
创建某种扩展对象方法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);
            }
            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);
        }
    }
    
 
   
     
    
  1. 根据扩展名称获得扩展实现类。先会调用方法getExtensionClasses加载扩展类列表，然后获取指定名称对应的扩展类。
    2.  
    
  2. 若找不到扩展类则抛出异常。
    3.  
    
  3. 从扩展实例缓存中找到该扩展类的实例。若找到则直接返回。
    4.  
    
  4. 若未找到缓存对象则产生新对象。调用的方法是clazz.newInstance())。
    5.  
    
  5. 给扩展实例执行依赖注入。调用了方法injectExtension，从而实现了对jdk的spi机制的ioc和aop功能扩展。
    6.  
   
 
    
   
获取扩展实现类方法getExtensionClasse()
 
   
该方法实现了获取某个名称扩展点的实现类，该方法是被几乎所有的方法调用之前先调用该方法，实现了扩展实现类的加载。
 
   
private Class getExtensionClass(String name) {
	    if (type == null)
	        throw new IllegalArgumentException("Extension type == null");
	    if (name == null)
	        throw new IllegalArgumentException("Extension name == null");
	    Class clazz = getExtensionClasses().get(name);
	    if (clazz == null)
	        throw new IllegalStateException("No such extension \"" + name + "\" for " + type.getName() + "!");
	    return clazz;
	}


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

 // 此方法已经getExtensionClasses方法同步过。
    private Map> loadExtensionClasses() {
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if(defaultAnnotation != null) {
            String value = defaultAnnotation.value();
            if(value != null && (value = value.trim()).length() > 0) {
                String[] names = NAME_SEPARATOR.split(value);
                if(names.length > 1) {
                    throw new IllegalStateException("more than 1 default extension name on extension " + type.getName()
                            + ": " + Arrays.toString(names));
                }
                if(names.length == 1) cachedDefaultName = names[0];
            }
        }
        
        Map> extensionClasses = new HashMap>();
        loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
        loadFile(extensionClasses, DUBBO_DIRECTORY);
        loadFile(extensionClasses, SERVICES_DIRECTORY);
        return extensionClasses;
    }


   private void loadFile(Map> extensionClasses, String dir) {
        String fileName = dir + type.getName();
        try {
            Enumeration urls;
            ClassLoader classLoader = findClassLoader();
            if (classLoader != null) {
                urls = classLoader.getResources(fileName);
            } else {
                urls = ClassLoader.getSystemResources(fileName);
            }
            if (urls != null) {
                while (urls.hasMoreElements()) {
                    java.net.URL url = urls.nextElement();
                    try {
                        BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));
                        try {
                            String line = null;
                            while ((line = reader.readLine()) != null) {
                                final int ci = line.indexOf('#');
                                if (ci >= 0) line = line.substring(0, ci);
                                line = line.trim();
                                if (line.length() > 0) {
                                    try {
                                        String name = null;
                                        int i = line.indexOf('=');
                                        if (i > 0) {
                                            name = line.substring(0, i).trim();
                                            line = line.substring(i + 1).trim();
                                        }
                                        if (line.length() > 0) {
                                            Class clazz = Class.forName(line, true, classLoader);
                                            if (! type.isAssignableFrom(clazz)) {
                                                throw new IllegalStateException("Error when load extension class(interface: " +
                                                        type + ", class line: " + clazz.getName() + "), class " 
                                                        + clazz.getName() + "is not subtype of interface.");
                                            }
                                            if (clazz.isAnnotationPresent(Adaptive.class)) {
                                                if(cachedAdaptiveClass == null) {
                                                    cachedAdaptiveClass = clazz;
                                                } else if (! cachedAdaptiveClass.equals(clazz)) {
                                                    throw new IllegalStateException("More than 1 adaptive class found: "
                                                            + cachedAdaptiveClass.getClass().getName()
                                                            + ", " + clazz.getClass().getName());
                                                }
                                            } else {
                                                try {
                                                    clazz.getConstructor(type);
                                                    Set> wrappers = cachedWrapperClasses;
                                                    if (wrappers == null) {
                                                        cachedWrapperClasses = new ConcurrentHashSet>();
                                                        wrappers = cachedWrapperClasses;
                                                    }
                                                    wrappers.add(clazz);
                                                } catch (NoSuchMethodException e) {
                                                    clazz.getConstructor();
                                                    if (name == null || name.length() == 0) {
                                                        name = findAnnotationName(clazz);
                                                        if (name == null || name.length() == 0) {
                                                            if (clazz.getSimpleName().length() > type.getSimpleName().length()
                                                                    && clazz.getSimpleName().endsWith(type.getSimpleName())) {
                                                                name = clazz.getSimpleName().substring(0, clazz.getSimpleName().length() - type.getSimpleName().length()).toLowerCase();
                                                            } else {
                                                                throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + url);
                                                            }
                                                        }
                                                    }
                                                    String[] names = NAME_SEPARATOR.split(name);
                                                    if (names != null && names.length > 0) {
                                                        Activate activate = clazz.getAnnotation(Activate.class);
                                                        if (activate != null) {
                                                            cachedActivates.put(names[0], activate);
                                                        }
                                                        for (String n : names) {
                                                            if (! cachedNames.containsKey(clazz)) {
                                                                cachedNames.put(clazz, n);
                                                            }
                                                            Class c = extensionClasses.get(n);
                                                            if (c == null) {
                                                                extensionClasses.put(n, clazz);
                                                            } else if (c != clazz) {
                                                                throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    } catch (Throwable t) {
                                        IllegalStateException e = new IllegalStateException("Failed to load extension class(interface: " + type + ", class line: " + line + ") in " + url + ", cause: " + t.getMessage(), t);
                                        exceptions.put(line, e);
                                    }
                                }
                            } // end of while read lines
                        } finally {
                            reader.close();
                        }
                    } catch (Throwable t) {
                        logger.error("Exception when load extension class(interface: " +
                                            type + ", class file: " + url + ") in " + url, t);
                    }
                } // end of while urls
            }
        } catch (Throwable t) {
            logger.error("Exception when load extension class(interface: " +
                    type + ", description file: " + fileName + ").", t);
        }
    }
 
   
     
    
  1. 先从加载的缓冲中获取扩展点实现类对象。若获取到则直接返回，否则需要加载。
    2.  
    
  2. 缓存有击穿的风险。即当扩展点无实现类的情况下会每次都进行扩展点记载，该操作是非常耗时的操作，因此要避免这种情况。
    3.  
    
  3. 加载扩展点实现类。通过调用方法loadExtensionClasses实现。
    4.  
    
  4. 扩展点接口上的SPI注解可以指定默认的扩展点名称。而且只能设置一个默认扩展点，不允许多个。这个很好理解。代码可以看出此时会将SPI注解的value值赋值给属性cachedDefaultName。
    5.  
    
  5. 扫描classpath下的三个目录加载SPI配置信息。分别类路径下的：META-INF/services/、META-INF/dubbo/ 和 META-INF/dubbo/internal/，加载顺序与该顺序正好相反，META-INF/dubbo/internal/ 最早开始加载。
    6.  
    
  6. 加载类路径下所有SPI配置文件。文件命名是：目录名+{扩展接口的类名}，比如扩展接口Protocol则文件名为："META-INF/dubbo/com.alibaba.dubbo.rpc.Protocol"。加载这些配置文件中的内容。
    7.  
    
  7. 逐行读取配置文件中的内容。
    8.  
    
  8. 配置文件支持'#'后面的均为注视，可以忽略。
    9.  
    
  9. 配置文件类似properties文件格式。内容格式是： {name}={className}。其中等号左边是扩展点实现名称，右边是扩展点实现的全局类名，需要包含在类路径中，否则类加载会抛出异常。可以写多行，每行表示一个实现类。
    10.  
    
  10. 找到类名后会使用当前的classloader加载该类。若加载失败则会记录异常。
    11.  
    
  11. 检查该扩展实现类的合法性。该类必须是扩展接口类的实现类。若不是则会抛出异常。
    12.  
    
  12. 检查扩展实现类是否为Adaptive标注类。如果是注解Adaptive标注的类（在类上注解，方法注解不算），则会将改类赋值给cachedAdaptiveClass类，表示该类为一个适配器类，然后退出。
    13.  
    
  13. 否则尝试获取包含参数为type的构造函数。如果有包含参数为type的构造函数，则说明该实现类是一个包装器类，会将cachedWrapperClasses的属性设置为该值，然后退出。
    14.  
    
  14. 否则继续获得无参构造函数。尝试获取无参数构造函数，若无则会抛出异常。
    15.  
    
  15. 检查扩展类名称。如果没有名称则会尝试自动生成，即若扩展点定义为com.alibaba.dubbo.rpc.Protocol，则扩展类名必须为com.alibaba.dubbo.rpc.XxxProtocol的才可以生成，自动生成的名称为xxx。即将前缀替换为小写。否则会抛出异常。
    16.  
    
  16. 扩展名称支持多个。名称如果是以','隔开，则表示名称是多个，多个名称都会被记录下来，引用相同的扩展实现类。
    17.  
    
  17. 如果扩展类有Activate注解，则会将注解实例activate放入集合属性cachedActivates中。
    18.  
    
  18. 将扩展实现的名称和类分别放入缓存中。以备后续使用。
    19.  
   
 
    
   
获得自适应扩展getAdaptiveExtension
 
   
ExtensionLoader注入的依赖扩展点是一个Adaptive实例，直到扩展点方法执行时才决定调用是一个扩展点实现。
 
   
Dubbo使用URL对象（包含了Key-Value）传递配置信息。
 
   
扩展点方法调用会有URL参数（或是参数有URL成员）
 
   
这样依赖的扩展点也可以从URL拿到配置信息，所有的扩展点自己定好配置的Key后，配置信息从URL上从最外层传入。URL在配置传递上即是一条总线。
 
   
本方法实现了这一特性。
 
   
 @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;
    }

 @SuppressWarnings("unchecked")
    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);
        }
    }

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


  private Class createAdaptiveExtensionClass() {
        String code = createAdaptiveExtensionClassCode();
        ClassLoader classLoader = findClassLoader();
        com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        return compiler.compile(code, classLoader);
    }


 private String createAdaptiveExtensionClassCode() {
        StringBuilder codeBuidler = new StringBuilder();
        Method[] methods = type.getMethods();
        boolean hasAdaptiveAnnotation = false;
        for(Method m : methods) {
            if(m.isAnnotationPresent(Adaptive.class)) {
                hasAdaptiveAnnotation = true;
                break;
            }
        }
        // 完全没有Adaptive方法，则不需要生成Adaptive类
        if(! hasAdaptiveAnnotation)
            throw new IllegalStateException("No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");
        
        codeBuidler.append("package " + type.getPackage().getName() + ";");
        codeBuidler.append("\nimport " + ExtensionLoader.class.getName() + ";");
        codeBuidler.append("\npublic class " + type.getSimpleName() + "$Adpative" + " implements " + type.getCanonicalName() + " {");
        
        for (Method method : methods) {
            Class rt = method.getReturnType();
            Class[] pts = method.getParameterTypes();
            Class[] ets = method.getExceptionTypes();

            Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
            StringBuilder code = new StringBuilder(512);
            if (adaptiveAnnotation == null) {
                code.append("throw new UnsupportedOperationException(\"method ")
                        .append(method.toString()).append(" of interface ")
                        .append(type.getName()).append(" is not adaptive method!\");");
            } else {
                int urlTypeIndex = -1;
                for (int i = 0; i < pts.length; ++i) {
                    if (pts[i].equals(URL.class)) {
                        urlTypeIndex = i;
                        break;
                    }
                }
                // 有类型为URL的参数
                if (urlTypeIndex != -1) {
                    // Null Point check
                    String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"url == null\");",
                                    urlTypeIndex);
                    code.append(s);
                    
                    s = String.format("\n%s url = arg%d;", URL.class.getName(), urlTypeIndex); 
                    code.append(s);
                }
                // 参数没有URL类型
                else {
                    String attribMethod = null;
                    
                    // 找到参数的URL属性
                    LBL_PTS:
                    for (int i = 0; i < pts.length; ++i) {
                        Method[] ms = pts[i].getMethods();
                        for (Method m : ms) {
                            String name = m.getName();
                            if ((name.startsWith("get") || name.length() > 3)
                                    && Modifier.isPublic(m.getModifiers())
                                    && !Modifier.isStatic(m.getModifiers())
                                    && m.getParameterTypes().length == 0
                                    && m.getReturnType() == URL.class) {
                                urlTypeIndex = i;
                                attribMethod = name;
                                break LBL_PTS;
                            }
                        }
                    }
                    if(attribMethod == null) {
                        throw new IllegalStateException("fail to create adative class for interface " + type.getName()
                        		+ ": not found url parameter or url attribute in parameters of method " + method.getName());
                    }
                    
                    // Null point check
                    String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"%s argument == null\");",
                                    urlTypeIndex, pts[urlTypeIndex].getName());
                    code.append(s);
                    s = String.format("\nif (arg%d.%s() == null) throw new IllegalArgumentException(\"%s argument %s() == null\");",
                                    urlTypeIndex, attribMethod, pts[urlTypeIndex].getName(), attribMethod);
                    code.append(s);

                    s = String.format("%s url = arg%d.%s();",URL.class.getName(), urlTypeIndex, attribMethod); 
                    code.append(s);
                }
                
                String[] value = adaptiveAnnotation.value();
                // 没有设置Key，则使用“扩展点接口名的点分隔 作为Key
                if(value.length == 0) {
                    char[] charArray = type.getSimpleName().toCharArray();
                    StringBuilder sb = new StringBuilder(128);
                    for (int i = 0; i < charArray.length; i++) {
                        if(Character.isUpperCase(charArray[i])) {
                            if(i != 0) {
                                sb.append(".");
                            }
                            sb.append(Character.toLowerCase(charArray[i]));
                        }
                        else {
                            sb.append(charArray[i]);
                        }
                    }
                    value = new String[] {sb.toString()};
                }
                
                boolean hasInvocation = false;
                for (int i = 0; i < pts.length; ++i) {
                    if (pts[i].getName().equals("com.alibaba.dubbo.rpc.Invocation")) {
                        // Null Point check
                        String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"invocation == null\");", i);
                        code.append(s);
                        s = String.format("\nString methodName = arg%d.getMethodName();", i); 
                        code.append(s);
                        hasInvocation = true;
                        break;
                    }
                }
                
                String defaultExtName = cachedDefaultName;
                String getNameCode = null;
                for (int i = value.length - 1; i >= 0; --i) {
                    if(i == value.length - 1) {
                        if(null != defaultExtName) {
                            if(!"protocol".equals(value[i]))
                                if (hasInvocation) 
                                    getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
                                else
                                    getNameCode = String.format("url.getParameter(\"%s\", \"%s\")", value[i], defaultExtName);
                            else
                                getNameCode = String.format("( url.getProtocol() == null ? \"%s\" : url.getProtocol() )", defaultExtName);
                        }
                        else {
                            if(!"protocol".equals(value[i]))
                                if (hasInvocation) 
                                    getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
                                else
                                    getNameCode = String.format("url.getParameter(\"%s\")", value[i]);
                            else
                                getNameCode = "url.getProtocol()";
                        }
                    }
                    else {
                        if(!"protocol".equals(value[i]))
                            if (hasInvocation) 
                                getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
                            else
                                getNameCode = String.format("url.getParameter(\"%s\", %s)", value[i], getNameCode);
                        else
                            getNameCode = String.format("url.getProtocol() == null ? (%s) : url.getProtocol()", getNameCode);
                    }
                }
                code.append("\nString extName = ").append(getNameCode).append(";");
                // check extName == null?
                String s = String.format("\nif(extName == null) " +
                		"throw new IllegalStateException(\"Fail to get extension(%s) name from url(\" + url.toString() + \") use keys(%s)\");",
                        type.getName(), Arrays.toString(value));
                code.append(s);
                
                s = String.format("\n%s extension = (% 0) {
                    codeBuidler.append(", ");
                }
                codeBuidler.append(pts[i].getCanonicalName());
                codeBuidler.append(" ");
                codeBuidler.append("arg" + i);
            }
            codeBuidler.append(")");
            if (ets.length > 0) {
                codeBuidler.append(" throws ");
                for (int i = 0; i < ets.length; i ++) {
                    if (i > 0) {
                        codeBuidler.append(", ");
                    }
                    codeBuidler.append(ets[i].getCanonicalName());
                }
            }
            codeBuidler.append(" {");
            codeBuidler.append(code.toString());
            codeBuidler.append("\n}");
        }
        codeBuidler.append("\n}");
        if (logger.isDebugEnabled()) {
            logger.debug(codeBuidler.toString());
        }
        return codeBuidler.toString();
    }
 
   
     
    
  1. 先从缓存中获得扩展点适配实例。如果有则直接获得，否则需要创建。
    2.  
    
  2. 若有类通过属性cachedAdaptiveClass的类创建。否则需要获取类。
    3.  
    
  3. 如果获取类失败，则需要调用方法createAdaptiveExtensionClass动态创建适配器类。
    4.  
    
  4. 如果扩展点类type没有方法被注解Adaptive注释过，则无需创建适配器类，则抛出异常。
    5.  
    
  5. 动态生成一个适配器实现类。生成的类名是： type.getSimpleName() + "$Adpative"。
    6.  
    
  6. 生成的类要实现每一个type中包含Adaptive注释过方法。若没有则该方法被抛出不支持的异常。
    7.  
    
  7. 实现包含Adaptive注释过方法。先通过type参数类型为URL或者getXXX返回值为URL的获得url对象值。并且会检查url值是否为空，如果为空则会抛出异常。
    8.  
    
  8. 若方法上的Adaptive注解的value是空，则使用“扩展点接口名的点分隔" 作为Key。
    9.  
    
  9. 以value作为key，从url对象中获得值，然后将获得的值调用方法getExtension获得扩展点实现对象。这样就实现了动态注入扩展实现。
    10.  
   
 
   
相关内容的进一步分析请参考另外一篇文章：http://my.oschina.net/ywbrj042/blog/688042
 
    
   
获得自动激活扩展列表方法getActivateExtension
 
   
对于集合类扩展点，比如：Filter, InvokerListener, ExportListener, TelnetHandler, StatusChecker等，
 可以同时加载多个实现，此时，可以用自动激活来简化配置。本方法实现了这一特性。
 
   
 /**
     * This is equivalent to 
     *     getActivateExtension(url, key, null);
     * 

     *
     * @param url url
     * @param key url parameter key which used to get extension point names
     * @return extension list which are activated.
     * @see #getActivateExtension(com.alibaba.dubbo.common.URL, String, String)
     */
    public List getActivateExtension(URL url, String key) {
        return getActivateExtension(url, key, null);
    }

    /**
     * This is equivalent to 
     *     getActivateExtension(url, values, null);
     * 

     *
     * @see #getActivateExtension(com.alibaba.dubbo.common.URL, String[], String)
     * @param url url
     * @param values extension point names
     * @return extension list which are activated
     */
    public List getActivateExtension(URL url, String[] values) {
        return getActivateExtension(url, values, null);
    }

    /**
     * This is equivalent to 
     *     getActivateExtension(url, url.getParameter(key).split(","), null);
     * 

     *
     * @see #getActivateExtension(com.alibaba.dubbo.common.URL, String[], String)
     * @param url url
     * @param key url parameter key which used to get extension point names
     * @param group group
     * @return extension list which are activated.
     */
    public List getActivateExtension(URL url, String key, String group) {
        String value = url.getParameter(key);
        return getActivateExtension(url, value == null || value.length() == 0 ? null : Constants.COMMA_SPLIT_PATTERN.split(value), group);
    }

    /**
     * Get activate extensions.
     *
     * @see com.alibaba.dubbo.common.extension.Activate
     * @param url url
     * @param values extension point names
     * @param group group
     * @return extension list which are activated
     */
    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();
            for (Map.Entry entry : cachedActivates.entrySet()) {
                String name = entry.getKey();
                Activate activate = entry.getValue();
                if (isMatchGroup(group, activate.group())) {
                    T ext = getExtension(name);
                    if (! names.contains(name)
                            && ! names.contains(Constants.REMOVE_VALUE_PREFIX + name) 
                            && isActive(activate, url)) {
                        exts.add(ext);
                    }
                }
            }
            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;
    }

 private boolean isMatchGroup(String group, String[] groups) {
        if (group == null || group.length() == 0) {
            return true;
        }
        if (groups != null && groups.length > 0) {
            for (String g : groups) {
                if (group.equals(g)) {
                    return true;
                }
            }
        }
        return false;
    }
    
    private boolean isActive(Activate activate, URL url) {
        String[] keys = activate.value();
        if (keys == null || keys.length == 0) {
            return true;
        }
        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;
    }
 
   
源码解析：
 
   
     
    
  1. 有多个重载方法可以获得自动激活的扩展实例列表。
    2.  
    
  2. 如果values（即扩展点名称）列表中不包含默认值“-default”则开始遍历map对象cachedActivates中的所有activate。
    3.  
    
  3. 若扩展点被Activate注解标准，则检查activate中的group是否匹配，
    4.  
   
 
   
 
    
 
      
    
 
   
 
   
  
转载于:https://my.oschina.net/ywbrj042/blog/687443
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(dubbo源码分析系列——dubbo的SPI机制源码分析)

        

            

                
    
                    
  • 解决方案评测｜通义万相AI绘画创作【阿里产品系测评】
                        一键难忘
精通AI实战千例专栏合集AI作画通义万相
                        
    文章目录解决方案评测｜通义万相AI绘画创作一、活动参与及部署体验二、针对通义万相AI绘画创作方案的详细评测反馈1）资源部署及场景API调用体验过程是否得到足够的引导，操作是否顺畅？2）该方案是否满足您的需求？3）针对业务场景，该方案还有哪些可以改进的图片生成能力或在您的业务场景中，还希望它可以提供哪些新的功能？4）同比其他类似产品方案，该方案在成本、易用性、应用场景上是否有竞争力？您是否愿意推荐团
    
                    
    • 
                    
  • 回溯法-子集树递归树-装载问题
                        王安安的记录
算法回溯法c++算法
                        
    回溯法深度优先策略（回忆深度优先遍历二叉树思路）解题步骤：1)针对所给问题，定义问题的解空间；例如，n个物品的0-1背包问题所对应的解空间树是一棵子集树。2)确定易于搜索的解空间结构；3)以深度优先方式搜索解空间，并在搜索过程中用剪枝函数（****约束函数除去不满足约束的子树，限界函数减去得不到最优解的子树**）**避免无效搜索##子集树和递归树扩展结点:一个正在产生儿子的结点称为扩展结点。活结点
    
                    
    • 
                    
  • C语言--正弦、余弦函数
                        坚持学习每一天
刘汝佳--算法竞赛入门经典c语言
                        
    #include#include#includeintmain(){constdoublepi=acos(-1.0);intn;scanf("%d",&n);printf("%lf%lf",sin(n/180.0*pi),cos(n/180.0*pi));}sin()函数和cos()函数的参数是弧度原型：doublesin(doublex);doublecos(doubley);
    
                    
    • 
                    
  • Day08-综合练习
                        坚持学习每一天
Java基础java算法排序算法
                        
    importjava.util.Random;publicclasstest3{/*定义方法实现随机产生一个5位的验证码验证码格式：长度为s前四位是大写字母或者小写字母最后一位是数字*///方法：//在一堆没有什么规律的数据中随机抽取//可以先把这些数据放到数组当中//再随机抽取一个索引publicstaticvoidmain(String[]args){char[]chs=newchar[52]
    
                    
    • 
                    
  • ClickHouse 作用，优缺点。
                        mldsh13
clickhouse
                        
    ClickHouseClickHouse是一个开源的分布式列式数据库管理系统(DBMS)，专门设计用于实时分析(OLAP)。它最初由俄罗斯的Yandex开发，后来成为了开源项目，被广泛应用于需要高性能数据分析和查询的场景。作用：实时分析：ClickHouse专注于快速查询和分析大量数据，使其特别适用于数据分析、报告和实时仪表板等应用场景。大规模数据处理：能够处理海量数据，支持分布式架构，可以水平扩
    
                    
    • 
                    
  • Infor CloudSuite软件二次开发：InforCloudSuite移动应用开发
                        kkchenjj
工业软件二次开发全集架构工业软件ERP开发语言
                        
    InforCloudSuite软件二次开发：InforCloudSuite移动应用开发InforCloudSuite简介InforCloudSuite平台概述InforCloudSuite是一个集成的企业资源规划(ERP)解决方案，专为特定行业设计，提供了一系列的云应用，旨在优化业务流程，提升运营效率。该平台涵盖了供应链管理、财务、人力资源、客户关系管理等多个领域，通过其先进的功能和模块，企业可以
    
                    
    • 
                    
  • 前端开发使用的 安卓模拟器_【译】移动开发中的仿真器与模拟器
                        weixin_39976748
前端开发使用的安卓模拟器
                        
    译者注：本文主要涉及到两个概念：Emulator和Simulator。通常我们在工作中可能统统习惯称为“模拟器”，但实际上二者有所不同。为了分清概念，本文将Emulator译作“仿真器”，Simulator译作“模拟器”。听起来可能略拗口，如产生生理或心理不适，敬请谅解。仿真器(Emulator)，又称仿真程序，在软件工程中指可以使计算机或者其他多媒体平台(掌上电脑，手机)能够运行其他平台上的程序
    
                    
    • 
                    
  • Dubbo应用接入
                        weixin_34281477
javapython
                        
    2019独角兽企业重金招聘Python工程师标准>>>一、应用配置1、pom文件引入下面的jar包com.niwodai.infdubbo-cat-extend3.0.02、如果要对全局dubbo服务加监控，增加如下filter：服务提供方：服务消费方：如果只需要对单个服务加监控，增加如下filter：服务提供方：服务消费方：3、配置disconf开关，一个应用只需要配置一次。Disconf监控开
    
                    
    • 
                    
  • Docker部署SVN服务器并使用：从基础到高级
                        ivwdcwso
运维SVN代码管理运维
                        
    目录引言Docker部署SVN服务器SVN基础使用SVN高级使用最佳实践和注意事项结语1.引言Subversion(SVN)是一个开源的版本控制系统,广泛用于管理和追踪软件项目的源代码。本文将详细介绍如何使用Docker快速部署SVN服务器,以及SVN的基础和高级使用方法。无论你是SVN新手还是有经验的用户,本文都将为你提供有价值的信息。2.Docker部署SVN服务器2.1安装Docker如果你
    
                    
    • 
                    
  • React Native
                        svygh123
问题解决过程编程jsreactnativereact.jsjavascript
                        
    ReactNative是一个用于构建原生移动应用的框架，它使用JavaScript和React（一个用于构建用户界面的JavaScript库）来开发iOS和Android平台的应用程序。ReactNative由Facebook开发并维护，并且是开源的。特点跨平台开发：ReactNative允许开发者使用相同的代码库为多个平台（如iOS和Android）编写应用，极大地提高了开发效率。热重载：开发者
    
                    
    • 
                    
  • Ubuntu16.04切换内核启动
                        StruggleYouth
ubuntu系统操作
                        
    1.该命令显示内核的启动顺序zgw@zgw-ThinkPad:~$grepmenuentry/boot/grub/grub.cfgif[x"${feature_menuentry_id}"=xy];thenmenuentry_id_option="--id"menuentry_id_option=""exportmenuentry_id_optionmenuentry'Ubuntu'--class
    
                    
    • 
                    
  • Java函数式接口四部曲之Consumer
                        sundawei2016
java前端开发语言
                        
    Consumer是一个函数式接口，位于java.util.function包中。它表示一个接受单个输入参数并且不返回任何结果的操作。Consumer通常用于需要对输入参数执行某些操作但不产生返回值的场景。Consumer接口定义了一个抽象方法：accept(Tt)：接受一个类型为T的参数，并对其执行操作。Consumerdisplay=System.out::println;display.acc
    
                    
    • 
                    
  • （十六）Java-File
                        Kyrie_Li
Java体系java开发语言
                        
    File类是Java中最基础的文件处理类，它用于表示文件和目录（文件路径）。File类不能直接进行读写操作，它仅用于描述文件或目录的元数据，比如文件名、路径、大小等。一、File类的构造方法1.通过提供文件的路径字符串来创建一个File对象。路径可以是绝对路径也可以是相对路径。Filefile=newFile("D:\\test\\555.txt");2.通过父目录路径和子文件/目录路径来创建Fi
    
                    
    • 
                    
  • （六）Java-BigDecimal
                        Kyrie_Li
Java体系java开发语言
                        
    一、概述BigDecimal类用于高精度计算，特别适用于需要进行精确浮点数运算的场合，例如货币计算、金融应用或科学计算。二、优势由于double和float类型是浮点数类型，它们在表示一些十进制数时会出现精度丢失问题，而BigDecimal则可以避免这些问题，提供任意精度的数值表示。三、特点1.任意精度：BigDecimal的精度仅受限于计算机的内存，而不像float和double有固定的精度限制
    
                    
    • 
                    
  • 二叉树-将二叉树展开为链表
                        Vacant Seat
链表数据结构二叉树java
                        
    114.将二叉树展开为链表给你二叉树的根结点root，请你将它展开为一个单链表：展开后的单链表应该同样使用TreeNode，其中right子指针指向链表中下一个结点，而左子指针始终为null。展开后的单链表应该与二叉树先序遍历顺序相同。输入：二叉树的根结点输出：空？思路：前序遍历之后再赋值，左边置为空，右边为单链表中的结点使用递归classSolution{Listlist=newArrayLis
    
                    
    • 
                    
  • 回溯-全排列
                        Vacant Seat
算法java回溯
                        
    46.全排列给定一个不含重复数字的数组nums，返回其所有可能的全排列。你可以按任意顺序返回答案输入：数组输出：二维列表思路：等待二刷classSolution{List>result=newArrayListpath=newLinkedList>permute(int[]nums){intlen=nums.length;used=newboolean[len];if(len==0){return
    
                    
    • 
                    
  • Git 的详细介绍及用法
                        xluo1715
工程化git代码管理gitlab程序员
                        
    一、Git的优点分布式版本控制每个开发者都拥有完整的仓库副本，无需依赖中央服务器（如SVN）。支持离线操作（提交、查看历史、创建分支等）。高效的分支管理创建和切换分支速度快（几乎是瞬间完成）。适合多人协作开发，支持多种工作流（如GitFlow、GitHubFlow）。强大的撤销和恢复能力可以回退到任意历史版本，避免代码丢失。提供gitreset、gitrevert、gitstash等撤销工具。数据
    
                    
    • 
                    
  • PIPCA个人信息保护合规审计师认证介绍！
                        熙丫 13381482386
大数据
                        
    个人信息保护合规审计师"（PersonalInformationProtectionComplianceAuditor-CCRC）是中国网络安全审查认证中心与市场监管大数据中心为深入贯彻实施《个人信息保护法》，推动个人信息处理者切实履行合规审计职责，针对企事业单位及第三方机构中从事个人信息保护合规审计（简称“个保审计”）的专业人员，依据《个人信息保护法》、《网络安全从业人员能力基本要求》
    
                    
    • 
                    
  • doris：Elasticsearch
                        向阳1218
大数据doris
                        
    ElasticsearchCatalog除了支持自动映射ES元数据外，也可以利用Doris的分布式查询规划能力和ES(Elasticsearch)的全文检索能力相结合，提供更完善的OLAP分析场景解决方案：ES中的多index分布式Join查询。Doris和ES中的表联合查询，更复杂的全文检索过滤。使用限制支持Elasticsearch5.x及以上版本。创建CatalogCREATECATALOG
    
                    
    • 
                    
  • doris：阿里云 MaxCompute
                        向阳1218
大数据doris
                        
    MaxCompute是阿里云上的企业级SaaS（SoftwareasaService）模式云数据仓库。什么是MaxCompute连接MaxCompute示例--1.创建Catalog。CREATECATALOGmcPROPERTIES("type"="max_compute","mc.default.project"="xxx","mc.access_key"="xxxx","mc.secret_
    
                    
    • 
                    
  • MyBatis Plus 在 Java 项目中的高效使用
                        随风九天
匠心数据库javaspringjavamybatisMyBatisPlus
                        
    1.前言1.1MyBatisPlus简介MyBatisPlus是一个MyBatis的增强工具，旨在简化开发人员在数据库操作上的工作量。它提供了丰富的功能，如自动化的CRUD操作、条件构造器、分页查询等，极大地提高了开发效率。1.2为什么选择MyBatisPlus简化代码：自动生成基础的CRUD方法，减少重复代码。提高效率：内置多种插件和工具，提升开发速度。易于维护：代码结构清晰，便于后续维护和扩展
    
                    
    • 
                    
  • java--数据校验Validator
                        郑*杰
java开发语言spring
                        
    一、基于注解进行数据校验1、配置依赖java--常用依赖配置_郑*杰的博客-CSDN博客2、创建一个配置类packagecom.ruqi.aditainoal;importorg.springframework.context.annotation.Bean;importorg.springframework.context.annotation.ComponentScan;importorg.s
    
                    
    • 
                    
  • 使用 ResponseBodyEmitter 实现异步响应式数据流处理
                        随风九天
springjava多线程BodyEmitter异步响应
                        
    1.概述1.1什么是ResponseBodyEmitterResponseBodyEmitter是SpringMVC提供的一个接口，用于支持异步返回响应数据流。它允许在控制器方法中逐步发送数据给客户端，而无需一次性生成完整的响应。1.2使用场景实时数据推送（如股票行情、聊天消息等）。大量数据分批传输。服务器发送事件（SSE,Server-SentEvents）。1.3优势与局限性优势：支持异步数据
    
                    
    • 
                    
  • 掌握SQL多表连接查询_轻松处理复杂数据关系
                        随风九天
匠心数据库javasql数据库
                        
    1.引言1.1数据库中的多表关系概述在实际应用中，数据库通常由多个表组成，每个表存储不同类型的数据。例如，在一个电子商务系统中，可能会有用户表、订单表、产品表等。这些表之间存在关联关系，通过多表连接查询可以整合这些数据，提供更全面的信息。1.2多表连接查询的重要性多表连接查询是SQL中最常用和重要的操作之一。它允许我们从多个表中提取相关数据，并根据特定条件进行组合。掌握多表连接查询可以帮助我们更高
    
                    
    • 
                    
  • Apache Doris 实现毫秒级查询响应
                        随风九天
匠心数据库服务javaapacheApacheDoris
                        
    1.引言1.1数据分析的重要性随着大数据时代的到来，企业对实时数据分析的需求日益增长。快速、准确地获取数据洞察成为企业在竞争中脱颖而出的关键。传统的数据库系统在处理大规模数据时往往面临性能瓶颈，难以满足实时分析的需求。例如，一个电商公司需要实时监控销售数据以调整库存和营销策略，而传统的数据库可能需要数分钟甚至数小时才能生成报表，这显然无法满足业务需求。1.2ApacheDoris简介ApacheD
    
                    
    • 
                    
  • Flink实时流处理入门与实践
                        随风九天
springjavaFlink实时流
                        
    一、引言1.1实时流处理的重要性在当今数据驱动的时代，实时数据处理变得越来越重要。企业需要从不断产生的大量数据中快速提取有价值的信息，以支持决策制定和业务优化。实时流处理技术能够实时处理数据流，提供即时的洞察和响应，从而提高业务效率和竞争力。1.2Flink简介ApacheFlink是一个开源的分布式流处理框架，支持批处理和流处理。Flink提供了高吞吐量、低延迟和精确一次（exactly-onc
    
                    
    • 
                    
  • 一学就会的深度学习基础指令及操作步骤（6）迁移学习
                        小圆圆666
深度学习迁移学习人工智能卷积神经网络
                        
    文章目录迁移学习模型准备数据增强模型训练模型微调和预测检查预测结果迁移学习迁移学习是将一个任务中学到的知识应用到另一个相关任务上，以提高新任务的学习效率和性能。优势：节省训练时间，提高模型性能，尤其在小数据场景下效果显著。核心是利用源域的知识来帮助目标域任务，比如在ImageNet上预训练的模型用于医疗影像分类。源域（SourceDomain）：已有知识的领域（如ImageNet图像库）。目标域（
    
                    
    • 
                    
  • Unity游戏引擎
                        喜欢星期五
游戏引擎unity
                        
    在数字创意的世界里，Unity引擎以其强大的功能和灵活性，已经成为无数开发者心中构建梦想游戏的首选工具。今天，我们就来深入探讨Unity的奥秘，解锁它如何帮助我们实现那些令人惊叹的游戏项目。unity博文的概要：1.入门教程和资源分享初学者指南：这类博文为刚接触Unity的新手提供入门指导，介绍Unity界面布局、基本操作和简单的游戏开发流程。资源推荐：分享对开发者非常有帮助的Unity插件、模型
    
                    
    • 
                    
  • 通义万相2.1：AI视频生成迎来“质变”，运镜、文字、物理规律全面突破
                        that's boy
人工智能通义万象2.1chatgptopenaiqwenAI作画AI编程
                        
    AI视频生成，从“能看”到“惊艳”的跨越在人工智能的浪潮中，AI视频生成无疑是最受瞩目的领域之一。从最初的简单动画到如今的逼真模拟，AI视频生成技术正在快速发展，不断刷新人们的认知。近日，阿里云旗下通义万相视频生成模型宣布了2.1版本的重磅升级，不仅在性能上实现了全面提升，更在运镜、文字生成、物理规律模拟等方面取得了突破性进展，让AI视频生成真正进入了“质变”的新阶段。通义万相2.1的出现，不仅是
    
                    
    • 
                    
  • YOLOv8制作自己的实例分割数据集保姆级教程（包含json转txt）
                        Sir小珂
YOLOpython深度学习人工智能
                        
    1.数据准备首先对原始数据集进行整理，将标注好的图像和标签分别放在两个文件夹中，同时额外新建两个文件夹，用于存放转换完的标签与划分后的数据集。1.1将json格式文件转换为txt格式新建json2txt.py文件，将代码中的文件路径修改为自己的路径。❗❗❗代码中第43行的classes中存放的是自己数据集的分类标签，记得修改成自己的。importjsonimportosfromtqdmimport
    
                    
    • 
                                
  • ASM系列六 利用TreeApi 添加和移除类成员
                                    lijingyao8206
jvm动态代理ASM字节码技术TreeAPI
                                    
        同生成的做法一样，添加和移除类成员只要去修改fields和methods中的元素即可。这里我们拿一个简单的类做例子，下面这个Task类，我们来移除isNeedRemove方法，并且添加一个int 类型的addedField属性。 
  
package asm.core;

/**
 * Created by yunshen.ljy on 2015/6/
    
                                
    • 
                                
  • Springmvc-权限设计
                                    bee1314
springWebjsp
                                    
     
 万丈高楼平地起。 
 
权限管理对于管理系统而言已经是标配中的标配了吧，对于我等俗人更是不能免俗。同时就目前的项目状况而言，我们还不需要那么高大上的开源的解决方案，如Spring Security，Shiro。小伙伴一致决定我们还是从基本的功能迭代起来吧。 
目标：  
1.实现权限的管理（CRUD）
2.实现部门管理 （CRUD)
3.实现人员的管理 （CRUD）
4.实现部门和权限
    
                                
    • 
                                
  • 算法竞赛入门经典（第二版）第2章习题
                                    CrazyMizzz
c算法
                                    
    2.4.1 输出技巧 
#include <stdio.h> 
 
int 
main() 
{ 
 int i, n; 
 
 scanf("%d", &n); 
 for (i = 1; i <= n; i++) 
 printf("%d\n", i); 
 return 0; 
} 
 
习题2-2 水仙花数(daffodil
    
                                
    • 
                                
  • struts2中jsp自动跳转到Action
                                    麦田的设计者
jspwebxmlstruts2自动跳转
                                    
    1、在struts2的开发中，经常需要用户点击网页后就直接跳转到一个Action，执行Action里面的方法，利用mvc分层思想执行相应操作在界面上得到动态数据。毕竟用户不可能在地址栏里输入一个Action（不是专业人士） 
  
2、＜jsp:forward page="xxx.action" /＞ ，这个标签可以实现跳转，page的路径是相对地址,不同与jsp和j
    
                                
    • 
                                
  • php 操作webservice实例
                                    IT独行者
PHPwebservice
                                    
    首先大家要简单了解了何谓webservice，接下来就做两个非常简单的例子，webservice还是逃不开server端与client端。我测试的环境为：apache2.2.11 php5.2.10做这个测试之前，要确认你的php配置文件中已经将soap扩展打开，即extension=php_soap.dll; 
OK 现在我们来体验webservice 
//server端 serve
    
                                
    • 
                                
  • Windows下使用Vagrant安装linux系统
                                    _wy_
windowsvagrant
                                    
    准备工作： 
下载安装 VirtualBox ：https://www.virtualbox.org/ 
下载安装 Vagrant ：http://www.vagrantup.com/ 
下载需要使用的 box ： 
官方提供的范例：http://files.vagrantup.com/precise32.box 
还可以在 http://www.vagrantbox.es/ 
    
                                
    • 
                                
  • 更改linux的文件拥有者及用户组(chown和chgrp)
                                    无量
clinuxchgrpchown
                                    
    本文（转）  
http://blog.163.com/yanenshun@126/blog/static/128388169201203011157308/   
http://ydlmlh.iteye.com/blog/1435157   
一、基本使用：    
使用chown命令可以修改文件或目录所属的用户： 
       命令
    
                                
    • 
                                
  • linux下抓包工具
                                    矮蛋蛋
linux
                                    
    原文地址： 
http://blog.chinaunix.net/uid-23670869-id-2610683.html 
tcpdump -nn -vv -X udp port 8888 
上面命令是抓取udp包、端口为8888 
netstat -tln 命令是用来查看linux的端口使用情况 
 
13 . 列出所有的网络连接 
lsof -i 
14. 列出所有tcp 网络连接信息 
l
    
                                
    • 
                                
  • 我觉得mybatis是垃圾！：“每一个用mybatis的男纸，你伤不起”
                                    alafqq
mybatis
                                    
    最近看了  
每一个用mybatis的男纸，你伤不起 
原文地址 ：http://www.iteye.com/topic/1073938 
发表一下个人看法。欢迎大神拍砖； 
 
个人一直使用的是Ibatis框架，公司对其进行过小小的改良； 
最近换了公司，要使用新的框架。听说mybatis不错；就对其进行了部分的研究； 
 
发现多了一个mapper层；个人感觉就是个dao； 
 
 
    
                                
    • 
                                
  • 解决java数据交换之谜
                                    百合不是茶
数据交换
                                    
    交换两个数字的方法有以下三种  ，其中第一种最常用
 
  
/*
输出最小的一个数
*/
public class jiaohuan1 {

	public static void main(String[] args) {
	int a =4;
	int b = 3;
		if(a<b){
         //  第一种交换方式
		int tmep =
    
                                
    • 
                                
  • 渐变显示
                                    bijian1013
JavaScript
                                    
    <style type="text/css">
 #wxf {
  FILTER: progid:DXImageTransform.Microsoft.Gradient(GradientType=0, StartColorStr=#ffffff, EndColorStr=#97FF98);
  height: 25px;
 }
</style>
    
                                
    • 
                                
  • 探索JUnit4扩展：断言语法assertThat
                                    bijian1013
java单元测试assertThat
                                    
    一.概述 
        JUnit 设计的目的就是有效地抓住编程人员写代码的意图，然后快速检查他们的代码是否与他们的意图相匹配。 JUnit 发展至今，版本不停的翻新，但是所有版本都一致致力于解决一个问题，那就是如何发现编程人员的代码意图，并且如何使得编程人员更加容易地表达他们的代码意图。JUnit 4.4 也是为了如何能够
    
                                
    • 
                                
  • 【Gson三】Gson解析{"data":{"IM":["MSN","QQ","Gtalk"]}}
                                    bit1129
gson
                                    
       
如何把如下简单的JSON字符串反序列化为Java的POJO对象? 
{"data":{"IM":["MSN","QQ","Gtalk"]}} 
  
下面的POJO类Model无法完成正确的解析： 
  
import com.google.gson.Gson;
    
                                
    • 
                                
  • 【Kafka九】Kafka High Level API vs. Low Level API
                                    bit1129
kafka
                                    
    1. Kafka提供了两种Consumer API 
 
 High Level Consumer API 
 Low Level Consumer API(Kafka诡异的称之为Simple Consumer API，实际上非常复杂) 
 
在选用哪种Consumer API时，首先要弄清楚这两种API的工作原理，能做什么不能做什么，能做的话怎么做的以及用的时候，有哪些可能的问题 
 
    
                                
    • 
                                
  • 在nginx中集成lua脚本：添加自定义Http头，封IP等
                                    ronin47
nginx lua
                                    
    Lua是一个可以嵌入到Nginx配置文件中的动态脚本语言，从而可以在Nginx请求处理的任何阶段执行各种Lua代码。刚开始我们只是用Lua 把请求路由到后端服务器，但是它对我们架构的作用超出了我们的预期。下面就讲讲我们所做的工作。 强制搜索引擎只索引mixlr.com 
Google把子域名当作完全独立的网站，我们不希望爬虫抓取子域名的页面，降低我们的Page rank。 
location /{
    
                                
    • 
                                
  • java-归并排序
                                    bylijinnan
java
                                    
    
import java.util.Arrays;


public class MergeSort {

	
	public static void main(String[] args) {

		int[] a={20,1,3,8,5,9,4,25};
		mergeSort(a,0,a.length-1);
		System.out.println(Arrays.to
    
                                
    • 
                                
  • Netty源码学习-CompositeChannelBuffer
                                    bylijinnan
javanetty
                                    
    CompositeChannelBuffer体现了Netty的“Transparent Zero Copy” 
 
查看API（ 
http://docs.jboss.org/netty/3.2/api/org/jboss/netty/buffer/package-summary.html#package_description） 
可以看到，所谓“Transparent Zero Copy”是通
    
                                
    • 
                                
  • Android中给Activity添加返回键
                                    hotsunshine
Activity
                                    
           
// this need android:minSdkVersion="11"
 getActionBar().setDisplayHomeAsUpEnabled(true);
 
 
 
   
 @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        
    
                                
    • 
                                
  • 静态页面传参
                                    ctrain
静态
                                    
    
$(document).ready(function () {
	var request = {
		QueryString :
		function (val) {
			var uri = window.location.search;
			var re = new RegExp("" + val + "=([^&?]*)", &
    
                                
    • 
                                
  • Windows中查找某个目录下的所有文件中包含某个字符串的命令
                                    daizj
windows查找某个目录下的所有文件包含某个字符串
                                    
    findstr可以完成这个工作。 
     
[html]  
view plain 
copy       
 
 >findstr /s /i "string" *.*   
  
上面的命令表示，当前目录以及当前目录的所有子目录下的所有文件中查找"string&qu
    
                                
    • 
                                
  • 改善程序代码质量的一些技巧
                                    dcj3sjt126com
编程PHP重构
                                    
    有很多理由都能说明为什么我们应该写出清晰、可读性好的程序。最重要的一点，程序你只写一次，但以后会无数次的阅读。当你第二天回头来看你的代码 时，你就要开始阅读它了。当你把代码拿给其他人看时，他必须阅读你的代码。因此，在编写时多花一点时间，你会在阅读它时节省大量的时间。让我们看一些基本的编程技巧：    尽量保持方法简短    尽管很多人都遵
    
                                
    • 
                                
  • SharedPreferences对数据的存储
                                    dcj3sjt126com

                                    
    SharedPreferences简介：                                                   &nbs
    
                                
    • 
                                
  • linux复习笔记之bash shell (2) bash基础
                                    eksliang
bashbash shell
                                    
    转载请出自出处：
http://eksliang.iteye.com/blog/2104329  
1.影响显示结果的语系变量（locale） 
 1.1locale这个命令就是查看当前系统支持多少种语系，命令使用如下： 
[root@localhost shell]# locale
LANG=en_US.UTF-8
LC_CTYPE="en_US.UTF-8"

    
                                
    • 
                                
  • Android零碎知识总结
                                    gqdy365
android
                                    
    1、CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。所以在多线程操作时不会出现java.util.ConcurrentModificationException错误。 
所以最后得出结论：CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。发生修改时候做copy，新老版本分离，保证读的高
    
                                
    • 
                                
  • HoverTree.Model.ArticleSelect类的作用
                                    hvt
Web.netC#hovertreeasp.net
                                    
    ArticleSelect类在命名空间HoverTree.Model中可以认为是文章查询条件类，用于存放查询文章时的条件，例如HvtId就是文章的id。HvtIsShow就是文章的显示属性，当为-1是，该条件不产生作用，当为0时，查询不公开显示的文章，当为1时查询公开显示的文章。HvtIsHome则为是否在首页显示。HoverTree系统源码完全开放，开发环境为Visual Studio 2013
    
                                
    • 
                                
  • PHP 判断是否使用代理 PHP Proxy Detector
                                    天梯梦
proxy
                                    
    1. php 类 
I found this class looking for something else actually but I remembered I needed some while ago something similar and I never found one. I'm sure it will help a lot of developers who try to 
    
                                
    • 
                                
  • apache的math库中的回归——regression（翻译）
                                    lvdccyb
Mathapache
                                    
    这个Math库，虽然不向weka那样专业的ML库，但是用户友好，易用。 
多元线性回归，协方差和相关性（皮尔逊和斯皮尔曼），分布测试（假设检验，t，卡方，G），统计。 
  
数学库中还包含，Cholesky，LU，SVD，QR，特征根分解，真不错。 
  
基本覆盖了：线代，统计，矩阵， 
最优化理论 
曲线拟合 
常微分方程 
遗传算法（GA）， 
还有3维的运算。。。 

    
                                
    • 
                                
  • 基础数据结构和算法十三：Undirected Graphs (2)
                                    sunwinner
Algorithm
                                    
      
Design pattern for graph processing.  
Since we consider a large number of graph-processing algorithms, our initial design goal is to decouple our implementations from the graph representation
    
                                
    • 
                                
  • 云计算平台最重要的五项技术
                                    sumapp
云计算云平台智城云
                                    
    云计算平台最重要的五项技术 
 
 
 
1、云服务器 
 
 
云服务器提供简单高效，处理能力可弹性伸缩的计算服务，支持国内领先的云计算技术和大规模分布存储技术，使您的系统更稳定、数据更安全、传输更快速、部署更灵活。 
 
 
特性 
 
机型丰富 
 
通过高性能服务器虚拟化为云服务器，提供丰富配置类型虚拟机，极大简化数据存储、数据库搭建、web服务器搭建等工作； 
 
仅需要几分钟，根据CP
    
                                
    • 
                                
  • 《京东技术解密》有奖试读获奖名单公布
                                    ITeye管理员
活动
                                    
    ITeye携手博文视点举办的12月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。  
 
 
12月试读活动回顾： 
http://webmaster.iteye.com/blog/2164754 
 
 
本次技术图书试读活动获奖名单及相应作品如下： 
 
 
一等奖（两名） 
 
 
 Microhardest：http://microhardest.ite
    
                                
    •