1.源码分析

1.1分析服务导出入口

当容器为spring是dubbo会为容器注册两个监听器:DubboLifecycleComponentApplicationListener和DubboBootstrapApplicationListener。第一个监听器主要负责从容器中获取org.apache.dubbo.common.context.Lifecycle的实现类并调用start()方法

  1.     @Override
  2.     protected void onApplicationContextEvent(ApplicationContextEvent event) {
  3.         if (event instanceof ContextRefreshedEvent) {
  4.             onContextRefreshedEvent((ContextRefreshedEvent) event);
  5.         } else if (event instanceof ContextClosedEvent) {
  6.             onContextClosedEvent((ContextClosedEvent) event);
  7.         }
  8.     }
  10.     protected void onContextRefreshedEvent(ContextRefreshedEvent event) {
  11.         initLifecycleComponents(event);
  12.         startLifecycleComponents();
  13.     }
  15.     private void loadLifecycleComponents(List<Lifecycle> lifecycleComponents, ApplicationContext context) {
  16.         lifecycleComponents.addAll(beansOfTypeIncludingAncestors(context, Lifecycle.class).values());
  17.     }
  19.     private void startLifecycleComponents() {
  20.         lifecycleComponents.forEach(Lifecycle::start);
  21.     }

第二个监听器负责启动dubboBootstrap

  1.     @Override
  2.     public void onApplicationContextEvent(ApplicationContextEvent event) {
  3.         if (event instanceof ContextRefreshedEvent) {
  4.             onContextRefreshedEvent((ContextRefreshedEvent) event);
  5.         } else if (event instanceof ContextClosedEvent) {
  6.             onContextClosedEvent((ContextClosedEvent) event);
  7.         }
  8.     }
  10.     private void onContextRefreshedEvent(ContextRefreshedEvent event) {
  11.         dubboBootstrap.start();
  12.     }

这个start()方法最终会调用获取到所有的ServiceBean对象并挨个export，执行链如下

  1. org.apache.dubbo.config.bootstrap.DubboBootstrap#start
  2.     org.apache.dubbo.config.bootstrap.DubboBootstrap#exportServices
  4.         private void exportServices() {
  5.         configManager.getServices().forEach(sc -> {
  6.             // TODO, compatible with ServiceConfig.export()
  7.             ServiceConfig serviceConfig = (ServiceConfig) sc;
  8.             serviceConfig.setBootstrap(this);
  10.             if (exportAsync) {
  11.                 ExecutorService executor = executorRepository.getServiceExporterExecutor();
  12.                 Future<?> future = executor.submit(() -> {
  13.                     //服务开始导出
  14.                     sc.export();
  15.                 });
  16.                 asyncExportingFutures.add(future);
  17.             } else {
  18.                 sc.export();
  19.                 exportedServices.add(sc);
  20.             }
  21.         });
  22.     }
  1. //这个方法从整体上来看就做了三件事
  2. //①实例并初始化bootstrap
  3. //②对当前对象做属性的检查和赋值
  4. //③调用doExport()方法
  5. public synchronized void export() {
  6.         if (!shouldExport()) {
  7.             return;
  8.         }
  10.         if (bootstrap == null) {
  11.             bootstrap = DubboBootstrap.getInstance();
  12.             bootstrap.init();
  13.         }
  15.         checkAndUpdateSubConfigs();
  17.         //init serviceMetadata
  18.         serviceMetadata.setVersion(version);
  19.         serviceMetadata.setGroup(group);
  20.         serviceMetadata.setDefaultGroup(group);
  21.         serviceMetadata.setServiceType(getInterfaceClass());
  22.         serviceMetadata.setServiceInterfaceName(getInterface());
  23.         serviceMetadata.setTarget(getRef());
  25.         if (shouldDelay()) {
  26.             DELAY_EXPORT_EXECUTOR.schedule(this::doExport, getDelay(), TimeUnit.MILLISECONDS);
  27.         } else {
  28.             doExport();
  29.         }
  30.     }

1.2 检查配置

先看checkAndUpdateSubConfigs()这个方法中具体做了什么事

  1. private void checkAndUpdateSubConfigs() {
  2.         // Use default configs defined explicitly with global scope
  3.      	//用于检测 provider、application 等核心配置类对象是否为空，
  4.     	// 若为空，则尝试从其他配置类对象中获取相应的实例。
  5.         completeCompoundConfigs();
  6.     	//检测provider属性是否为空,若为空则new一个ProviderConfig并refresh
  7.         checkDefault();
  8.     	//检测protocol属性
  9.         checkProtocol();
  10.         // if protocol is not injvm checkRegistry
  11.     	//检测protocols数量是否为1，并且名字是injvm
  12.         if (!isOnlyInJvm()) {
  13.             checkRegistry();
  14.         }
  15.         this.refresh();
  17.         if (StringUtils.isEmpty(interfaceName)) {
  18.             throw new IllegalStateException("<dubbo:service interface=\"\" /> interface not allow null!");
  19.         }
  20. 		// 检测 ref 是否为泛化服务类型
  21.         if (ref instanceof GenericService) {
  22.             // 设置 interfaceClass 为 GenericService.class
  23.             interfaceClass = GenericService.class;
  24.             if (StringUtils.isEmpty(generic)) {
  25.                 // 设置 generic = "true"
  26.                 generic = Boolean.TRUE.toString();
  27.             }
  28.         } else {
  29.             // ref 非 GenericService 类型
  30.             try {
  31.                 // 对 interfaceClass，以及 <dubbo:method> 标签中的必要字段进行检查
  32.                 interfaceClass = Class.forName(interfaceName, true, Thread.currentThread()
  33.                         .getContextClassLoader());
  34.             } catch (ClassNotFoundException e) {
  35.                 throw new IllegalStateException(e.getMessage(), e);
  36.             }
  37.             // 对 ref 合法性进行检测
  38.             checkInterfaceAndMethods(interfaceClass, getMethods());
  39.             checkRef();
  40.             generic = Boolean.FALSE.toString();
  41.         }
  42.     	// local 和 stub 在功能应该是一致的，用于配置本地存根
  43.         if (local != null) {
  44.             if ("true".equals(local)) {
  45.                 local = interfaceName + "Local";
  46.             }
  47.             Class<?> localClass;
  48.             try {
  49.                 localClass = ClassUtils.forNameWithThreadContextClassLoader(local);
  50.             } catch (ClassNotFoundException e) {
  51.                 throw new IllegalStateException(e.getMessage(), e);
  52.             }
  53.             if (!interfaceClass.isAssignableFrom(localClass)) {
  54.                 throw new IllegalStateException("The local implementation class " + localClass.getName() + " not implement interface " + interfaceName);
  55.             }
  56.         }
  57.         if (stub != null) {
  58.             if ("true".equals(stub)) {
  59.                 stub = interfaceName + "Stub";
  60.             }
  61.             Class<?> stubClass;
  62.             try {
  63.                 stubClass = ClassUtils.forNameWithThreadContextClassLoader(stub);
  64.             } catch (ClassNotFoundException e) {
  65.                 throw new IllegalStateException(e.getMessage(), e);
  66.             }
  67.             if (!interfaceClass.isAssignableFrom(stubClass)) {
  68.                 throw new IllegalStateException("The stub implementation class " + stubClass.getName() + " not implement interface " + interfaceName);
  69.             }
  70.         }
  71.         checkStubAndLocal(interfaceClass);
  72.         // 检测各种对象是否为空，为空则新建，或者抛出异常
  73.         ConfigValidationUtils.checkMock(interfaceClass, this);
  74.         ConfigValidationUtils.validateServiceConfig(this);
  75.     	//动态添加一些参数(通过SPI机制调用org.apache.dubbo.config.AppendParametersComponent实现类并调用appendExportParameters方法将，ServiceConfig对象传入)
  76.         appendParameters();
  77.     }

