yulewo123
yulewo123

dubbo源码分析 SPI机制、provider、consume启动与consume调用provider流程

1.dubbo spi机制

以dubbo源码的dubbo-demo-provider为例说明

dubbo-demo-provider.xml内容如下

spring容器启动，会去解析自定义的标签，dubbo的标签定义都在DubboNamespaceHandler内，具体解析就不说了，这个看过spring源码的都知道，不知道也没关系，不影响理解dubbo，下面说下每个dubbo标签的功能

创建ApplicationConfig，保存配置上的值到ApplicationConfig属性上。

创建RegistryConfig，保存配置上的值到RegistryConfig属性上。

创建ProtocolConfig，保存配置上的值到ProtocolConfig属性上

创建ServiceBean，保存配置上的值到ServiceBean属性上，该类和spring紧密联系，它实现了spring bean的初始化接口InitializingBean，销毁接口DisposableBean，感知接口ApplicationContextAware、BeanNameAware，监听器接口ApplicationListener，这里不讲spring的启动流程，看我其它spring启动流程图，就可以看出这些spring接口的功能。

这些都是bean，都是单例对象存在于spring IOC容器内，那么既然是bean，就有bean的初始化、创建了。

对于ServiceBean，由于实现了InitializingBean、ApplicationContextAware、BeanNameAware、ApplicationListener，那么在spring对该bean启动过程会有一些特殊操作，按照该bean的创建执行顺序分别是：

step1：ServiceBean.setBeanName(String) 设置bean名称，实现了BeanNameAware可以自定义名称，这里名称就是interface属性值，在DubboBeanDefinitionParser解析的时候获取的。
step2：ServiceBean.setApplicationContext(ApplicationContext)，吧IOC容器对象保存到ServiceBean属性内，同时该方法也把监听器ServiceBean添加到IOC容器的监听器集合中。
step3：ServiceBean.afterPropertiesSet()初始化步骤，服务暴露在该方法内执行。
step4：ServiceBean.onApplicationEvent(ContextRefreshedEvent)，spring IOC启动后执行监听器调用这里，如果dubbo服务没有被暴露，则暴露服务。

加载ServiceBean肯定是在创建ServiceBean之前进行的，该类有2个重要属性，分别是父类ServiceConfig中的

private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
private static final ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();

搞清楚这两个属性，那么对于dubbo的启动就比较容易明白了。

先看private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();属性在加载的时候赋值过程，这个执行还有点绕，当时看的时候不下画图了，结果被绕晕了，贴个该属性创建的流程图，跟着图看一圈代码，就很容易明白：

dubbo源码分析 SPI机制、provider、consume启动与consume调用provider流程_第1张图片

题外话，这个属性跟cglib的Enhancer.KEY_FACTORY属性很类似，都是这种写法，创建都是执行了一大堆复杂东西。

核心是一个创建自适应类，在com.alibaba.dubbo.common.extension.ExtensionLoader.createAdaptiveExtensionClassCode()内，

几个注解说明下

@SPI，用于注解在类、接口、枚举类上，作用是标记该接口是一个dubbo spi接口，即一个扩展点，运行时需要通过配置找到具体的实现类。比如Protocol就是个dubbo spi扩展点，用@SPI注解。

@Adaptive，自适应注解，标记在类、接口、枚举类、方法上，标记在类上，说明该类是个自适应类，标记在方法上，说明可以通过该方法，动态的从参数（比如URL）中来确定要使用哪个方法，这个是策略模式的升级版。比如Protocol的export、refer方法就被@Adaptive注解，生成的自适应类Protocol$Adaptive，根据url的protocol不同，使用不同的协议。

@Activate，自动激活注解，标记在类、接口、枚举类、方法上，使用在有多个扩展点实现，需要根据不同条件被激活的场景中，比如filter需要同时被激活多个。

ExtensionLoader类属性我加了注释，帮助阅读源码理解。

public class ExtensionLoader {

    private static final Logger logger = LoggerFactory.getLogger(ExtensionLoader.class);

    private static final String SERVICES_DIRECTORY = "META-INF/services/";

    private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";

    private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";

    private static final Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*");

    //全局变量，缓存已经创建的ExtensionLoader[XXXX]
    private static final ConcurrentMap, ExtensionLoader> EXTENSION_LOADERS = new ConcurrentHashMap, ExtensionLoader>();//{interface com.alibaba.dubbo.common.extension.ExtensionFactory=com.alibaba.dubbo.common.extension.ExtensionLoader[com.alibaba.dubbo.common.extension.ExtensionFactory], interface com.alibaba.dubbo.rpc.Protocol=com.alibaba.dubbo.common.extension.ExtensionLoader[com.alibaba.dubbo.rpc.Protocol]}

    //全局变量，缓存创建的ExtensionLoader[XXXX].type文件内的clazz实例对象
    private static final ConcurrentMap, Object> EXTENSION_INSTANCES = new ConcurrentHashMap, Object>();//{class com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory=com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory@916eb0, class com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory@10dbc7a}

    // ==============================

    /*
     * 构造器赋值，以该clazz作为名称的文件是要被加载的
     */
    private final Class type;

    /*
     * 构造器赋值
     * 除了ExtensionLoader[ExtensionFactory]该属性是null，其他ExtensionLoader[XXXX]该属性是AdaptiveExtensionFactory
     * 该属性的功能是用来在injectExtension(T instance)进行ioc注入(通过setter注入)
     */
    private final ExtensionFactory objectFactory;//AdaptiveExtensionFactory,该属性就是用于给创建的XXX$Adaptive注入属性
    
    /*
     * 缓存加载/META-INF/dubbo/internal/、/META-INF/dubbo/、/META-INF/services/目录下的ExtensionLoader.type文件内
     * 未被@Adaptive注解且构造器的参数非ExtensionFactory.type，则把clazz=>name保存该属性。其中clazz和name就是ExtensionLoader.type文件内的配置，
     * 比如class SpringExtensionFactory=spring
     * 缓存普通扩展类clazz
     */
    private final ConcurrentMap, String> cachedNames = new ConcurrentHashMap, String>();

