Spring框架从2.0版本开始,提供了基于Schema风格的Spring XML格式用来定义bean的扩展机制。引入Schema-based XML是为了对Traditional的XML配置形式进行简化。通过Schema的定义，把一些原本需要通过几个bean的定义或者复杂的bean的组合定义的配置形式，用另外一种简单而可读的配置形式呈现出来。

Schema-based XML由三部分构成，我们由一幅图说明：

Dubbo源码(三) 与Spring集成 - 图1

  • namespace —— 拥有很明确的逻辑分类
  • element —— 拥有很明确的过程语义
  • attributes —— 拥有很简明的配置选项

例如，<mvc:annotation-driven />这段配置想要表达的意思，就是在mvc的空间内实现Annotation驱动的配置方式。其中，mvc表示配置的有效范围，annotation-driven则表达了一个动态的过程，实际的逻辑含义是：整个SpringMVC的实现是基于Annotation模式，请为我注册相关的行为模式。

在之前的文章中提到过如何自定义Schema实现。在Spring的内部也大量使用自定义的Schema。
Spring Extensible XML

Dubbo源码(三) 与Spring集成 - 图2

在dubbo中也通过这种自定义Schema的形式简化它的使用与配置。

DubboNamespaceHandler.java

  1. public class DubboNamespaceHandler extends NamespaceHandlerSupport {
  3.     static {
  4.         Version.checkDuplicate(DubboNamespaceHandler.class);
  5.     }
  7.     public void init() {
  8.         registerBeanDefinitionParser("application", new DubboBeanDefinitionParser(ApplicationConfig.class, true));
  9.         registerBeanDefinitionParser("module", new DubboBeanDefinitionParser(ModuleConfig.class, true));
  10.         registerBeanDefinitionParser("registry", new DubboBeanDefinitionParser(RegistryConfig.class, true));
  11.         registerBeanDefinitionParser("monitor", new DubboBeanDefinitionParser(MonitorConfig.class, true));
  12.         registerBeanDefinitionParser("provider", new DubboBeanDefinitionParser(ProviderConfig.class, true));
  13.         registerBeanDefinitionParser("consumer", new DubboBeanDefinitionParser(ConsumerConfig.class, true));
  14.         registerBeanDefinitionParser("protocol", new DubboBeanDefinitionParser(ProtocolConfig.class, true));
  15.         registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));
  16.         registerBeanDefinitionParser("reference", new DubboBeanDefinitionParser(ReferenceBean.class, false));
  17.         registerBeanDefinitionParser("annotation", new DubboBeanDefinitionParser(AnnotationBean.class, true));
  18.     }
  20. }

如下图所示：
image.png

1. Dubbo的Api方式调用实例

在dubbo中provider通过ServiceConfig创建服务信息，并且通过调用export()方法发布并暴露服务到注册中心提供给consumer使用。下面是dubbo官网给出的Java provider API使用。

  1. import com.alibaba.dubbo.rpc.config.ApplicationConfig;
  2. import com.alibaba.dubbo.rpc.config.RegistryConfig;
  3. import com.alibaba.dubbo.rpc.config.ProviderConfig;
  4. import com.alibaba.dubbo.rpc.config.ServiceConfig;
  5. import com.xxx.XxxService;
  6. import com.xxx.XxxServiceImpl;
  8. // 服务实现
  9. XxxService xxxService = new XxxServiceImpl();
  11. // 当前应用配置
  12. ApplicationConfig application = new ApplicationConfig();
  13. application.setName("xxx");
  15. // 连接注册中心配置
  16. RegistryConfig registry = new RegistryConfig();
  17. registry.setAddress("10.20.130.230:9090");
  18. registry.setUsername("aaa");
  19. registry.setPassword("bbb");
  21. // 服务提供者协议配置
  22. ProtocolConfig protocol = new ProtocolConfig();
  23. protocol.setName("dubbo");
  24. protocol.setPort(12345);
  25. protocol.setThreads(200);
  27. // 注意：ServiceConfig为重对象，内部封装了与注册中心的连接，以及开启服务端口
  29. // 服务提供者暴露服务配置
  30. ServiceConfig<XxxService> service = new ServiceConfig<XxxService>(); // 此实例很重，封装了与注册中心的连接，请自行缓存，否则可能造成内存和连接泄漏
  31. service.setApplication(application);
  32. service.setRegistry(registry); // 多个注册中心可以用setRegistries()
  33. service.setProtocol(protocol); // 多个协议可以用setProtocols()
  34. service.setInterface(XxxService.class);
  35. service.setRef(xxxService);
  36. service.setVersion("1.0.0");
  38. // 暴露及注册服务
  39. service.export();

