DUBBO 服务导出实现

在阅读此文章之前，我希望阅读者对Spring 扩展机制的有一定的了解，比如：自定义标签与Spring整合， InitializingBean 接口，ApplicationContextAware，BeanNameAware，

BeanFactory 接口所起到的作用 ;从来没了解过的，请看我之前的关于Spring的博客 

关于此篇文章受益于 ：http://dubbo.apache.org/zh-cn/docs/source_code_guide/export-service.html   dubbo官网文档

开始正题

（一）onApplicationEvent （事件监听）

dubbo 服务导出的方法是在 com.alibaba.dubbo.config.spring.ServiceBean 类中，dubbo 服务的导出过程始于在Spring 容器发生刷新事件，那么如何感知到Spring 容器发生刷新

事件呢？ ～～ 得益于Spring提供的 ApplicationListener 接口，看如下代码实现：

public void onApplicationEvent(ApplicationEvent event) {
　　　　//在Spring bean 刷新后进行服务的导出；
        if (ContextRefreshedEvent.class.getName().equals(event.getClass().getName())) {
            if (isDelay() && ! isExported() && ! isUnexported()) {
                if (logger.isInfoEnabled()) {
                    logger.info("The service ready on spring started. service: " + getInterface());
                }
                export();
            }
        }
    }

实现该接口需要实现 onApplicationEvent 方法；事件的监听，在有event 事件发生后，Spring会自动进行触发此方法；

在Spring 容器发生刷新事件后进行导出 export();   这一步就是最先开始的地方；

（二）检查参数，组装 URL

public synchronized void export() {
        if (provider != null) {
        //是否进行导出的操作，用于在我们配置了<dubbo:provider export="false" />的时候，本地进行操作，不进行服务暴露的时候
            if (export == null) {
                export = provider.getExport();
            }
            if (delay == null) {
                delay = provider.getDelay();
            }
        }
        if (export != null && ! export.booleanValue()) {
            return;
        }
        //延时导出，线程睡眠，在高版本中，此方法改变成了schedule
        if (delay != null && delay > 0) {
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(delay);
                    } catch (Throwable e) {
                    }
                    doExport();
                }
            });
            thread.setDaemon(true);
            thread.setName("DelayExportServiceThread");
            thread.start();
        } else {
            doExport();
        }
    }        

以上的方法就是进行了<dubbo:provider> 标签属性 export 与delay 的操作判断；

我们继续进行  doExport();

 doExport() 又进行了一些的判断与初始化的动作，没什么好说的，接下来就是调用 doExportUrls（）；

private void doExportUrls() {
        List<URL> registryURLs = loadRegistries(true);
        for (ProtocolConfig protocolConfig : protocols) {
            doExportUrlsFor1Protocol(protocolConfig, registryURLs);
        }
    }

loadRegistries() 会将一些必要信息进行排序封装，生成url地址链接如下格式：

registry://47.95.**.138:2181/com.alibaba.dubbo.registry.RegistryService?application=hm-service-cart&check=false&dubbo=2.5.3&pid=931&registry=zookeeper&timestamp=1545835371053

有多少协议，就导出多少次：

doExportUrlsFor1Protocol(protocolConfig, registryURLs);这个方法我们在第4步分析；

我们先看看Dubbo spi 机制
  

　(三) Dubbo SPI （服务发现机制）

DUBBO SPI 的实现主要依赖于。 com.alibaba.dubbo.common.extension.ExtensionLoader 这个类，这个类是dubbo 运行的容器，维护着一些组件的实例，就像Spring 容器一样；

SPI 服务发现机制；我给大家揭开它的面纱：

在源码阅读中，我们只要发现了像如下的代码，内部就进行了spi 的机制

ExtensionLoader.getExtensionLoader(XXX.class).getExtension(type);

ExtensionLoader.getExtensionLoader(XXX.class).getAdaptiveExtension();

xxx.class 是接口名字，必须带有@SPI的注解

public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
    //不为空检测
        if (type == null)
            throw new IllegalArgumentException("Extension type == null");