下面对配置检查的逻辑进行简单的总结，如下：

  1. 检测 <dubbo:service> 标签的 interface 属性合法性，不合法则抛出异常
  2. 检测 ProviderConfig、ApplicationConfig 等核心配置类对象是否为空，若为空，则尝试从其他配置类对象中获取相应的实例。
  3. 检测并处理泛化服务和普通服务类
  4. 检测本地存根配置，并进行相应的处理
  5. 对 ApplicationConfig、RegistryConfig等配置类进行检测，为空则尝试创建，若无法创建则抛出异常
  1. //dispathch方法暂时不做分析
  2. protected synchronized void doExport() {
  3.         if (unexported) {
  4.             throw new IllegalStateException("The service " + interfaceClass.getName() + " has already unexported!");
  5.         }
  6.         if (exported) {
  7.             return;
  8.         }
  9.         exported = true;
  11.         if (StringUtils.isEmpty(path)) {
  12.             path = interfaceName;
  13.         }
  14.         doExportUrls();
  16.         // dispatch a ServiceConfigExportedEvent since 2.7.4
  17.         dispatch(new ServiceConfigExportedEvent(this));
  18.     }

1.3多协议多注册中心导出服务

  1. private void doExportUrls() {
  2.     	//首先将服务导入本地
  3.         ServiceRepository repository = ApplicationModel.getServiceRepository();
  4.         ServiceDescriptor serviceDescriptor = repository.registerService(getInterfaceClass());
  5.         repository.registerProvider(
  6.                 getUniqueServiceName(),
  7.                 ref,
  8.                 serviceDescriptor,
  9.                 this,
  10.                 serviceMetadata
  11.         );
  12. 		// 加载注册中心链接
  13.         List<URL> registryURLs = ConfigValidationUtils.loadRegistries(this, true);
  15.     	// 遍历 protocols，并在每个协议下导出服务
  16.         for (ProtocolConfig protocolConfig : protocols) {
  17.             String pathKey = URL.buildKey(getContextPath(protocolConfig)
  18.                     .map(p -> p + "/" + path)
  19.                     .orElse(path), group, version);
  20.             // In case user specified path, register service one more time to map it to path.
  21.             repository.registerService(pathKey, interfaceClass);
  22.             // TODO, uncomment this line once service key is unified
  23.             serviceMetadata.setServiceKey(pathKey);
  24.             doExportUrlsFor1Protocol(protocolConfig, registryURLs);
  25.         }
  26.     }

  2. public static List<URL> loadRegistries(AbstractInterfaceConfig interfaceConfig, boolean provider) {
  3.         // check && override if necessary
  4.         List<URL> registryList = new ArrayList<URL>();
  5.     	//获取全局配置
  6.         ApplicationConfig application = interfaceConfig.getApplication();
  7.     	//获取注册中心配置集合
  8.         List<RegistryConfig> registries = interfaceConfig.getRegistries();
  9.         if (CollectionUtils.isNotEmpty(registries)) {
  10.             for (RegistryConfig config : registries) {
  11.                 String address = config.getAddress();
  12.                 if (StringUtils.isEmpty(address)) {
  13.                     address = ANYHOST_VALUE;
  14.                 }
  15.                 if (!RegistryConfig.NO_AVAILABLE.equalsIgnoreCase(address)) {
  16.                     Map<String, String> map = new HashMap<String, String>();
  17.                     // 添加 ApplicationConfig 中的字段信息到 map 中
  18.                     AbstractConfig.appendParameters(map, application);
  19.                     // 添加 RegistryConfig 字段信息到 map 中
  20.                     AbstractConfig.appendParameters(map, config);
  21.                     // 添加 path、pid，protocol 等信息到 map 中
  22.                     map.put(PATH_KEY, RegistryService.class.getName());
  23.                     AbstractInterfaceConfig.appendRuntimeParameters(map);
  24.                     if (!map.containsKey(PROTOCOL_KEY)) {
  25.                         map.put(PROTOCOL_KEY, DUBBO_PROTOCOL);
  26.                     }
  27.                     // 解析得到 URL 列表，address 可能包含多个注册中心 ip，
  28.                 	// 因此解析得到的是一个 URL 列表
  29.                     List<URL> urls = UrlUtils.parseURLs(address, map);
  31.                     for (URL url : urls) {
  33.                         url = URLBuilder.from(url)
  34.                                 .addParameter(REGISTRY_KEY, url.getProtocol())
  35.                                 .setProtocol(extractRegistryType(url))
  36.                                 .build();
  37.                         if ((provider && url.getParameter(REGISTER_KEY, true))
  38.                                 || (!provider && url.getParameter(SUBSCRIBE_KEY, true))) {
  39.                             registryList.add(url);
  40.                         }
  41.                     }
  42.                 }
  43.             }
  44.         }
  45.         return registryList;
  46.     }