在consumer端通过ReferenceConfig创建引用服务信息，并且通过get()方法获取到调用远程服务的代理对象。下面是dubbo官网提供的Java consumer API使用demo.

  1. import com.alibaba.dubbo.rpc.config.ApplicationConfig;
  2. import com.alibaba.dubbo.rpc.config.RegistryConfig;
  3. import com.alibaba.dubbo.rpc.config.ConsumerConfig;
  4. import com.alibaba.dubbo.rpc.config.ReferenceConfig;
  5. import com.xxx.XxxService;
  7. // 当前应用配置
  8. ApplicationConfig application = new ApplicationConfig();
  9. application.setName("yyy");
  11. // 连接注册中心配置
  12. RegistryConfig registry = new RegistryConfig();
  13. registry.setAddress("10.20.130.230:9090");
  14. registry.setUsername("aaa");
  15. registry.setPassword("bbb");
  17. // 注意：ReferenceConfig为重对象，内部封装了与注册中心的连接，以及与服务提供方的连接
  19. // 引用远程服务
  20. ReferenceConfig<XxxService> reference = new ReferenceConfig<XxxService>(); // 此实例很重，封装了与注册中心的连接以及与提供者的连接，请自行缓存，否则可能造成内存和连接泄漏
  21. reference.setApplication(application);
  22. reference.setRegistry(registry); // 多个注册中心可以用setRegistries()
  23. reference.setInterface(XxxService.class);
  24. reference.setVersion("1.0.0");
  26. // 和本地bean一样使用xxxService
  27. XxxService xxxService = reference.get(); // 注意：此代理对象内部封装了所有通讯细节，对象较重，请缓存复用

2.Dubbo的XML方式调用实例

  1. //生产者
  2. public class ProviderXml {
  3.     public static void main(String[] args) {
  4.         ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:spring/dubbo-server.xml");
  6.         ctx.start();
  7.         System.out.println("---------dubbo启动成功--------");
  9.         // 保证服务一直开着
  10.         synchronized (ProviderXml.class) {
  11.             try {
  12.                 ProviderXml.class.wait();
  13.             } catch (Throwable e) {
  14.             }
  15.         }
  16.     }
  17. }
  19. //消费者
  20. public class ConsumerXml {
  21.     public static void main(String[] args) {
  22.         ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:spring/dubbo-client.xml");
  24.         ctx.start();
  25.         System.out.println("---------dubbo启动成功--------");
  26.         // get remote service proxy
  27.         DemoService demoService = (DemoService) ctx.getBean("demoService");
  29.         String username = orderService.getUsername();
  30.         System.out.println(" ConsumerXml result: " + username);
  31.     }
  32. }

通过Spring的自定义Schema可以创建ServiceConfig对象和ReferenceConfig对象(XML方式调用)
下面我们再来看一下dubbo通过自定义Schema是如何配置dubbo里面的核心组件的呢？

  1. // classpath:spring/dubbo-server.xml
  2. <?xml version="1.0" encoding="UTF-8"?>
  3. <beans xmlns="http://www.springframework.org/schema/beans"
  4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
  7.     <!-- 提供方应用信息，用于计算依赖关系 -->
  8.     <dubbo:application name="hello-world-app"  />
  10.     <!-- 使用multicast广播注册中心暴露服务地址 -->
  11.     <dubbo:registry address="multicast://224.5.6.7:1234" />
  13.     <!-- 用dubbo协议在20880端口暴露服务 -->
  14.     <dubbo:protocol name="dubbo" port="20880" />
  16.     <!-- 声明需要暴露的服务接口 -->
  17.     <dubbo:service interface="com.weimob.o2o.carl.provider.DemoService" ref="demoService" />
  19.     <!-- 和本地bean一样实现服务 -->
  20.     <bean id="demoService" class="com.weimob.o2o.carl.provider.impl.DemoServiceImpl" />
  22. </beans>

image.png

然后通过DubboNamespaceHandler注册的的service把xml解析成ServiceBean。这个Bean是继承自上面提到的ServiceConfig。然后通过利用Spring的生命周期在实例化bean的时候会调用org.springframework.beans.factory.InitializingBean#afterPropertiesSet方法。它最终会调用com.alibaba.dubbo.config.ServiceConfig#export方法进行服务暴露。

image.png

而对于服务引用Dubbo也是同样的套路。首先我们来看一下consumer的xml配置。

  2. <?xml version="1.0" encoding="UTF-8"?>
  3. <beans xmlns="http://www.springframework.org/schema/beans"
  4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
  7.     <!-- 消费方应用名，用于计算依赖关系，不是匹配条件，不要与提供方一样 -->
  8.     <dubbo:application name="consumer-of-helloworld-app"  />
  10.     <!-- 使用multicast广播注册中心暴露发现服务地址 -->
  11.     <dubbo:registry address="multicast://224.5.6.7:1234" />
  13.     <!-- 生成远程服务代理，可以和本地bean一样使用demoService -->
  14.     <dubbo:reference id="demoService" interface="com.weimob.o2o.carl.provider.DemoService" />
  16. </beans>

它也是通过DubboNamespaceHandler注册的的reference把xml解析成ReferenceBean。这个Bean是继承自上面提到的ReferenceConfig。然后通过利用Spring的生命周期在实例化bean的时候会调用org.springframework.beans.factory.InitializingBean#afterPropertiesSet方法。它最终会调用com.alibaba.dubbo.config.ReferenceConfig#get方法远程服务调用代理类的创建。

image.png