    /*
     * 缓存加载/META-INF/dubbo/internal/、/META-INF/dubbo/、/META-INF/services/目录下的ExtensionLoader.type文件内的
     * 未被@Adaptive注解且构造器的参数非ExtensionFactory.type的clazz集合
     * 缓存普通扩展类clazz和被@Active注解的扩展类，不包括自适应类和warpper类
     */
    private final Holder>> cachedClasses = new Holder>>();//{registry=class com.alibaba.dubbo.registry.integration.RegistryProtocol, injvm=class com.alibaba.dubbo.rpc.protocol.injvm.InjvmProtocol, dubbo=class com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol, mock=class com.alibaba.dubbo.rpc.support.MockProtocol}

    /*
     * 缓存加载/META-INF/dubbo/internal/、/META-INF/dubbo/、/META-INF/services/目录下的ExtensionLoader.type文件内
     * 未被@Adaptive注解且clazz的构造器参数非ExtensionLoader.type的clazz(dubbo称为wrapper类)且clazz被@Activate注解的name和Activate.value
     */
    private final Map cachedActivates = new ConcurrentHashMap();//如果被加载的类被@Activate注解，则存放其name和Activate.value
    /*
     * 保存的是ExtensionLoader.type文件内的name和clazz实例对象，在createExtension()内创建
     */
    private final ConcurrentMap> cachedInstances = new ConcurrentHashMap>();//{spring=com.alibaba.dubbo.common.utils.Holder@1282ed8, spi=com.alibaba.dubbo.common.utils.Holder@f57048}
    
    /*
     * 自适应对象，
     * 如果ExtensionLoader.type文件内的类有被@Adaptive注解，则保存的是该类，否则通常由createAdaptiveExtension()创建
     * 比如ExtensionLoader[ExtensionFactory]该值是AdaptiveExtensionFactory
     * 比如Protocol是Protocol$Adaptive，是由createAdaptiveExtension()创建
     * 缓存实例化后的自适应扩展类，只能有一个
     */
    private final Holder cachedAdaptiveInstance = new Holder();//value=AdaptiveExtensionFactory
    
    /*
     * 缓存/META-INF/dubbo/internal/、/META-INF/dubbo/、/META-INF/services/目录下的ExtensionLoader.type文件内被@Adaptive注解的clazz，
     * ExtensionLoader.type文件内最多只能有一个被@Adaptive注解的clazz，超过一个则抛异常
     * 如果没有，则执行createAdaptiveExtensionClass()创建
     */
    private volatile Class cachedAdaptiveClass = null;//如果要加载的类被Adaptive注解，则赋值为该class。对于ExtensionFactory来说，其三个子类AdaptiveExtensionFactory、SpiExtensionFactory、SpringExtensionFactory只有AdaptiveExtensionFactory被注解了，因此就是AdaptiveExtensionFactory
    /*
     * 存放的是@SPI注解的value值，比如com.alibaba.dubbo.rpc.Protocol被@SPI("dubbo")注解，则该值就是dubbo
     * 在ExtensionLoader.loadExtensionClasses()赋值
     */
    private String cachedDefaultName;
    private volatile Throwable createAdaptiveInstanceError;

    /*
     * 缓存/META-INF/dubbo/internal/、/META-INF/dubbo/、/META-INF/services/目录下的ExtensionLoader.type文件内
     * 未被@Adaptive注解且clazz的构造器参数是ExtensionLoader.type的clazz，就是包装类
     * 缓存wrapper类
     */
    private Set> cachedWrapperClasses;
}

核心方法有四个，下面一个个说明


1.1.ExtensionLoader.getExtensionLoader(Class)


创建接口clazz对应的ExtensionLoader对象。该方法功能就是从全局缓存EXTENSION_LOADERS获取一个ExtensionLoader[type]对象，不存在则创建ExtensionLoader[type]对象放入全局缓存EXTENSION_LOADERS，最后返回ExtensionLoader[type]对象。


/*
     * 传入参数是clazz，即该clazz是个文件存放在META-INF/dubbo/internal/、META-INF/dubbo/、META-INF/services/，跟jdk spi是类似的
     * 从全局缓存EXTENSION_LOADERS获取type对应的ExtensionLoader[type]对象，不存在则创建
     */
    @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)) {//class未被@SPI注解，抛出异常，只有被@SPI注解说明才是一个dubbo扩展接口
            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));//创建ExtensionLoader[type]对象，属性type存放的就是扩展接口clazz
            loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }


1.2.ExtensionLoader.getAdaptiveExtension()


功能：获取ExtensionLoader.type接口对应的自适应对象，不存在则创建


//获取接口clazz(即ExtensionLoader.type)的自适应扩展类对象，如果不存在，则创建
@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 {
    	/*
    	 * step1 getAdaptiveExtensionClass 获取自适应对象的clazz
    	 * step2 通过clazz.newInstance()反射创建自适应对象
    	 * step3 进行setter注入属性，这个是dubbo spi ioc功能
    	 */
        return injectExtension((T) getAdaptiveExtensionClass().newInstance());
    } catch (Exception e) {
        throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
    }
}
/*
 * 获取自适应clazz，形式是XXX$Adaptive
 */
private Class getAdaptiveExtensionClass() {
    getExtensionClasses();//如果缓存不存在则先加载
    if (cachedAdaptiveClass != null) {//说明ExtensionFactory.type文件内的clazz有被@Adaptive注解的类
        return cachedAdaptiveClass;
    }
    return cachedAdaptiveClass = createAdaptiveExtensionClass();//创建自适应对象保存到this.cachedAdaptiveClass
}
/*
 * 生成自适应类的java代码，然后使用javaassit编译自适应类java代码为class
 */
private Class createAdaptiveExtensionClass() {
    String code = createAdaptiveExtensionClassCode();//生成的是XXX$Adaptive这个java文件内容
    //如果需要查看生成的代码，则把变量code保存到文件内即可
    ClassLoader classLoader = findClassLoader();
    com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();//AdaptiveCompiler
    return compiler.compile(code, classLoader);//默认使用JavassistCompiler编译java代码
}
/*
 * 生成ExtensionLoader.type接口的实现类，并对接口内被@Adaptive注解的方法生成具体实现，
 * 未被@Adaptive注解的方法抛出UnsupportedOperationException，
 * 生成的类名是类名是ExtensionLoader.type$Adaptive
 */
