public synchronized void export() {
	// 检查服务是否已发布
	if(export.get()) {
		LoggerUtil.warn(String.format("%s has already been expoted, so ignore the export request!", interfaceClass.getName()));
		return;
	}

	// 检查发布服务的接口和方法是否存在和正确
	checkInterfaceAndMethods(interfaceClass, methods);

	// 加载注册中心配置地址 Zookeeper或者Consul服务地址
	List<URL> registryUrls = loadRegistryUrls();
	if(registryUrls == null || registryUrls.size() == 0) {
		throw new IllegalStateException("Should set registry config for service:" + interfaceClass.getName());
	}

	// 加载服务协议配置的服务发布地址和端口
	Map<String, Integer> protocolPorts = getProtocolAndPort();
	// protocols 哪里来的？？？ServiceConfigBean里创建，实现了InitializingBean接口的afterPropertiesSet方法
	for(ProtocolConfig protocolConfig : protocols) {
		Integer port = protocolPorts.get(protocolConfig.getId());
		if(port == null) {
			throw new MotanServiceException(String.format("Unknow port in service:%s, protocol:%s", interfaceClass.getName(),
                        protocolConfig.getId()));
		}
		// 发布服务
		doExport(protocolConfig, port, registryUrls);
	}

	// 将服务添加到已注册服务列表
	afterExport();
}

private void doExport(ProtocolConfig protocolConfig, int port, List<URL> registryUrls) {
	String protocolName = protocolConfig.getName();
	if(protocolName == null || protocolName.length() == 0) {
		protocolName = URLParamType.protocol.getValue();// 默认协议“motan”
	}

	// 设置本地IP
	String hostAddress = host;
	if(StringUtils.isBlank(hostAddress) && basicServiceConfig != null) {
		hostAddress = basicServiceConfig.getHost();
	}
	if(NetUtils.isInvalidLocalHost(hostAddress)) {
		hostAddress = getLocalHostAddress(registryUrls);
	}

	Map<String, String> map = new HashMap<String, String>();

	map.put(URLParamType.nodeType.getName(), MotanConstants.NODE_TYPE_SERVICE);
	map.put(URLParamType.refreshTimestamp.getName(), String.valueOf(System.currentTimeMillis()));

	// 加载配置文件参数
	collectConfigParams(map, protocolConfig, basicServiceConfig, extConfig, this);
	collectMethodConfigParams(map, this.getMethods());

	// 构建服务URL
	URL serviceUrl = new URL(protocolName, hostAddress, port, interfaceClass.getName(), map);

	if(serviceExists(serviceUrl)) {
		LoggerUtil.warn(String.format("%s configService is malformed, for same service (%s) already exists ", interfaceClass.getName(),
                    serviceUrl.getIdentity()));
            throw new MotanFrameworkException(String.format("%s configService is malformed, for same service (%s) already exists ",
                    interfaceClass.getName(), serviceUrl.getIdentity()), MotanErrorMsgConstant.FRAMEWORK_INIT_ERROR);
	}

	List<URL> urls = new ArrayList<URL>();

	// injvm 协议只支持注册到本地，其他协议可以注册到local、remote
	if(MotanConstants.PROTOCOL_INJVM.equals(protocolConfig.getId())) {
		...
	} else {
		for (URL ru : registryUrls) {
			urls.add(ru.createCopy());// 为什么要copy？？？
		}
	}

	for(URL u : urls) {
		u.addParameter(URLParamType.embed.getName(), StringTools.urlEncode(serviceUrl.toFullStr()));
		registereUrls.add(u.createCopy());// ??? registereUrls
	}

	// 获取默认配置处理程序，发布服务 ？？？SimpleConfigHandler
	ConfigHandler configHandler = ExtensionLoader.getExtensionLoader(ConfigHelper.class).getExtension(MotanConstants.DEFAULT_VALUE);

	exporters.add(configHandler.export(interfaceClass, ref, urls));

	// 记录服务，用于日志统计作用
	initLocalAppInfo(serviceUrl);

}

@Override
public <T> Exporter<T> export(Class<T> interfaceClass, T ref, List<URL> registryUrls) {
	
	String serviceStr = StringTools.urlDecode(registryUrls.get(0).getParameter(URLParamType.embed.getName()));
	URL serviceUrl = URL.valueOf(serviceStr);

	// export Service 启动服务
	// 利用protocol decorator来增加filter特性
	String protocolName = serviceUrl.getParameter(URLParamType.protocol.getName(), URLParamType.protocol.getValue());
	Protocol protocol = new ProtocolFilterDecorator(ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(protocolName));
	// Provider ???
	Provider<T> provider = new DefaultProvider<T>(ref, serviceUrl, interfaceClass);
	Exporter<T> exporter = protocol.export(provider, serviceUrl);// ？？？

	// register service 注册服务
	register(registryUrls, serviceUrl);

	return exporter;
}

public class MotanNamespaceHandler extends NamespaceHandlerSupport {
	...

	@Override
	public void init() {
		// 解析标签 referer
		registerBeanDefinitionParser("referer", new MotanBeanDefinitionParser(RefererConfigBean.class, false));
		// 解析标签 service
		registerBeanDefinitionParser("service", new MotanBeanDefinitionParser(ServiceConfigBean.class, false));
		...
		Initializable initialization = InitializationFactory.getInitialization();
		initialization.init();
	}
}

@Override
public <T> Exporter<T> export(Provider<T> provider, URL url) {

	// 检查参数
	if(url == null)	{
		throw new MotanFrameworkException(this.getClass().getSimpleName() + " export Error: url is null", MotanErrorMsgConstant.FRAMEWORK_INIT_ERROR);
	}

	if(provider == null) {
		throw new MotanFrameworkException(this.getClass().getSimpleName() + " export Error: provider is null, url=" + url, MotanErrorMsgConstant.FRAMEWORK_INIT_ERROR);
	}

	// ???
	String protocolKey = MotanFrameworkUtil.getProtocolKey(url);

	synchronized(exporterMap) {
		Exporter<T> exporter = (Exporter<T>)exporterMap.get(protocolKey);

		if(exporter != null) {
			throw new MotanFrameworkException(this.getClass().getSimpleName() + " export Error: service already exist, url=" + url, MotanErrorMsgConstant.FRAMEWORK_INIT_ERROR);
		}

		// 创建服务
		exporter = createExporter(provider, url);
		exporter.init();

		exporterMap.put(protocolKey, exporter);

		LoggerUtil.info(this.getClass().getSimpleName() + " export Success: url=" + url);

		return exporter;
	}
}

@Override
protected <T> Exporter<T> createExporter(Provider<T> provider, URL url) {
	return new DefaultRpcExporter<T>(provider, url);
}

	class DefaultRpcExporter<T> extends AbstractExporter<T> {
		private Server server;
		private EndpointFactory endpointFactory;

		public DefaultRpcExporter(Provider<T> provider, URL url) {
			super(provider, url);

			// 构建消息处理程序，用于方法的回调
			ProviderMessageRouter requestRouter = initRequestRouter(url);
			
			endpointFactory = ExtensionLoader.getExtensionLoader(EndpointFactory.class).getExtension(url.getParameter(URLParamType.endpointFactory.getName(), URLParamType.endpointFactory.getValue()));
			// 启动Netty Server服务
			server = endpointFactory.createServer(url, requestRouter);
		}
	}