loadRegistries 方法主要包含如下的逻辑：

  1. 构建参数映射集合，也就是 map
  2. 构建注册中心链接列表
  3. 遍历链接列表，并根据条件决定是否将其添加到 registryList 中

1.4组装 URL

配置检查完毕后，紧接着要做的事情是根据配置，以及其他一些信息组装 URL。URL 是 Dubbo 配置的载体，通过 URL 可让 Dubbo 的各种配置在各个模块之间传递。URL 之于 Dubbo，犹如水之于鱼，非常重要。大家在阅读 Dubbo 服务导出相关源码的过程中，要注意 URL 内容的变化。既然 URL 如此重要，那么下面我们来了解一下 URL 组装的过程。

  1. private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
  2.         String name = protocolConfig.getName();
  3.     	// 如果协议名为空，或空串，则将协议名变量设置为 dubbo
  4.         if (StringUtils.isEmpty(name)) {
  5.             name = DUBBO;
  6.         }
  7.         Map<String, String> map = new HashMap<String, String>();
  8.         map.put(SIDE_KEY, PROVIDER_SIDE);
  9.     	// 通过反射将对象的字段信息添加到 map 中
  10.         ServiceConfig.appendRuntimeParameters(map);
  11.         AbstractConfig.appendParameters(map, getMetrics());
  12.         AbstractConfig.appendParameters(map, getApplication());
  13.         AbstractConfig.appendParameters(map, getModule());
  14.         // remove 'default.' prefix for configs from ProviderConfig
  15.         // appendParameters(map, provider, Constants.DEFAULT_KEY);
  16.         AbstractConfig.appendParameters(map, provider);
  17.         AbstractConfig.appendParameters(map, protocolConfig);
  18.         AbstractConfig.appendParameters(map, this);
  19.     	// methods 为 MethodConfig 集合，MethodConfig 中存储了 <dubbo:method> 标签的配置信息
  20.     	//由于太繁琐了就是配置标签的解析就跳过
  21.         if (CollectionUtils.isNotEmpty(getMethods())) {
  22.             for (MethodConfig method : getMethods()) {
  23.                 AbstractConfig.appendParameters(map, method, method.getName());
  24.                 String retryKey = method.getName() + ".retry";
  25.                 if (map.containsKey(retryKey)) {
  26.                     String retryValue = map.remove(retryKey);
  27.                     if ("false".equals(retryValue)) {
  28.                         map.put(method.getName() + ".retries", "0");
  29.                     }
  30.                 }
  31.                 List<ArgumentConfig> arguments = method.getArguments();
  32.                 if (CollectionUtils.isNotEmpty(arguments)) {
  33.                     for (ArgumentConfig argument : arguments) {
  34.                         // convert argument type
  35.                         if (argument.getType() != null && argument.getType().length() > 0) {
  36.                             Method[] methods = interfaceClass.getMethods();
  37.                             // visit all methods
  38.                             if (methods != null && methods.length > 0) {
  39.                                 for (int i = 0; i < methods.length; i++) {
  40.                                     String methodName = methods[i].getName();
  41.                                     // target the method, and get its signature
  42.                                     if (methodName.equals(method.getName())) {
  43.                                         Class<?>[] argtypes = methods[i].getParameterTypes();
  44.                                         // one callback in the method
  45.                                         if (argument.getIndex() != -1) {
  46.                                             if (argtypes[argument.getIndex()].getName().equals(argument.getType())) {
  47.                                                 AbstractConfig.appendParameters(map, argument, method.getName() + "." + argument.getIndex());
  48.                                             } else {
  49.                                                 throw new IllegalArgumentException("Argument config error : the index attribute and type attribute not match :index :" + argument.getIndex() + ", type:" + argument.getType());
  50.                                             }
  51.                                         } else {
  52.                                             // multiple callbacks in the method
  53.                                             for (int j = 0; j < argtypes.length; j++) {
  54.                                                 Class<?> argclazz = argtypes[j];
  55.                                                 if (argclazz.getName().equals(argument.getType())) {
  56.                                                     AbstractConfig.appendParameters(map, argument, method.getName() + "." + j);
  57.                                                     if (argument.getIndex() != -1 && argument.getIndex() != j) {
  58.                                                         throw new IllegalArgumentException("Argument config error : the index attribute and type attribute not match :index :" + argument.getIndex() + ", type:" + argument.getType());
  59.                                                     }
  60.                                                 }
  61.                                             }
  62.                                         }
  63.                                     }
  64.                                 }
  65.                             }
  66.                         } else if (argument.getIndex() != -1) {
  67.                             AbstractConfig.appendParameters(map, argument, method.getName() + "." + argument.getIndex());
  68.                         } else {
  69.                             throw new IllegalArgumentException("Argument config must set index or type attribute.eg: <dubbo:argument index='0' .../> or <dubbo:argument type=xxx .../>");
  70.                         }
  72.                     }
  73.                 }
  74.             } // end of methods for
  75.         }
  77.     	// 检测 generic 是否为 "true"，并根据检测结果向 map 中添加不同的信息
  78.         if (ProtocolUtils.isGeneric(generic)) {
  79.             map.put(GENERIC_KEY, generic);
  80.             map.put(METHODS_KEY, ANY_VALUE);
  81.         } else {
  82.             String revision = Version.getVersion(interfaceClass, version);
  83.             if (revision != null && revision.length() > 0) {
  84.                 map.put(REVISION_KEY, revision);
  85.             }
  86. 			// 为接口生成包裹类 Wrapper，Wrapper 中包含了接口的详细信息，比如接口方法名数组，字段信息等
  87.             String[] methods = Wrapper.getWrapper(interfaceClass).getMethodNames();
  88.             if (methods.length == 0) {
  89.                 logger.warn("No method found in service interface " + interfaceClass.getName());
  90.                 map.put(METHODS_KEY, ANY_VALUE);
  91.             } else {
  92.                  // 将逗号作为分隔符连接方法名，并将连接后的字符串放入 map 中
  93.                 map.put(METHODS_KEY, StringUtils.join(new HashSet<String>(Arrays.asList(methods)), ","));
  94.             }
  95.         }
  96.     	// 添加 token 到 map 中
  97.         if (!ConfigUtils.isEmpty(token)) {
  98.             if (ConfigUtils.isDefault(token)) {
  99.                 map.put(TOKEN_KEY, UUID.randomUUID().toString());
  100.             } else {
  101.                 map.put(TOKEN_KEY, token);
  102.             }
  103.         }
  104.         //init serviceMetadata attachments
  105.         serviceMetadata.getAttachments().putAll(map);
  107.         // export service
  108.     	// 获取 host 和 port
  109.         String host = findConfigedHosts(protocolConfig, registryURLs, map);
  110.         Integer port = findConfigedPorts(protocolConfig, name, map);
  111.     	// 组装 URL
  112.         URL url = new URL(name, host, port, getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), map);
  114.        .....省略
  115.     }