private String createAdaptiveExtensionClassCode() {
	//代码较多，省略。
	//功能就是生成ExtensionLoader.type接口实现类的java代码，最后返的是个java代码对象
}


上步代码展示省略了编译java代码的步骤，这个编译我也没完全看懂，通常也不需要看懂的。


1.3.ExtensionLoader.getExtension(String)


获取name对应的扩展类，比如对于com.alibaba.dubbo.rpc.Protocol，那么name=dubbo的获取的是DubboProtocol，但是由于有wrapper类，因此获取到的对象是ProtocolFilterWrapper，结构是




为什么要使用wrapper呢？wrapper是对目标对象进行了一层装饰，为了增强目标对象，但是又不对目标对象增加额外功能，保持目标对象的功能共用性和单一性。


/*
 * 功能：获取普通扩展类对象XXX$Adaptive
 * 在ExtensionLoader[XXXX].getExtension(String name)获取ExtensionLoader.type文件内name对应的clazz实例（即自适应类）
 * 参数name是url上的属性值（或者是dubbo默认值）
 */
@SuppressWarnings("unchecked")
public T getExtension(String name) {//该方法功能就是获取ExtensionLoader.type文件内名称是name的对象实例，并放入缓存
    if (name == null || name.length() == 0)
        throw new IllegalArgumentException("Extension name == null");
    if ("true".equals(name)) {
        return getDefaultExtension();
    }
    Holder holder = cachedInstances.get(name);//从缓存获取对应的clazz
    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;
}
/*
 * 创建ExtensionLoader.type文件内name对应的clazz实例
 * dubbo扩展类的4个特性：自动包装，自动加载，自适应，自动激活
 * 这里是自动包装，就是目标扩展类自动会用wrapper类包装下
 */
@SuppressWarnings("unchecked")
private T createExtension(String name) {
    Class clazz = getExtensionClasses().get(name);//缓存获取
    if (clazz == null) {
        throw findException(name);
    }
    try {
        T instance = (T) EXTENSION_INSTANCES.get(clazz);
        if (instance == null) {
            EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());//创建clzz实例
            instance = (T) EXTENSION_INSTANCES.get(clazz);
        }
        injectExtension(instance);//setter注入
        Set> wrapperClasses = cachedWrapperClasses;
        //spi的wrapper对象就是该类只有一个构造器且构造器的参数是ExtensionLoader.type，比如ProtocolFilterWrapper、ProtocolListenerWrapper就是DubboProtocol的wrapper类
        if (wrapperClasses != null && !wrapperClasses.isEmpty()) {//使用wrapper类装饰，这样作用是为了增强功能，而且是类功能分开
            for (Class wrapperClass : wrapperClasses) {
            	/*
            	 * step1: wrapper类使用instance实例化
            	 * step2: wrapper类属性注入
            	 */
                instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));//wrapper实例化并注入
            }
        }
        return instance;
    } catch (Throwable t) {
        throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
                type + ")  could not be instantiated: " + t.getMessage(), t);
    }
}

1.4.ExtensionLoader.getActivateExtension(URL, String[], String)


/*
     * 参数values是url上属性值集合，比如filter属性，配置了多个filter，那么就是filter1、filter2、filter3
     * 参数group是url上属性group的value值
     * 功能：获取所有自动激活扩展点
     */
    public List getActivateExtension(URL url, String[] values, String group) {//遍历cachedActivates集合，返回@Activate.value匹配group名称的实例集合
        List exts = new ArrayList();
        List names = values == null ? new ArrayList(0) : Arrays.asList(values);
        //step0:加入默认的激活
        if (!names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) {//-default表示禁用所有默认
            //step1:检查缓存，如缓存没有，则加载到缓存
        	getExtensionClasses();
        	/*
        	 * step2:遍历ExtensionLoader.type文件内所有被@Activate注解的类，比如com.alibaba.dubbo.rpc.Filter文件内所有被@Activate注解的类
        	 * 根据传入的url匹配条件（匹配group name），得到所有符合激活条件的扩展类实现。然后根据@Activate中配置的before after order排序
        	 */
            for (Map.Entry entry : cachedActivates.entrySet()) {//
                String name = entry.getKey();//获取名称，比如com.alibaba.dubbo.rpc.Filter 文件内future
                Activate activate = entry.getValue();//获取类上的Activate注解
                if (isMatchGroup(group, activate.group())) {//group匹配，参数group为null 或者 被@Activate.group值集合包含 则匹配
                    T ext = getExtension(name);//获取名称为name对应的扩展点
                    if (!names.contains(name)//默认激活是不在url配置
                            && !names.contains(Constants.REMOVE_VALUE_PREFIX + name)//-表示禁止
                            && isActive(activate, url)) {//处于激活状态
                        exts.add(ext);
                    }
                }
            }
            Collections.sort(exts, ActivateComparator.COMPARATOR);//按照@Activate中配置的before after order排序
        }
        /*
         * step3:遍历所有用户自定义扩展类名称，根据用户url配置的顺序，调整扩展点激活顺序(按照用户在url中配置的顺序)
         */
        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)) {
            	//这个理解稍微麻烦些，比如test://localhost/text?ext=order1,default,order2，那么扩展点ext的激活顺序是按照order1->default->order2，这个default是表示前面的默认激活扩展点
                if (Constants.DEFAULT_KEY.equals(name)) {
                    if (!usrs.isEmpty()) {
                        exts.addAll(0, usrs);//把usrs添加到exts的头部，即default扩展点的前面
                        usrs.clear();
                    }
                } else {
                    T ext = getExtension(name);//获取名称name对应的扩展
                    usrs.add(ext);
                }
            }
        }
        if (!usrs.isEmpty()) {
            exts.addAll(usrs);
        }
        return exts;//最后返回的激活扩展点集合是顺序先默认激活+用户自定义激活
    }


那么判断是处于激活状态呢？如何判断的在isActive方法内