//必须的接口
        if(!type.isInterface()) {
            throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
        }
//接口必须有@SPI 的注解
        if(!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type(" + type + 
                    ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
        }
        //实例化
        ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        if (loader == null) {
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
            loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

具体如下

1.（大家可以去看一看dubbo jar 包下 META-INF/dubbo/internal 目录的文件）：以接口作为文件名称，内部是ke y = 实现类

 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/";

2.在 getExtension  方法执行中，主要看  createExtension(name)方法；

public T getExtension(String name) {
        if (name == null || name.length() == 0)
            throw new IllegalArgumentException("Extension name == null");
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        Holder<Object> holder = cachedInstances.get(name);
        if (holder == null) {
            cachedInstances.putIfAbsent(name, new Holder<Object>());
            holder = cachedInstances.get(name);
        }
        Object instance = holder.get();
        if (instance == null) {
            synchronized (holder) {
                instance = holder.get();
                if (instance == null) {
                    instance = createExtension(name);
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }

createExtension（name）方法（ioc + aop ）

private T createExtension(String name) {
　　　　　　//这个方法会从文件系统中获取name 所对应的value ，大家可以看看这个方法
        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);
            }
　　　　　　　　//ioc 操作
            injectExtension(instance);
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
　　　　　　　//aop 包装的操作,包装类你调用我我调用你，形成了一条执行链；wrapperClasses 是包装类，在loadFile() 方法中被装配
            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);
        }
    }

获取所有的扩展类：

    private Map<String, Class<?>> getExtensionClasses() {
        Map<String, Class<?>> classes = cachedClasses.get();
        if (classes == null) {
            synchronized (cachedClasses) {
                classes = cachedClasses.get();
                if (classes == null) {
                    classes = loadExtensionClasses();
                    cachedClasses.set(classes);
                }
            }
        }
        return classes;
    }

 // 此方法已经getExtensionClasses方法同步过。
    private Map<String, Class<?>> 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<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
　　　　//从META-INF/services/ META-INF/dubbo/  /META-INF/dubbo/internal/ 这三个文件夹中获取class配置
        loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
        loadFile(extensionClasses, DUBBO_DIRECTORY);
        loadFile(extensionClasses, SERVICES_DIRECTORY);
        return extensionClasses;
    }

　　//dubbo 扩展检索的文件

    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/";

这样对应着key 就可以实例化value，找到实现类了； 大家可以做一做小的demo进行一下测试：

/**
接口
 * dubbo spi 机制，需要引用dubbo的spi 注解标签
 */
@SPI
public interface DubboSPI {

    public void sayHello();
}

//实现类
public class DuboSPIImpl implements DubboSPI {

    public void sayHello(){
        System.out.println("dubbo spi 机制运行......cys");
    };

}



//测试类
public static void main(String[] args) {
        ExtensionLoader<DubboSPI> extensionLoader =
                ExtensionLoader.getExtensionLoader(DubboSPI.class);
        DubboSPI optimusPrime = extensionLoader.getExtension("DubboSPI");
        optimusPrime.sayHello();

    }

在META-INF/dubbo 下配置创建 com.baseknow.spi.dubbospi.DubboSPI (你的接口名字)文件 

DubboSPI = com.baseknow.spi.dubbospi.DuboSPIImpl

关于一些常规的操作就到这里；

高级特性：(动态生成字节码文件，加载进入内存)

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

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

　如上：dubbo 通过 getAdaptiveExtension（）进行扩展适配；通过javassist 将动态创建的类加载进内存；可以这么说，如上的protocol  proxyFactory 这两个对象是不存在的

通过dubbo 扩展 SPI Adapter 机制，将会自动生成实现该接口的一个类(这个类是自动生成的，不存在我们的文件中)，通过javassiste 进行记载，然后通过创建的Adapter 类进行方法

的调度；

 具体请看 ExtensionLoader 类如下两个方法（源码生成➕编译）：