1.5导出 Dubbo 服务

  1. private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
  2.  ...省略
  3.       // You can customize Configurator to append extra parameters
  4.         if (ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
  5.                 .hasExtension(url.getProtocol())) {
  6.              // 加载 ConfiguratorFactory，并生成 Configurator 实例，然后通过实例配置 url
  7.             url = ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
  8.                     .getExtension(url.getProtocol()).getConfigurator(url).configure(url);
  9.         }
  11.         String scope = url.getParameter(SCOPE_KEY);
  12.         // don't export when none is configured
  13.     	// 如果 scope = none，则什么都不做
  14.         if (!SCOPE_NONE.equalsIgnoreCase(scope)) {
  16.             // export to local if the config is not remote (export to remote only when config is remote)
  17.             // scope != remote，导出到本地
  18.             if (!SCOPE_REMOTE.equalsIgnoreCase(scope)) {
  19.                 exportLocal(url);
  20.             }
  21.             // export to remote if the config is not local (export to local only when config is local)
  22.             // scope != local，导出到远程
  23.             if (!SCOPE_LOCAL.equalsIgnoreCase(scope)) {
  24.                 if (CollectionUtils.isNotEmpty(registryURLs)) {
  25.                     for (URL registryURL : registryURLs) {
  26.                         //if protocol is only injvm ,not register
  27.                         if (LOCAL_PROTOCOL.equalsIgnoreCase(url.getProtocol())) {
  28.                             continue;
  29.                         }
  30.                         url = url.addParameterIfAbsent(DYNAMIC_KEY, registryURL.getParameter(DYNAMIC_KEY));
  31.                         // 加载监视器链接
  32.                         URL monitorUrl = ConfigValidationUtils.loadMonitor(this, registryURL);
  33.                         if (monitorUrl != null) {
  34.                             // 将监视器链接作为参数添加到 url 中
  35.                             url = url.addParameterAndEncoded(MONITOR_KEY, monitorUrl.toFullString());
  36.                         }
  37.                         if (logger.isInfoEnabled()) {
  38.                             if (url.getParameter(REGISTER_KEY, true)) {
  39.                                 logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);
  40.                             } else {
  41.                                 logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
  42.                             }
  43.                         }
  45.                         // For providers, this is used to enable custom proxy to generate invoker
  46.                         String proxy = url.getParameter(PROXY_KEY);
  47.                         if (StringUtils.isNotEmpty(proxy)) {
  48.                             registryURL = registryURL.addParameter(PROXY_KEY, proxy);
  49.                         }
  51.                         // 为服务提供类(ref)生成 Invoker
  52.                         Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString()));
  53.                          // DelegateProviderMetaDataInvoker 用于持有 Invoker 和 ServiceConfig
  54.                         DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
  56.                         // 导出服务，并生成 Exporter
  57.                         Exporter<?> exporter = protocol.export(wrapperInvoker);
  58.                         exporters.add(exporter);
  59.                     }
  60.                 } else {
  61.                   	// 不存在注册中心，仅导出服务
  62.                     if (logger.isInfoEnabled()) {
  63.                         logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
  64.                     }
  65.                     Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, url);
  66.                     DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
  68.                     Exporter<?> exporter = protocol.export(wrapperInvoker);
  69.                     exporters.add(exporter);
  70.                 }
  71.                 /**
  72.                  * @since 2.7.0
  73.                  * ServiceData Store
  74.                  */
  75.                 WritableMetadataService metadataService = WritableMetadataService.getExtension(url.getParameter(METADATA_KEY, DEFAULT_METADATA_STORAGE_TYPE));
  76.                 if (metadataService != null) {
  77.                     metadataService.publishServiceDefinition(url);
  78.                 }
  79.             }
  80.         }
  81.         this.urls.add(url);
  82. }

上面代码根据 url 中的 scope 参数决定服务导出方式，分别如下：

  • scope = none，不导出服务
  • scope != remote，导出到本地
  • scope != local，导出到远程

不管是导出到本地，还是远程。进行服务导出之前，均需要先创建 Invoker，这是一个很重要的步骤。因此下面先来分析 Invoker 的创建过程。

1.4 Invoker 创建过程

在 Dubbo 中，Invoker 是一个非常重要的模型。在服务提供端，以及服务引用端均会出现 Invoker。Dubbo 官方文档中对 Invoker 进行了说明，这里引用一下。

Invoker 是实体域，它是 Dubbo 的核心模型，其它模型都向它靠扰，或转换成它，它代表一个可执行体，可向它发起 invoke 调用，它有可能是一个本地的实现，也可能是一个远程的实现，也可能一个集群实现。