/*
     * 分2种情况
     * case1:被@Activate注解的扩展点的value集合是空，返回true，说明处于自动激活状态
     * case2:@Activate注解的扩展点的value集合和url上配置的激活key每个比较，如果相同 或者 url上的k是以Activate上的.key结尾 且url上的k的value非空 说明匹配
     */
    private boolean isActive(Activate activate, URL url) {
        String[] keys = activate.value();
        if (keys.length == 0) {
            return true;
        }
        //双层for循环，如果url上的k==Activate上的key || url上的k是以Activate上的.key结尾 且url上的k的value非空 说明匹配
        for (String key : keys) {
            for (Map.Entry entry : url.getParameters().entrySet()) {//遍历url上的参数，
                String k = entry.getKey();
                String v = entry.getValue();
                if ((k.equals(key) || k.endsWith("." + key))//k==key || k是以.key结尾，说明匹配
                        && ConfigUtils.isNotEmpty(v)) {
                    return true;
                }
            }
        }
        return false;
    }


下面给出个自己分析的时候，生成的自适应类，供参考


链接：https://share.weiyun.com/5qDR7qt


 


2.provider启动流程


按照自己习惯，先贴总体流程图


dubbo源码分析 SPI机制、provider、consume启动与consume调用provider流程_第2张图片


总结如下：


invoker对象本质就是对目标对象的代理，在dubbo中对通过代理对目标对象增强了功能，增加了filter，那么最终暴露的是exporter对象，需要把invoker对象包装为Exporter对象，Exporter对象也通过了装饰增加了功能，最终暴露到zk的服务对象的结构是这样的：


dubbo源码分析 SPI机制、provider、consume启动与consume调用provider流程_第3张图片


                                                                                图一，服务暴露对象的数据结构


总结dubbo启动流程大体是这样的，生成registry协议的url，生成dubbo协议的url，把dubbo url作为属性保存到registry协议url上，属性的export，接着生成目标对象的代理对象invoker，给该invoker增强（增加filter处理链），把invoker包装为protocol协议的export（默认是DubboExporter），启动netty监听端口，增加netty channelHandler处理链，在zk上创建服务节点，接着订阅本节点，zk创建configurators节点，zk watch机制监听该节点变化，有变化，则重新暴露服务，最后把export对象暴露（缓存起来），exporter对象也是经过了多层装饰。


启动过程大量用到了spi机制，根据url上的参数配置spi找到对应的具体实现对象，完全进行了解耦，理解了这个，很容易对自己的项目进行特定扩展，比如最常见增加filter。


3.consumer启动流程


consumer的配置如下




    
    
	
    
    
    
	
    
    




对应的是ReferenceBean，同ServiceBean一样，也是实现了spring提供的扩展接口，核心入口是ReferenceConfig.createProxy(Map)，看流程图：




消费端消费provider服务，但是实际都是存在多个provider的，那就为每个provider生成一个对应的invoker对象（默认dubboinvoker），但是最终得表现为一个invoker，那就包装下，把invoker集合包装为一个对象就是RegistryDirectory（实际保存在urlInvokerMap属性上），接着又包装为FailoverClusterInvoker（集群容错）、MockClusterInvoker，最终表现为对外的invoker对象就是MockClusterInvoker，那么该invoker对象结构就是：


MockClusterInvoker
     FailoverClusterInvoker
     RegistryDirectory.methodInvokerMap集合内存放是proviver的Invoker，表示provider集群
         RegistryDirectory$InvokerDelegate  (id=277)    
             ProtocolFilterWrapper$1[filterchain: ConsumerContextFilter -> FutureFilter -> MonitorFilter]
                 DubboInvoker


包装为了invoker，但是类型不是所需要的目标类型com.alibaba.dubbo.demo.DemoService，那就对invoker生成代理类，为代理类增加目标接口，这样生成的proxy类实现了目标接口又包装了invoker对象，然后调用的时候proxy类直接调用invoker对象，这个和jdk的动态代理模式思想是一样的，只是使用的javaassit生成的代理类。


为什么要生成代理类呢？因为要远程调用，要连接服务端，涉及到编解码，这些步骤都是公共部分，那么就包装起来，因此invoker类就是包装了公共部分功能。


消费端订阅了zk上的providers节点、configurators、routers节点，在这些节点发发生变化的时候，zk向消费端发送通知，然后消费端从zk拉取到节点变化内容，执行对应的变化，比如重新生成invoker对象。 这里的执行流程是


dubbo源码分析 SPI机制、provider、consume启动与consume调用provider流程_第4张图片


 


4.dubbo调用流程


以dubbo源码的例子来说，String hello = demoService.sayHello("world");，该步骤是实际的调用，表面看就是IOC容器内的bean执行方法，但是方法的具体实现是在provider的，使用的是netty，下图是dubbo consume调provider总体流程图


dubbo源码分析 SPI机制、provider、consume启动与consume调用provider流程_第5张图片


 


大体功能是：consume发起请求，把要执行的目标方法、参数包装为RpcInvocation，根据集群策略查找到consume启动的时候保存的所有该方法对应的invoker集合，然后经过router筛选后，返回符合的invoker集合，再通过负载均衡策略获取一个invoker，然后执行该invoker的调用，invoker是个装饰对象，执行其内部被装饰的一个个invoker，那么经过invoker和filter处理，最终调用到netty client发送数据，创建com.alibaba.dubbo.remoting.exchange.Request，该对象包装了RpcInvocation，通过Netty进行网络发送，经过netty ChannelHandler处理链的编码写入到缓冲区，刷新缓冲区，从而把数据发送到provider发送出去，因为netty是异步非阻塞的（发送线程和业务线程不是同一个），如果是同步发送方式，ResponseFuture进行同步等待结果，异步的话不需要等待结果。


provider端netty io线程不停轮询selector，如果有可读事件，则触发ChannelHandler链的channelRead()操作，那么由netty读取到consume请求，进行解码，接收处理，根据url获取到provider暴露的服务，从暴露的服务获取到对应的invoker对象，那么执行invoker对象，invoker对象是个装饰链对象，一层层执行内部Invoker，再经过filter链处理，最终执行到目标方法。然后把目标方法进行编码通过netty传输返回到consume。


FIXME 这个图应该用管道图更加清晰，后续改为管道图。


 


 


 

