private Class<?> createAdaptiveExtensionClass() {
        //生成源码code ，建议debug ,看一看生成的源码是什么样子的
        String code = createAdaptiveExtensionClassCode();
        ClassLoader classLoader = findClassLoader();
        com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
    //默认会进行javassist 将源码加载toclass()
        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;
            }
        }        
//........ 

 如下是dubbo   通过 getAdaptiveExtension() 通过一系列判断 stringbbuilder 拼接而生成的 实现了Protocol接口的 适配器源码，根据传来的url来处理不同协议的调度

package com.alibaba.dubbo.rpc;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
public class Protocol$Adpative implements com.alibaba.dubbo.rpc.Protocol {
public void destroy() {throw new UnsupportedOperationException("method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
}
public int getDefaultPort() {throw new UnsupportedOperationException("method public abstract int com.alibaba.dubbo.rpc.Protocol.getDefaultPort() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
}

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

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

 这是实现了ProxyFactory  接口的 适配器源码

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

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

public java.lang.Object getProxy(com.alibaba.dubbo.rpc.Invoker arg0) throws com.alibaba.dubbo.rpc.Invoker {
if (arg0 == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");
if (arg0.getUrl() == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");com.alibaba.dubbo.common.URL url = arg0.getUrl();
String extName = url.getParameter("proxy", "javassist");
if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.ProxyFactory) name from url(" + url.toString() + ") use keys([proxy])");
com.alibaba.dubbo.rpc.ProxyFactory extension = (com.alibaba.dubbo.rpc.ProxyFactory)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.ProxyFactory.class).getExtension(extName);
return extension.getProxy(arg0);
}

public com.alibaba.dubbo.rpc.Invoker getInvoker(java.lang.Object arg0, java.lang.Class arg1, com.alibaba.dubbo.common.URL arg2) throws java.lang.Object {
if (arg2 == null) throw new IllegalArgumentException("url == null");
com.alibaba.dubbo.common.URL url = arg2;
String extName = url.getParameter("proxy", "javassist");
if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.ProxyFactory) name from url(" + url.toString() + ") use keys([proxy])");
com.alibaba.dubbo.rpc.ProxyFactory extension = (com.alibaba.dubbo.rpc.ProxyFactory)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.ProxyFactory.class).getExtension(extName);
return extension.getInvoker(arg0, arg1, arg2);
}
}

 以上两个类就是生成的源码code；

通过Javassist 进行将类进行加载成字节码 com.alibaba.dubbo.common.compiler.support.JavassistCompiler    

总的来说就二步：

1.通过Dubbo 扩展机制 ExtensionLoader 生成一个接口的自定义实现类源码；
2.通过javassist 将生成的源码转换为字节码加载进入内存

关于Protocol 与 ProxyFactory 这两个动态的实现类，内部又是进行了spi机制的一些方法调用；大家看一看，因为下面的一些扩展都是基于这两个的，不然很难知道它进行调用了哪个实现类；当然还有 Transporter 接口实现等等也是该机制；

如下是Transport Adapter 源码：可以看出在没有指定传输的时候，默认使用的是netty