既然 Invoker 如此重要，那么我们很有必要搞清楚 Invoker 的用途。Invoker 是由 ProxyFactory 创建而来，Dubbo 默认的 ProxyFactory 实现类是 JavassistProxyFactory。下面我们到 JavassistProxyFactory 代码中，探索 Invoker 的创建过程。如下：

  1.     @Override
  2.     public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
  3.         // TODO Wrapper cannot handle this scenario correctly: the classname contains '$'
  4.         // 为目标类创建 Wrapper
  5.         final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
  6.         // 创建匿名 Invoker 类对象，并实现 doInvoke 方法。
  7.         return new AbstractProxyInvoker<T>(proxy, type, url) {
  8.             @Override
  9.             protected Object doInvoke(T proxy, String methodName,
  10.                                       Class<?>[] parameterTypes,
  11.                                       Object[] arguments) throws Throwable {
  12.                 return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
  13.             }
  14.         };
  15.     }
  1. //
  2. // Source code recreated from a .class file by IntelliJ IDEA
  3. // (powered by Fernflower decompiler)
  4. //
  5. //这是通过javassist生成的接口实现的包装类(通过idea反编译过后)
  6. package org.apache.dubbo.common.bytecode;
  8. import java.lang.reflect.InvocationTargetException;
  9. import java.util.Map;
  10. import org.apache.dubbo.common.bytecode.ClassGenerator.DC;
  11. import org.apache.dubbo.demo.GreetingService;
  13. public class Wrapper0 extends Wrapper implements DC {
  14.     //属性名称数组
  15.     public static String[] pns;
  16.     // pts 用于存储成员变量名和类型
  17.     public static Map pts;
  18.     // mns 为方法名列表
  19.     public static String[] mns;
  20.     // dmns 用于存储“定义在当前类中的方法”的名称
  21.     public static String[] dmns;
  22.     public static Class[] mts0;
  24.     public String[] getPropertyNames() {
  25.         return pns;
  26.     }
  28.     public boolean hasProperty(String var1) {
  29.         return pts.containsKey(var1);
  30.     }
  32.     public Class getPropertyType(String var1) {
  33.         return (Class)pts.get(var1);
  34.     }
  36.     public String[] getMethodNames() {
  37.         return mns;
  38.     }
  40.     public String[] getDeclaredMethodNames() {
  41.         return dmns;
  42.     }
  44.     public void setPropertyValue(Object var1, String var2, Object var3) {
  45.         try {
  46.             GreetingService var4 = (GreetingService)var1;
  47.         } catch (Throwable var6) {
  48.             throw new IllegalArgumentException(var6);
  49.         }
  51.         throw new NoSuchPropertyException("Not found property \"" + var2 + "\" field or setter method in class org.apache.dubbo.demo.GreetingService.");
  52.     }
  54.     public Object getPropertyValue(Object var1, String var2) {
  55.         try {
  56.             GreetingService var3 = (GreetingService)var1;
  57.         } catch (Throwable var5) {
  58.             throw new IllegalArgumentException(var5);
  59.         }
  61.         throw new NoSuchPropertyException("Not found property \"" + var2 + "\" field or setter method in class org.apache.dubbo.demo.GreetingService.");
  62.     }
  64.     public Object invokeMethod(Object var1, String var2, Class[] var3, Object[] var4) throws InvocationTargetException {
  65.         GreetingService var5;
  66.         try {
  67.             var5 = (GreetingService)var1;
  68.         } catch (Throwable var8) {
  69.             throw new IllegalArgumentException(var8);
  70.         }
  72.         try {
  73.             if ("hello".equals(var2) && var3.length == 0) {
  74.                 return var5.hello();
  75.             }
  76.         } catch (Throwable var9) {
  77.             throw new InvocationTargetException(var9);
  78.         }
  80.         throw new NoSuchMethodException("Not found method \"" + var2 + "\" in class org.apache.dubbo.demo.GreetingService.");
  81.     }
  83.     public Wrapper0() {
  84.     }
  85. }

1.7导出服务到本地

本节我们来看一下服务导出相关的代码，按照代码执行顺序，本节先来分析导出服务到本地的过程。相关代码如下：

  1. private void exportLocal(URL url) {
  2.     //构建injvm:127.0.0.1...
  3.     //并在本地导出服务
  4.     URL local = URLBuilder.from(url)
  5.             .setProtocol(LOCAL_PROTOCOL)
  6.             .setHost(LOCALHOST_VALUE)
  7.             .setPort(0)
  8.             .build();
  9.     Exporter<?> exporter = protocol.export(
  10.             PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, local));
  11.     exporters.add(exporter);
  12.     logger.info("Export dubbo service " + interfaceClass.getName() + " to local registry url : " + local);
  13. }

1.8导出服务到远程

与导出服务到本地相比，导出服务到远程的过程要复杂不少，其包含了服务导出与服务注册两个过程。这两个过程涉及到了大量的调用，比较复杂。按照代码执行顺序，本节先来分析服务导出逻辑，服务注册逻辑将在下一节进行分析。下面开始分析，我们把目光移动到 RegistryProtocol 的 export 方法上。

  1. public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
  2.     	//尝试将url中的协议替换成映射register的值,并删除register
  3.     	//zookeeper://127.0.0.1:2181/org.apache.dubbo.registry.RegistryService?application=demo-provider&dubbo=2.0.2&export=dubbo%3A%2F%2F192.168.1.6%3A20880%2Forg.apache.dubbo.demo.DemoService%3Fanyhost%3Dtrue%26application%3Ddemo-provider%26bind.ip%3D192.168.1.6%26bind.port%3D20880%26deprecated%3Dfalse%26dubbo%3D2.0.2%26dynamic%3Dtrue%26generic%3Dfalse%26interface%3Dorg.apache.dubbo.demo.DemoService%26metadata-type%3Dremote%26methods%3DsayHello%2CsayHelloAsync%26pid%3D3972%26qos.port%3D22222%26release%3D%26side%3Dprovider%26timestamp%3D1585222934666&metadata-type=remote&pid=3972&qos.port=22222&timestamp=1585222934636
  4.         URL registryUrl = getRegistryUrl(originInvoker);
  6.     	//获取映射export的值并解析成url
  7.         URL providerUrl = getProviderUrl(originInvoker);
  9.     	//将providerUrl的协议修改为provider并添加category和check两个属性
  10.         final URL overrideSubscribeUrl = getSubscribedOverrideUrl(providerUrl);
  11.      	// 创建监听器
  12.         final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
  13.         overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
  15.         providerUrl = overrideUrlWithConfig(providerUrl, overrideSubscribeListener);
  16.         //export invoker
  17.         final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker, providerUrl);
  19.         // 根据 URL 加载 Registry 实现类，比如 ZookeeperRegistry
  20.         final Registry registry = getRegistry(originInvoker);
  21.      	// 获取已注册的服务提供者 URL，比如：
  22.         final URL registeredProviderUrl = getUrlToRegistry(providerUrl, registryUrl);
  23.         // 获取 register 参数
  24.         boolean register = providerUrl.getParameter(REGISTER_KEY, true);
  25.     	// 根据 register 的值决定是否注册服务
  26.         if (register) {
  27.             register(registryUrl, registeredProviderUrl);
  28.         }
  30.         // 向注册中心进行订阅 override 数据
  31.         registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
  33.         exporter.setRegisterUrl(registeredProviderUrl);
  34.         exporter.setSubscribeUrl(overrideSubscribeUrl);
  36.         notifyExport(exporter);
  37.         // 创建并返回 DestroyableExporter
  38.         return new DestroyableExporter<>(exporter);
  39.     }