你可能感兴趣的:(dubbo,源码分析)






    

  • JVM源码分析之堆外内存完全解读
HeapDump性能社区

    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
    

    • 

  • Golang Channel
PandaSkr
golang

    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
    

    • 

  • Java集合类框架源码分析 之 RoleList源码解析 【6】
yunzhonghefei
Java集合类源码分析RoleList源码解析

    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    

    • 

  • 【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析
"小夜猫&小懒虫&小财迷"的男人
鸿蒙OH-v5.0源码分析之Uboot+Kernel部分harmonyoslinux华为

    【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
    

    • 

  • Dubbo架构概览：服务注册与发现、远程调用、监控与管理
木南曌
dubbo架构

    Dubbo是一个成熟的、高性能的、基于Java的微服务开发框架，它主要用于解决分布式系统中的服务治理问题，包括服务的注册与发现、远程过程调用（RPC）、服务监控与管理等多个关键环节。以下是Dubbo架构概览的详细介绍：服务注册与发现Dubbo的服务注册与发现机制是其核心功能之一，它依赖于注册中心来管理服务的生命周期和定位服务提供者。1.服务提供者（Provider）服务提供者是实际提供服务的节点，
    

    • 

  • 主流行架构
rainbowcheng
架构架构

    nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
    

    • 

  • 深入解析 Dubbo 的 attachments 机制及其应用场景
molashaonian
dubboattachments隐式传参

    背景在分布式系统中，服务之间的调用（RPC调用）是非常常见的。而在这种服务调用过程中，常常需要在不同服务之间传递一些上下文信息，比如用户身份信息、请求追踪ID、客户端IP等。Dubbo提供的attachments机制，能够帮助开发者在RPC调用时隐式传递这些数据，而不需要修改接口方法签名。通过分析架构图，我们可以看到，在服务调用链路中，使用Dubbo的attachments机制可以简化上下文信息的
    

    • 

  • Java高并发编程详解系列-深入理解Thread构造
nihui123
高并发Java高并发Java高并发

    上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范  从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
    

    • 

  • 【QT教程】QT6硬件图形界面编程 QT硬件编程
QT性能优化QT原理源码QT界面美化
qtqt6.3qt5c++QT教程

    QT6硬件图形界面编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6硬件图形界面编程概述1.1QT6硬件图形界面编程简介1.1.1QT6硬件
    

    • 

  • 自己实现一个简易RPC调用框架
殷俊杰

    最近在看dubbo，去创始人之一梁飞大神的博客搂了几眼，找到这个demo自己实现了一下，关于dubbo就不再介绍了，快速开始、框架设计、设计原则官网都有，有兴趣可以自己看Dubbo官网1.服务接口packagecom.yjj.my.api;/***@Description:*@Author:yinjunjie*@CreateDate:2018/8/713:16*@Version:1.0*/publ
    

    • 

  • Jetpack LiveData源码分析
xiangxiongfly915
#AndroidJetpack系列JetpackLiveData源码分析

    文章目录JetpackLiveData源码分析前提源码分析注册订阅流程LiveData#observe()LifecycleRegistry#addObserver()ObserverWithState#dispatchEvent()LiveData#removeObserver()LiveData$LifecycleBoundObserver类LifecycleBoundObserver#sho
    

    • 

  • ExoPlayer架构详解与源码分析（17）——TrackSelector
山雨楼
ExoPlayer架构android音视频ExoPlayerMedia3源码

    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
    

    • 

  • ExoPlayer架构详解与源码分析（12）——Cache
山雨楼
ExoPlayer架构android音视频ExoPlayerMedia3源码

    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
    

    • 

  • ExoPlayer架构详解与源码分析（7）——SampleQueue(4)
2401_83740189
程序员架构

    long[]newSourceIds=newlong[newCapacity];long[]newOffsets=newlong[newCapacity];long[]newTimesUs=newlong[newCapacity];int[]newFlags=newint[newCapacity];int[]newSizes=newint[newCapacity];CryptoData[]newC
    

    • 

  • 【HarmonyOS】- 常见算法简单写法