package com.alibaba.dubbo.remoting;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
public class Transporter$Adpative implements com.alibaba.dubbo.remoting.Transporter {
public com.alibaba.dubbo.remoting.Client connect(com.alibaba.dubbo.common.URL arg0, com.alibaba.dubbo.remoting.ChannelHandler arg1) throws com.alibaba.dubbo.common.URL {
if (arg0 == null) throw new IllegalArgumentException("url == null");
com.alibaba.dubbo.common.URL url = arg0;
String extName = url.getParameter("client", url.getParameter("transporter", "netty"));
if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.remoting.Transporter) name from url(" + url.toString() + ") use keys([client, transporter])");
com.alibaba.dubbo.remoting.Transporter extension = (com.alibaba.dubbo.remoting.Transporter)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.remoting.Transporter.class).getExtension(extName);
return extension.connect(arg0, arg1);
}
public com.alibaba.dubbo.remoting.Server bind(com.alibaba.dubbo.common.URL arg0, com.alibaba.dubbo.remoting.ChannelHandler arg1) throws com.alibaba.dubbo.common.URL {
if (arg0 == null) throw new IllegalArgumentException("url == null");
com.alibaba.dubbo.common.URL url = arg0;
String extName = url.getParameter("server", url.getParameter("transporter", "netty"));
if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.remoting.Transporter) name from url(" + url.toString() + ") use keys([server, transporter])");
com.alibaba.dubbo.remoting.Transporter extension = (com.alibaba.dubbo.remoting.Transporter)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.remoting.Transporter.class).getExtension(extName);
return extension.bind(arg0, arg1);
}
}

 关于高级特性就到这里，具体的还是要看getAdaptiveExtension() 方法实现，里面是进行了 StringBuilder  append 拼接源码生成新的类，再进行JAVAssist toClass() 操作，需要对

JAVAssist 了解，不了解，大约知道生成的新类长什么样子就好了；

 　(四) Netty(mina) 服务的启动，端口绑定

紧接着第二步的步伐，我们分析 doExportUrlsFor1Protocol();我们抛开一些小细节，具体看如下Mark 红色的部分

 //如果配置不是local则暴露为远程服务.(配置为local，则表示只暴露远程服务)
            if (! Constants.SCOPE_LOCAL.toString().equalsIgnoreCase(scope) ){
                if (logger.isInfoEnabled()) {
                    logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
                }
                if (registryURLs != null && registryURLs.size() > 0
                        && url.getParameter("register", true)) {
                    for (URL registryURL : registryURLs) {
                        url = url.addParameterIfAbsent("dynamic", registryURL.getParameter("dynamic"));
                        URL monitorUrl = loadMonitor(registryURL);
                        if (monitorUrl != null) {
                            url = url.addParameterAndEncoded(Constants.MONITOR_KEY, monitorUrl.toFullString());
                        }
                        if (logger.isInfoEnabled()) {
                            logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);
                        }
                        Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));

                        Exporter<?> exporter = protocol.export(invoker);
                        exporters.add(exporter);

proxyFactory 与 protocol 都是动态生成类，大家可以看第四部分我贴出来的动态生成的源码，就可以知道真正的实现类是哪一个（默认是javassist 的实现类）；

protocol 则是进行了aop 式的包装类，会将DubboProtocol 类 ProtocolFilterWrapper 类， ProtocolListenerWrapper类，RegistryProtocol 类的export()方法执行一边，为什么都会执行呢，请大家看 ExtensionLoader 的 createExtension 方法；如下：

private T createExtension(String name) {
　　　　　　//这个方法会从文件系统中获取name 所对应的value ，大家可以看看这个方法
        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);
            }
　　　　　　　　//ioc 操作
            injectExtension(instance);
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
　　　　　　　//aop 包装的操作,包装类你调用我我调用你，形成了一条执行链；
            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);
        }
    }

在调用 DubboProtocol 的export() 方法时候，会进行 openServer(url)操作；

 openServer(url);

private void openServer(URL url) {
        // find server.
        String key = url.getAddress();
        //client 也可以暴露一个只有server可以调用的服务。
        boolean isServer = url.getParameter(Constants.IS_SERVER_KEY,true);
        if (isServer) {
            ExchangeServer server = serverMap.get(key);
            if (server == null) {
                serverMap.put(key, createServer(url));
            } else {
                //server支持reset,配合override功能使用
                server.reset(url);
            }
        }
    }

检查是否开启过服务，没有的话，createServer(url);创建服务，这里大家就往下面点，会经过如下的过程：

 

会使用dubbo SPI 机制返回Transporter 传输对象，在我们不在xml 做任何配置的情况下，默认使用的是netty，我们可以看Javassist 生成的Transporter Adapter 源码：