上面代码看起来比较复杂，主要做如下一些操作：

  1. 调用 doLocalExport 导出服务
  2. 向注册中心注册服务
  3. 向注册中心进行订阅 override 数据
  4. 创建并返回 DestroyableExporter

在以上操作中，除了创建并返回 DestroyableExporter 没什么难度外，其他几步操作都不是很简单。这其中，导出服务和注册服务是本章要重点分析的逻辑。 订阅 override 数据并非本文重点内容，后面会简单介绍一下。下面先来分析 doLocalExport 方法的逻辑，如下：

  1.     private <T> ExporterChangeableWrapper<T> doLocalExport(final Invoker<T> originInvoker, URL providerUrl) {
  2.         String key = getCacheKey(originInvoker);
  3.         //若缓存中没有与key映射的value则执行lambda表达式并将key与lambda表达式返回值做映射
  4.         return (ExporterChangeableWrapper<T>) bounds.computeIfAbsent(key, s -> {
  5.             // 创建 Invoker 为委托类对象
  6.             Invoker<?> invokerDelegate = new InvokerDelegate<>(originInvoker, providerUrl);
  7.             // 调用 protocol 的 export 方法导出服务
  8.             return new ExporterChangeableWrapper<>((Exporter<T>) protocol.export(invokerDelegate), originInvoker);
  9.         });
  10.     }

上面的protocol首先会通过dubbo的SPI机制依次执行Protocol的wapper实现类的export方法（构建protocol的Filter链和listener链），最终会走到invokerDelegate中url的协议的实现类（本例中为dubbo）

  1. public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
  2.         URL url = invoker.getUrl();
  4. 		// 获取服务标识，理解成服务坐标也行。由服务组名，服务名，服务版本号以及端口组成。比如：
  5.     	// demoGroup/com.alibaba.dubbo.demo.DemoService:1.0.1:20880
  6.         String key = serviceKey(url);
  7.     	// 创建 DubboExporter
  8.         DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
  9.     	// 将 <key, exporter> 键值对放入缓存中
  10.         exporterMap.put(key, exporter);
  12.         // 本地存根相关代码
  13.         Boolean isStubSupportEvent = url.getParameter(STUB_EVENT_KEY, DEFAULT_STUB_EVENT);
  14.         Boolean isCallbackservice = url.getParameter(IS_CALLBACK_SERVICE, false);
  15.         if (isStubSupportEvent && !isCallbackservice) {
  16.             String stubServiceMethods = url.getParameter(STUB_EVENT_METHODS_KEY);
  17.             if (stubServiceMethods == null || stubServiceMethods.length() == 0) {
  18.                 if (logger.isWarnEnabled()) {
  19.                     logger.warn(new IllegalStateException("consumer [" + url.getParameter(INTERFACE_KEY) +
  20.                             "], has set stubproxy support event ,but no stub methods founded."));
  21.                 }
  23.             }
  24.         }
  25. 		// 启动服务器
  26.         openServer(url);
  27.     	// 优化序列化
  28.         optimizeSerialization(url);
  30.         return exporter;
  31.     }

如上，我们重点关注 DubboExporter 的创建以及 openServer 方法，其他逻辑看不懂也没关系，不影响理解服务导出过程。另外，DubboExporter 的代码比较简单，就不分析了。下面分析 openServer 方法。

  1. private void openServer(URL url) {
  2.     // 获取 host:port，并将其作为服务器实例的 key，用于标识当前的服务器实例
  3.     String key = url.getAddress();
  4.     boolean isServer = url.getParameter(Constants.IS_SERVER_KEY, true);
  5.     if (isServer) {
  6.         // 访问缓存
  7.         ExchangeServer server = serverMap.get(key);
  8.         if (server == null) {
  9.             // 创建服务器实例
  10.             serverMap.put(key, createServer(url));
  11.         } else {
  12.             // 服务器已创建，则根据 url 中的配置重置服务器
  13.             server.reset(url);
  14.         }
  15.     }
  16. }

如上，在同一台机器上（单网卡），同一个端口上仅允许启动一个服务器实例。若某个端口上已有服务器实例，此时则调用 reset 方法重置服务器的一些配置。接下来分析createServer方法。

  1. private ProtocolServer createServer(URL url) {
  2.         url = URLBuilder.from(url)
  3.                 // send readonly event when server closes, it's enabled by default
  4.                 .addParameterIfAbsent(CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString())
  5.                 // 添加心跳检测配置到 url 中
  6.                 .addParameterIfAbsent(HEARTBEAT_KEY, String.valueOf(DEFAULT_HEARTBEAT))
  7.             	// 添加编码解码器参数
  8.                 .addParameter(CODEC_KEY, DubboCodec.NAME)
  9.                 .build();
  10.         String str = url.getParameter(SERVER_KEY, DEFAULT_REMOTING_SERVER);
  12.     	// 通过 SPI 检测是否存在 server 参数所代表的 Transporter 拓展，不存在则抛出异常
  13.         if (str != null && str.length() > 0 && !ExtensionLoader.getExtensionLoader(Transporter.class).hasExtension(str)) {
  14.             throw new RpcException("Unsupported server type: " + str + ", url: " + url);
  15.         }
  17.         ExchangeServer server;
  18.         try {
  19.             // 创建 ExchangeServer
  20.             server = Exchangers.bind(url, requestHandler);
  21.         } catch (RemotingException e) {
  22.             throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
  23.         }
  25.     	// 获取 client 参数，可指定 netty，mina,grizzly
  26.     	// 同样通过SPI检测是否存在 client 参数所代表的 Transporter 拓展，不存在则抛出异常
  27.         str = url.getParameter(CLIENT_KEY);
  28.         if (str != null && str.length() > 0) {
  29.             Set<String> supportedTypes = ExtensionLoader.getExtensionLoader(Transporter.class).getSupportedExtensions();
  30.             if (!supportedTypes.contains(str)) {
  31.                 throw new RpcException("Unsupported client type: " + str);
  32.             }
  33.         }
  35.         return new DubboProtocolServer(server);
  36.     }