数的羊都睡了
HarmonyOSArkTS鸿蒙

    文章目录知识回顾前言源码分析1.冒泡排序2.二分法查找拓展知识时间、空间复杂度总结知识回顾前言常见算法简单写法源码分析1.冒泡排序functionbubbleSort(arr:number[]):number[]{constn=arr.length;for(leti=0;iarr[j+1]){//交换元素consttemp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;
    

    • 

  • [ docker-ce源码分析系列 ] 修改resolv.conf文件被还原的原因
nangonghen
dockerdocker

    1概述：1.1环境版本信息如下：a、操作系统：centos7.6，amd64b、服务器docker版本：v18.09.22resolv.conf文件被还原的现象：容器中的/etc/resolv.conf文件，是由宿主机/var/lib/docker/containers/xxxx/resolv.conf文件挂载。在dockerrestart容器之前，手动修改了/var/lib/docker/con
    

    • 

  • Dubbo 与 Zookeeper 在项目中的应用：原理与实现详解
CopyLower
学习Javadubbozookeeper分布式

    引言在微服务架构日益普及的今天，如何实现服务的高效调用和管理成为了关键问题。Dubbo作为阿里巴巴开源的高性能RPC框架，在分布式服务治理方面具有显著的优势。Zookeeper作为一款分布式协调服务，能够高效地管理和协调服务节点信息。因此，Dubbo与Zookeeper的结合不仅能够提供服务注册与发现机制，还能实现更高效的服务治理。在本文中，我们将深入探讨Dubbo和Zookeeper的原理、如何
    

    • 

  • dispatch_once源码分析
福伟_Y

    GCD里的单例函数dispatch_once是我们经常会用到的，今天我们来稍做深入分析一下。GCD的源码都在libdispatch.dylib库里，这个库在libSystem_initializer被初始化，可理解为在dyld里被加载和初始化的(之前的文章有分析过)。dispatch_once作为单例的使用入口，通过分析得到它是一个宏定义，_dispatch_once函数在libdispatch.
    

    • 

  • dubbo整合nacos（狠狠踩坑 之 自己淋过雨不想让别人也一起）
程序员-珍
dubbo微服务springbootjava后端

    快速入门1.dubbo官网强烈推荐小伙伴们去官网看看哪里写的都不如官网。我是看了网上的代码，狠狠踩坑，这个东西搞了好久~~~2.消费服务和提供服务都加上依赖org.apache.dubbodubbo3.0.9com.alibaba.nacosnacos-client2.1.03.创建一个DemoService接口和一个DemoServiceImpl实现类，DemoService类上面要加上注解@D
    

    • 

  • Dubbo服务自动Web化之路
搜狐技术产品小编2023
dubbo前端

    本文字数：6047字预计阅读时间：40分钟01故障出现事情起源于一次故障，2023年12月14日14点26分，大量Dubbo服务报出异常，无法链接zookeeper集群：Session0x0 for serverdubboZk.xxx.com/10.x.x.x:2181, Closingsocketconnection. AttemptingreconnectexceptitisaSessionE
    

    • 

  • SpringBoot整合Dubbo(基于Nacos2)
KenithZhang

    1.前言这是一个基于SpringBoot整合ApacheDubbo+Nacos的极简教程，笔者使用到的技术及版本如下：SpringBoot2.4.5Dubbo2.7.11Nacos2.0.1（自行安装）Dubbo官网：https://dubbo.apache.org/zh/Nacos官网：https://nacos.io/zh-cn/docs/quick-start.html2.目录结构dubbo
    

    • 

  • dubbo 服务消费原理分析之服务目录
DEARM LINER
dubbojava架构后端springboot

    文章目录前言一、RegistryDirectory1、DynamicDirectory2、RegistryProtocol.doCreateInvoker2、RegistryProtocol.subscribe3、ListenerRegistryWrapper.subscribe4、FailbackRegistry.subscribe5、ZookeeperRegistry.doSubscribe6
    

    • 

  • dubbo spi 原理分析
DEARM LINER
dubbospringjavaspringboot后端

    文章目录前言一、加载固定的扩展类1、ExtensionLoader.getExtension2、createExtension3、getExtensionClasses4、loadExtensionClasses5、cacheDefaultExtensionName6、loadDirectory7、loadResource8、loadClass二、加载自适应扩展类1、ExtensionLoader
    

    • 

  • dubbo k8s 服务发现_Dubbo 迈出云原生重要一步 - 应用级服务发现解析
weixin_39775127
dubbok8s服务发现

    作者|刘军(陆龟)ApacheDubboPMC概述社区版本Dubbo从2.7.5版本开始，新引入了一种基于实例(应用)粒度的服务发现机制，这是我们为Dubbo适配云原生基础设施的一步重要探索。版本发布到现在已有近半年时间，经过这段时间的探索与总结，我们对这套机制的可行性与稳定性有了更全面、深入的认识；同时在Dubbo3.0的规划也在全面进行中，如何让应用级服务发现成为未来下一代服务框架Dubbo3
    

    • 

  • dubbo k8s 服务发现_Dubbo 迈出云原生重要一步 应用级服务发现解析
倩Sur
dubbok8s服务发现

    作者|刘军(陆龟)ApacheDubboPMC概述社区版本Dubbo从2.7.5版本开始，新引入了一种基于实例(应用)粒度的服务发现机制，这是我们为Dubbo适配云原生基础设施的一步重要探索。版本发布到现在已有近半年时间，经过这段时间的探索与总结，我们对这套机制的可行性与稳定性有了更全面、深入的认识；同时在Dubbo3.0的规划也在全面进行中，如何让应用级服务发现成为未来下一代服务框架Dubbo3
    

    • 

  • jQuery Easyui 源码分析之combo组件
90后北京程序员
前端-easyuieasyui之combobox

    /***jQueryEasyUI1.3.1*该源码完全由压缩码翻译而来，并非网络上放出的源码，请勿索要。*/(function($){functionsetSize(target,width){varopts=$.data(target,"combo").options;varcombo=$.data(target,"combo").combo;varpanel=$.data(target,"co
    

    • 

  • html5carousel图片轮播,全面解析Bootstrap中Carousel轮播的使用方法
RemusrickCat

    本文实例为大家全面的解析了Bootstrap中Carousel的使用方法，供大家参考，具体内容如下源码文件：Carousel.scssCarousel.js实现原理：隐藏所有要显示的元素，然后指定当前要显示的为block，宽、高自适应源码分析：1、Html结构：主要分为以四个部分1.1、容器：最外层div，需要一个data-ride=”carousel”来指定为轮播放插件，并且提供一个Id，方便圆
    

    • 

  • Java集合-----List接口及其实现类：ArrayList、LinkedList、Vector
Colourful．
Java集合java集合

    文章目录List接口概述List接口的常用方法List接口的实现类ArrayList源码分析类继承关系ArrayList中的属性：ArrayList构造函数：ArrayList中常用方法添加操作：add()删除操作：remove()获取元素：get()ArrayList是如何实现序列化的？ArrayList的总结LinkedList源码分析类继承关系类成员属性类构造器LinkedList的List
    

    • 

  • React Native通讯原理
zbl_zbl
androidReactNativ

    之前写过一篇文章ReactNativeAndroid源码分析，在此文章的基础上分析和总结下RN与Native的通讯流程。本文基于Android代码分析，iOS实现原理类似。1.通讯框架图先来解析下各个模块的角色与作用：Java层，这块的实现在ReactAndroid中-ReactContext:Android上下文子类，包含一个CatalystInstance实例，用于获取NativeModule
    

    • 

  • [linux 驱动]增加一个文件节点控制led灯亮灭
嵌入式成长家
linux内核的系统实战linux驱动linux驱动led灯驱动

    目录1修改设备树2修改驱动3驱动源码3.1驱动源码3.2设备树节点3.3驱动源码分析3.3.1##解释3.3.2class_create解释3.3.3class_create_file解释3.3.4of_get_named_gpio_flags解释3.3.5devm_gpio_request解释3.3.6platform_driver_register解释3.3.7platform_driver_
    

    • 

  • windows下源码安装golang
616050468
golang安装golang环境windows

             系统： 64位win7， 开发环境：sublime text 2，  go版本： 1.4.1
 
 1.  安装前准备(gcc, gdb, git)
       golang在64位系
    

    • 

  • redis批量删除带空格的key
bylijinnan
redis

    redis批量删除的通常做法：
redis-cli keys "blacklist*" | xargs redis-cli del
上面的命令在key的前后没有空格时是可以的，但有空格就不行了：
$redis-cli keys "blacklist*"
1) "blacklist:12: [email protected]
    

    • 

  • oracle正则表达式的用法
0624chenhong
oracle正则表达式

      方括号表达示
方括号表达式
描述
[[:alnum:]]
字母和数字混合的字符
[[:alpha:]]
字母字符
[[:cntrl:]]
控制字符
[[:digit:]]
数字字符
[[:graph:]]
图像字符
[[:lower:]]
小写字母字符
[[:print:]]
打印字符
[[:punct：]]
标点符号字符
[[:space:]]
    

    • 

  • 2048源码(核心算法有，缺少几个anctionbar，以后补上)
不懂事的小屁孩
2048

    2048游戏基本上有四部分组成，
1：主activity，包含游戏块的16个方格，上面统计分数的模块
2：底下的gridview，监听上下左右的滑动，进行事件处理，
3：每一个卡片，里面的内容很简单，只有一个text，记录显示的数字
4：Actionbar，是游戏用重新开始，设置等功能(这个在底下可以下载的代码里面还没有实现)
写代码的流程
1：设计游戏的布局，基本是两块，上面是分
    

    • 

  • jquery内部链式调用机理
换个号韩国红果果
JavaScriptjquery

    只需要在调用该对象合适(比如下列的setStyles)的方法后让该方法返回该对象（通过this  因为一旦一个函数称为一个对象方法的话那么在这个方法内部this（结合下面的setStyles）指向这个对象）
function create(type){
var element=document.createElement(type);
//this=element; 
    

    • 

  • 你订酒店时的每一次点击 背后都是NoSQL和云计算
蓝儿唯美
NoSQL

    全球最大的在线旅游公司Expedia旗下的酒店预订公司，它运营着89个网站，跨越68个国家，三年前开始实验公有云，以求让客户在预订网站上查询假期酒店时得到更快的信息获取体验。
云端本身是用于驱动网站的部分小功能的，如搜索框的自动推荐功能，还能保证处理Hotels.com服务的季节性需求高峰整体储能。
Hotels.com的首席技术官Thierry Bedos上个月在伦敦参加“2015 Clou
    

    • 

  • java笔记1
a-john
java

    1，面向对象程序设计（Object-oriented Propramming，OOP）：java就是一种面向对象程序设计。
2，对象：我们将问题空间中的元素及其在解空间中的表示称为“对象”。简单来说，对象是某个类型的实例。比如狗是一个类型，哈士奇可以是狗的一个实例，也就是对象。
3，面向对象程序设计方式的特性：
    3.1 万物皆为对象。
   
    

    • 

  • C语言 sizeof和strlen之间的那些事 C/C++软件开发求职面试题 必备考点（一）
aijuans
C/C++求职面试必备考点

            找工作在即，以后决定每天至少写一个知识点，主要是记录，逼迫自己动手、总结加深印象。当然如果能有一言半语让他人收益，后学幸运之至也。如有错误，还希望大家帮忙指出来。感激不尽。
       后学保证每个写出来的结果都是自己在电脑上亲自跑过的，咱人笨，以前学的也半吊子。很多时候只能靠运行出来的结果再反过来
    

    • 

  • 程序员写代码时就不要管需求了吗？
asia007
程序员不能一味跟需求走

          编程也有2年了，刚开始不懂的什么都跟需求走，需求是怎样就用代码实现就行，也不管这个需求是否合理，是否为较好的用户体验。当然刚开始编程都会这样，但是如果有了2年以上的工作经验的程序员只知道一味写代码，而不在写的过程中思考一下这个需求是否合理，那么，我想这个程序员就只能一辈写敲敲代码了。
      我的技术不是很好，但是就不代
    

    • 

  • Activity的四种启动模式
百合不是茶
android栈模式启动Activity的标准模式启动栈顶模式启动单例模式启动

    android界面的操作就是很多个activity之间的切换,启动模式决定启动的activity的生命周期 ;
 
启动模式xml中配置
    <activity android:name=".MainActivity" android:launchMode="standard&quo
    

    • 

  • Spring中@Autowired标签与@Resource标签的区别
bijian1013
javaspring@Resource@Autowired@Qualifier

    Spring不但支持自己定义的@Autowired注解，还支持由JSR-250规范定义的几个注解，如：@Resource、 @PostConstruct及@PreDestroy。
 
1. @Autowired    @Autowired是Spring 提供的，需导入    Package:org.springframewo
    

    • 

  • Changes Between SOAP 1.1 and SOAP 1.2
sunjing
ChangesEnableSOAP 1.1SOAP 1.2

    JAX-WS
SOAP Version 1.2 Part 0: Primer (Second Edition)
SOAP Version 1.2 Part 1: Messaging Framework (Second Edition)
SOAP Version 1.2 Part 2: Adjuncts (Second Edition)
 
Which style of WSDL
    

    • 

  • 【Hadoop二】Hadoop常用命令
bit1129
hadoop

    以Hadoop运行Hadoop自带的wordcount为例，
 
hadoop脚本位于/home/hadoop/hadoop-2.5.2/bin/hadoop，需要说明的是，这些命令的使用必须在Hadoop已经运行的情况下才能执行
  Hadoop HDFS相关命令
 hadoop fs -ls
 列出HDFS文件系统的第一级文件和第一级
    

    • 

  • java异常处理（初级）
白糖_
javaDAOspring虚拟机Ajax

    从学习到现在从事java开发一年多了，个人觉得对java只了解皮毛，很多东西都是用到再去慢慢学习，编程真的是一项艺术，要完成一段好的代码，需要懂得很多。
最近项目经理让我负责一个组件开发，框架都由自己搭建，最让我头疼的是异常处理，我看了一些网上的源码，发现他们对异常的处理不是很重视，研究了很久都没有找到很好的解决方案。后来有幸看到一个200W美元的项目部分源码，通过他们对异常处理的解决方案，我终
    

    • 

  • 记录整理-工作问题
braveCS
工作

    1）那位同学还是CSV文件默认Excel打开看不到全部结果。以为是没写进去。同学甲说文件应该不分大小。后来log一下原来是有写进去。只是Excel有行数限制。那位同学进步好快啊。
2）今天同学说写文件的时候提示jvm的内存溢出。我马上反应说那就改一下jvm的内存大小。同学说改用分批处理了。果然想问题还是有局限性。改jvm内存大小只能暂时地解决问题，以后要是写更大的文件还是得改内存。想问题要长远啊
    

    • 

  • org.apache.tools.zip实现文件的压缩和解压，支持中文
bylijinnan
apache

    刚开始用java.util.Zip，发现不支持中文（网上有修改的方法，但比较麻烦）
后改用org.apache.tools.zip
org.apache.tools.zip的使用网上有更简单的例子
下面的程序根据实际需求，实现了压缩指定目录下指定文件的方法
import java.io.BufferedReader;
import java.io.BufferedWrit
    

    • 

  • 读书笔记-4
chengxuyuancsdn
读书笔记

    1、JSTL 核心标签库标签
2、避免SQL注入
3、字符串逆转方法
4、字符串比较compareTo
5、字符串替换replace
6、分拆字符串
1、JSTL 核心标签库标签共有13个，
学习资料：http://www.cnblogs.com/lihuiyy/archive/2012/02/24/2366806.html
功能上分为4类：
(1)表达式控制标签：out
    

    • 

  • [物理与电子]半导体教材的一个小问题
comsci
问题

    
      各种模拟电子和数字电子教材中都有这个词汇-空穴
      书中对这个词汇的解释是; 当电子脱离共价键的束缚成为自由电子之后,共价键中就留下一个空位,这个空位叫做空穴
      我现在回过头翻大学时候的教材,觉得这个
    

    • 

  • Flashback Database --闪回数据库
daizj
oracle闪回数据库

    Flashback 技术是以Undo segment中的内容为基础的， 因此受限于UNDO_RETENTON参数。要使用flashback 的特性，必须启用自动撤销管理表空间。
在Oracle 10g中， Flash back家族分为以下成员： Flashback Database， Flashback Drop，Flashback Query(分Flashback Query,Flashbac
    

    • 

  • 简单排序:插入排序
dieslrae
插入排序

    
public void insertSort(int[] array){
int temp;
for(int i=1;i<array.length;i++){
temp = array[i];
for(int k=i-1;k>=0;k--)
    

    • 

  • C语言学习六指针小示例、一维数组名含义，定义一个函数输出数组的内容
dcj3sjt126com
c

    # include <stdio.h>
int main(void)
{
int * p; //等价于 int *p 也等价于 int* p;
int i = 5;
char ch = 'A';
//p = 5; //error
//p = &ch; //error
//p = ch; //error
p = &i; // 
    

    • 

  • centos下php redis扩展的安装配置3种方法
dcj3sjt126com
redis

    方法一
1.下载php redis扩展包  代码如下 复制代码
#wget http://redis.googlecode.com/files/redis-2.4.4.tar.gz
2 tar -zxvf 解压压缩包，cd /扩展包 （进入扩展包然后 运行phpize 一下是我环境中phpize的目录，/usr/local/php/bin/phpize (一定要
    

    • 

  • 线程池(Executors)
shuizhaosi888
线程池

    在java类库中，任务执行的主要抽象不是Thread，而是Executor，将任务的提交过程和执行过程解耦
public interface Executor {
void execute(Runnable command);
}
 
public class RunMain implements Executor{
@Override
pub
    

    • 

  • openstack 快速安装笔记
haoningabc
openstack

    前提是要配置好yum源
版本icehouse，操作系统redhat6.5
最简化安装，不要cinder和swift
三个节点
172 control节点keystone glance horizon
173 compute节点nova
173 network节点neutron
control
/etc/sysctl.conf
net.ipv4.ip_forward =
    

    • 

  • 从c面向对象的实现理解c++的对象（二）
jimmee
C++面向对象虚函数

    1. 类就可以看作一个struct，类的方法，可以理解为通过函数指针的方式实现的，类对象分配内存时，只分配成员变量的，函数指针并不需要分配额外的内存保存地址。
2. c++中类的构造函数，就是进行内存分配(malloc)，调用构造函数
3. c++中类的析构函数，就时回收内存(free)
4. c++是基于栈和全局数据分配内存的，如果是一个方法内创建的对象，就直接在栈上分配内存了。
专门在
    

    • 

  • 如何让那个一个div可以拖动
lingfeng520240
html

    
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml
    

    • 

  • 第10章 高级事件（中）
onestopweb
事件

    index.html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    

    • 

  • 计算两个经纬度之间的距离
roadrunners
计算纬度LBS经度距离

    要解决这个问题的时候，到网上查了很多方案，最后计算出来的都与百度计算出来的有出入。下面这个公式计算出来的距离和百度计算出来的距离是一致的。
/**
*
* @param longitudeA
* 经度A点
* @param latitudeA
* 纬度A点
* @param longitudeB
* 
    

    • 

  • 最具争议的10个Java话题
tomcat_oracle
java

    1、Java8已经到来。什么！？ Java8 支持lambda。哇哦，RIP Scala！ 　　随着Java8 的发布，出现很多关于新发布的Java8是否有潜力干掉Scala的争论，最终的结论是远远没有那么简单。Java8可能已经在Scala的lambda的包围中突围，但Java并非是函数式编程王位的真正觊觎者。 　
　2、Java 9 即将到来 　　
Oracle早在8月份就发布
    

    • 

  • zoj 3826 Hierarchical Notation(模拟)
阿尔萨斯
rar

     题目链接：zoj 3826 Hierarchical Notation
题目大意：给定一些结构体，结构体有value值和key值，Q次询问，输出每个key值对应的value值。
解题思路：思路很简单，写个类词法的递归函数，每次将key值映射成一个hash值，用map映射每个key的value起始终止位置，预处理完了查询就很简单了。 这题是最后10分钟出的，因为没有考虑value为{}的情
    

    •