package com.alibaba.dubbo.remoting;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
public class Transporter$Adpative implements com.alibaba.dubbo.remoting.Transporter {
public com.alibaba.dubbo.remoting.Client connect(com.alibaba.dubbo.common.URL arg0, com.alibaba.dubbo.remoting.ChannelHandler arg1) throws com.alibaba.dubbo.common.URL {
if (arg0 == null) throw new IllegalArgumentException("url == null");
com.alibaba.dubbo.common.URL url = arg0;
String extName = url.getParameter("client", url.getParameter("transporter", "netty"));
if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.remoting.Transporter) name from url(" + url.toString() + ") use keys([client, transporter])");
com.alibaba.dubbo.remoting.Transporter extension = (com.alibaba.dubbo.remoting.Transporter)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.remoting.Transporter.class).getExtension(extName);
return extension.connect(arg0, arg1);
}
public com.alibaba.dubbo.remoting.Server bind(com.alibaba.dubbo.common.URL arg0, com.alibaba.dubbo.remoting.ChannelHandler arg1) throws com.alibaba.dubbo.common.URL {
if (arg0 == null) throw new IllegalArgumentException("url == null");
com.alibaba.dubbo.common.URL url = arg0;
String extName = url.getParameter("server", url.getParameter("transporter", "netty"));
if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.remoting.Transporter) name from url(" + url.toString() + ") use keys([server, transporter])");
com.alibaba.dubbo.remoting.Transporter extension = (com.alibaba.dubbo.remoting.Transporter)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.remoting.Transporter.class).getExtension(extName);
return extension.bind(arg0, arg1);
}
}

如果使用mina ，我们可以在xml 做如下配置：

    <!-- 用dubbo协议在20880端口暴露服务 -->
    <dubbo:protocol name="dubbo" port="20881" transporter="mina" />

在实例化的时候会进行doOpen() 操作了，就是正常的netty api 流程了； 

public NettyServer(URL url, ChannelHandler handler) throws RemotingException{
        super(url, ChannelHandlers.wrap(handler, ExecutorUtil.setThreadName(url, SERVER_THREAD_POOL_NAME)));
    }

    @Override
    protected void doOpen() throws Throwable {
        NettyHelper.setNettyLoggerFactory();
        ExecutorService boss = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerBoss", true));
        ExecutorService worker = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerWorker", true));
        ChannelFactory channelFactory = new NioServerSocketChannelFactory(boss, worker, getUrl().getPositiveParameter(Constants.IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS));
        bootstrap = new ServerBootstrap(channelFactory);
        
        final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
        channels = nettyHandler.getChannels();
        // https://issues.jboss.org/browse/NETTY-365
        // https://issues.jboss.org/browse/NETTY-379
        // final Timer timer = new HashedWheelTimer(new NamedThreadFactory("NettyIdleTimer", true));
        bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
            public ChannelPipeline getPipeline() {
                NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec() ,getUrl(), NettyServer.this);
                ChannelPipeline pipeline = Channels.pipeline();
                /*int idleTimeout = getIdleTimeout();
                if (idleTimeout > 10000) {
                    pipeline.addLast("timer", new IdleStateHandler(timer, idleTimeout / 1000, 0, 0));
                }*/
                pipeline.addLast("decoder", adapter.getDecoder());
                pipeline.addLast("encoder", adapter.getEncoder());
                pipeline.addLast("handler", nettyHandler);
                return pipeline;
            }
        });
        // bind
        channel = bootstrap.bind(getBindAddress());
    }

通过分析，netty 服务创建流程就是spi 的各种调用，所以大家了解dubbo 就必须了解它的spi 机制；
这样，一个netty 服务就启动了.. 

　(五) 注册中心注册服务

注册中心我们以zookeeper 为例，也是Dubbo 推荐使用的注册中心以及生产部署中常用的；

注册中心的实现是 protocol 执行链中的RegistryProtocol 类中的export 方法

实现主要是CURATOR 框架进行节点的创建以及监听

我们看节点的创建过程：

　递归创建节点，其中url地址是临时的节点，客户端断开会消失，其他的像/dubbo/接口地址 是永久的节点:如下图