如上，createServer 包含三个核心的逻辑。第一是检测是否存在 server 参数所代表的 Transporter 拓展，不存在则抛出异常。第二是创建服务器实例。第三是检测是否支持 client 参数所表示的 Transporter 拓展，不存在也是抛出异常。两次检测操作所对应的代码比较直白了，无需多说。但创建服务器的操作目前还不是很清晰，我们继续往下看。

  1.     public static ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
  2.         if (url == null) {
  3.             throw new IllegalArgumentException("url == null");
  4.         }
  5.         if (handler == null) {
  6.             throw new IllegalArgumentException("handler == null");
  7.         }
  8.         url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
  9.         // 获取 Exchanger，默认为 HeaderExchanger。
  10.    	    // 紧接着调用 HeaderExchanger 的 bind 方法创建 ExchangeServer 实例
  11.         return getExchanger(url).bind(url, handler);
  12.     }
  1. public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
  2. 	// 创建 HeaderExchangeServer 实例，该方法包含了多个逻辑，分别如下：
  3. 	//   1. new HeaderExchangeHandler(handler)
  4. 	//	 2. new DecodeHandler(new HeaderExchangeHandler(handler))
  5. 	//   3. Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler)))
  6.     return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
  7. }

HeaderExchanger 的 bind 方法包含的逻辑比较多，但目前我们仅需关心 Transporters 的 bind 方法逻辑即可。该方法的代码如下：

  1. public static Server bind(URL url, ChannelHandler... handlers) throws RemotingException {
  2.     if (url == null) {
  3.         throw new IllegalArgumentException("url == null");
  4.     }
  5.     if (handlers == null || handlers.length == 0) {
  6.         throw new IllegalArgumentException("handlers == null");
  7.     }
  8.     ChannelHandler handler;
  9.     if (handlers.length == 1) {
  10.         handler = handlers[0];
  11.     } else {
  12.     	// 如果 handlers 元素数量大于1，则创建 ChannelHandler 分发器
  13.         handler = new ChannelHandlerDispatcher(handlers);
  14.     }
  15.     // 获取自适应 Transporter 实例，并调用实例方法
  16.     return getTransporter().bind(url, handler);
  17. }

如上，getTransporter() 方法获取的 Transporter 是在运行时动态创建的，类名为 TransporterAdaptive，也就是自适应拓展类。TransporterAdaptive 会在运行时根据传入的 URL 参数决定加载什么类型的 Transporter，默认为 NettyTransporter。下面我们继续跟下去，这次分析的是 NettyTransporter 的 bind 方法。

  1. public Server bind(URL url, ChannelHandler listener) throws RemotingException {
  2. 	// 创建 NettyServer
  3. 	return new NettyServer(url, listener);
  4. }

这里仅有一句创建 NettyServer 的代码，无需多说，我们继续向下看。

  1. public class NettyServer extends AbstractServer implements Server {
  2.     public NettyServer(URL url, ChannelHandler handler) throws RemotingException {
  3.         // 调用父类构造方法
  4.         super(url, ChannelHandlers.wrap(handler, ExecutorUtil.setThreadName(url, SERVER_THREAD_POOL_NAME)));
  5.     }
  6. }
  8. public abstract class AbstractServer extends AbstractEndpoint implements Server {
  9.     public AbstractServer(URL url, ChannelHandler handler) throws RemotingException {
  10.         // 调用父类构造方法，这里就不用跟进去了，没什么复杂逻辑
  11.         super(url, handler);
  12.         localAddress = getUrl().toInetSocketAddress();
  14.         // 获取 ip 和端口
  15.         String bindIp = getUrl().getParameter(Constants.BIND_IP_KEY, getUrl().getHost());
  16.         int bindPort = getUrl().getParameter(Constants.BIND_PORT_KEY, getUrl().getPort());
  17.         if (url.getParameter(Constants.ANYHOST_KEY, false) || NetUtils.isInvalidLocalHost(bindIp)) {
  18.             // 设置 ip 为 0.0.0.0
  19.             bindIp = NetUtils.ANYHOST;
  20.         }
  21.         bindAddress = new InetSocketAddress(bindIp, bindPort);
  22.         // 获取最大可接受连接数
  23.         this.accepts = url.getParameter(Constants.ACCEPTS_KEY, Constants.DEFAULT_ACCEPTS);
  24.         this.idleTimeout = url.getParameter(Constants.IDLE_TIMEOUT_KEY, Constants.DEFAULT_IDLE_TIMEOUT);
  25.         try {
  26.             // 调用模板方法 doOpen 启动服务器
  27.             doOpen();
  28.         } catch (Throwable t) {
  29.             throw new RemotingException("Failed to bind ");
  30.         }
  32.         DataStore dataStore = ExtensionLoader.getExtensionLoader(DataStore.class).getDefaultExtension();
  33.         executor = (ExecutorService) dataStore.get(Constants.EXECUTOR_SERVICE_COMPONENT_KEY, Integer.toString(url.getPort()));
  34.     }
  36.     protected abstract void doOpen() throws Throwable;
  38.     protected abstract void doClose() throws Throwable;
  39. }

上面代码多为赋值代码，不需要多讲。我们重点关注 doOpen 抽象方法，该方法需要子类实现。下面回到 NettyServer 中。

  1. protected void doOpen() throws Throwable {
  2.     NettyHelper.setNettyLoggerFactory();
  3.     // 创建 boss 和 worker 线程池
  4.     ExecutorService boss = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerBoss", true));
  5.     ExecutorService worker = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerWorker", true));
  6.     ChannelFactory channelFactory = new NioServerSocketChannelFactory(boss, worker, getUrl().getPositiveParameter(Constants.IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS));
  8.     // 创建 ServerBootstrap
  9.     bootstrap = new ServerBootstrap(channelFactory);
  11.     final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
  12.     channels = nettyHandler.getChannels();
  13.     bootstrap.setOption("child.tcpNoDelay", true);
  14.     // 设置 PipelineFactory
  15.     bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
  16.         @Override
  17.         public ChannelPipeline getPipeline() {
  18.             NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec(), getUrl(), NettyServer.this);
  19.             ChannelPipeline pipeline = Channels.pipeline();
  20.             pipeline.addLast("decoder", adapter.getDecoder());
  21.             pipeline.addLast("encoder", adapter.getEncoder());
  22.             pipeline.addLast("handler", nettyHandler);
  23.             return pipeline;
  24.         }
  25.     });
  26.     // 绑定到指定的 ip 和端口上
  27.     channel = bootstrap.bind(getBindAddress());
  28. }

以上就是 NettyServer 创建的过程，dubbo 默认使用的 NettyServer 是基于 netty 3.x 版本实现的，比较老了。因此 Dubbo 另外提供了 netty 4.x 版本的 NettyServer，大家可在使用 Dubbo 的过程中按需进行配置。

Dubbo 服务导出-Version2.7.5的更多相关文章

  1. RPC -dubbo 服务导出实现

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

  2. Dubbo 服务引入-Version2.7.5

    1.服务引用原理 Dubbo 服务引用的时机有两个,第一个是在 Spring 容器调用 ReferenceBean 的 afterPropertiesSet 方法时引用服务,第二个是在 Referen ...

  3. Dubbo 源码分析 - 服务导出

    1.服务导出过程 本篇文章,我们来研究一下 Dubbo 导出服务的过程.Dubbo 服务导出过程始于 Spring 容器发布刷新事件,Dubbo 在接收到事件后,会立即执行服务导出逻辑.整个逻辑大致可 ...

  4. dubbo源码阅读之服务导出

    dubbo服务导出 常见的使用dubbo的方式就是通过spring配置文件进行配置.例如下面这样 <?xml version="1.0" encoding="UTF ...

  5. Dubbo源码阅读-服务导出

    Dubbo服务导出过程始于Spring容器发布刷新事件,Dubbo在接收到事件后,会立即执行服务导出逻辑.整个逻辑大致可分为三个部分,第一部分是前置工作,主要用于检查参数,组装URL.第二部分是导出服 ...

  6. Dubbo源码(三) - 服务导出（生产者）

    前言 本文基于Dubbo2.6.x版本,中文注释版源码已上传github:xiaoguyu/dubbo 在了解了Dubbo SPI后,我们来了解下Dubbo服务导出的过程. Dubbo的配置是通过Du ...

  7. Dubbo源码学习之-服务导出

    前言 忙的时候,会埋怨学习的时间太少,缺少个人的空间,于是会争分夺秒的工作.学习.而一旦繁忙的时候过去,有时间了之后,整个人又会不自觉的陷入一种懒散的状态中,时间也显得不那么重要了,随便就可以浪费掉几 ...

  8. 跟我学习dubbo-使用Maven构建Dubbo服务的可执行jar包(4)

    Dubbo服务的运行方式: 1.使用Servlet容器运行(Tomcat.Jetty等)----不可取 缺点:增加复杂性(端口.管理) 浪费资源(内存) 官方:服务容器是一个standalone的启动 ...

  9. dubbo系列四、dubbo服务暴露过程源码解析

    一.代码准备 1.示例代码 参考dubbo系列二.dubbo+zookeeper+dubboadmin分布式服务框架搭建(windows平台) 2.简单了解下spring自定义标签 https://w ...

随机推荐

  1. spring boot:用dynamic-datasource-spring-boot-starter配置多数据源访问seata(seata 1.3.0 / spring boot 2.3.3)

    一,dynamic-datasource-spring-boot-starter的优势? 1,dynamic-datasource-spring-boot-starter 是一个基于springboo ...

  2. STM32中断

    STM32的中断分两个类型:内核异常和外部中断. 内核异常不能够被打断,不能被设置优先级(它的优先级是凌驾于外部中断之上的).常见的内核异常有以下几种:复位(reset),不可屏蔽中断(NMI),硬错 ...

  3. MySQL备份和恢复[1]-概述

    备份类型 完全备份,部分备份 完全备份:整个数据集 部分备份:只备份数据子集,如部分库或表 完全备份.增量备份.差异备份 增量备份:仅备份最近一次完全备份或增量备份(如果存在增量)以来变化的数据,备份 ...

  4. 微信小程序-基于高德地图API实现天气组件(动态效果)

    微信小程序-基于高德地图API实现天气组件(动态效果) ​ 在社区翻腾了许久,没有找到合适的天气插件.迫不得已,只好借鉴互联网上的web项目,手动迁移到小程序中使用.现在分享到互联网社区中,帮助后续有 ...

  5. SpringMVC异常的处理机制

    SpringMVC异常的处理机制 处理流程图 其本质还是把异常交给SpringMVC框架来处理 系统的dao.service.controller出现异常都通过throws Exception向上抛出 ...

  6. 基于web的图书管理系统设计与实现（附演示地址）

    欢迎访问博主个人网站,记得收藏哦,点击查看 - - - >>>> 公众号推荐:计算机类毕业设计系统源码,IT技术文章分享,游戏源码,网页模板 小程序推荐:网站资源快速收录--百 ...

  7. 开发笔记：PDF生成文字和图片水印

    背景 团队手里在做的一个项目,其中一个小功能是用户需要上传PDF文件到文件服务器上,都是一些合同或者技术评估文档,鉴于知识版权和防伪的目的,需要在上传的PDF文件打上水印, 这时候我们需要提供能力给客 ...

  8. mapstruct 快速使用

    mapstruct 快速使用 mapstruct 主要的作用则是用来复制对象字段使用,功能非常的强大.在没有使用 mapstruct 之前可能都在使用 BeanUtils ,但是 BeanUtils ...

  9. Alibaba Spring Cloud 微服务介绍(一）

    " Spring Cloud Alibaba 致力于提供微服务开发的一站式解决方案.此项目包含开发分布式应用服务的必需组件,方便开发者通过 Spring Cloud 编程模型轻松使用这些组件 ...

  10. JVM详解（二）-- 第2章 类加载器子系统

    一.JVM内存结构 1.1 内存结构---概略图 1.2 内存结构--详细图 二.类加载器子系统的作用 类加载器子系统负责从文件系统或网络中加载.Class文件,文件需要有特定的标识(cafe bab ...