带你手写基于 Spring 的可插拔式 RPC 框架（四）代理类的注入与服务启动

写一个 xsd 文件来自定义我们的标签和属性,注意 schema 的 xmlns 和
targetNamespace 属性， http://paul.com/schema。

在自定义的 BeanDefinitionParser 来对我们自定义标签的属性进行解析。
在 BeanDefinitionParser 里面我们可以使用 Spring 的一些组件，也可以只将我们自定的属性解析出来。parse 方法里面传入的两个参数，通过 element 可以获得 xml 中的属性信息，通过 parserContext 可以获取到 BeanDefinitionRegistry，熟悉 Spring 源码的同学应该知道这个类，我们可以通过这个类将我们的类注入到 Spring 容器中。
构造方法中的 beanClass 我们可以传入自己定义的类，将解析出来的属性赋值到类的属性中。

rpc:procotol 标签
这个标签中包含了协议类型，端口，序列化协议，注册中心地址和角色（服务端还是客户端）。这个标签解析中我们将一些属性赋值到了 Configuration 配置类中，根据属性选择了协议类型，如果是客户端，提前初始化出 channel 保存到阻塞队列中，提高并发能力，如果是客户端则启动通信服务器。

客户端 procotol 标签配置：

服务端 procotol 标签配置：

对应的解析器。

public class ProcotolBeanDefinitionParser implements BeanDefinitionParser {

     private final Class> beanClass;

     public ProcotolBeanDefinitionParser(Class> beanClass) {
         this.beanClass = beanClass;
     }


     @Override
     public BeanDefinition parse(Element element, ParserContext parserContext) {
         System.out.println("1");
         String pro = element.getAttribute("procotol");
         int port = Integer.parseInt(element.getAttribute("port"));
         Configuration.getInstance().setProcotol(pro);
         Configuration.getInstance().setPort(port);
         Configuration.getInstance().setSerialize(element.getAttribute("serialize"));
         Configuration.getInstance().setStragety(element.getAttribute("stragety"));
         Configuration.getInstance().setRole(element.getAttribute("role"));
         Configuration.getInstance().setAddress(element.getAttribute("address"));
         if("provider".equals(element.getAttribute("role"))){
             Procotol procotol = null;
                 if("Dubbo".equalsIgnoreCase(pro)){
                     procotol = new DubboProcotol();
                 }else if("Http".equalsIgnoreCase(pro)){
                     procotol = new HttpProcotol();
                 }else if("Socket".equalsIgnoreCase(pro)){
                     procotol = new SocketProcotol();
                 }else{
                     procotol = new DubboProcotol();
                 }

                 try {
                     InetAddress addr = InetAddress.getLocalHost();
                     String ip = addr.getHostAddress();
                     if(port == 0){
                         port = 32115;
                     }
                     URL url = new URL(ip,port);
                     procotol.start(url);

                 } catch (Exception e) {
                     e.printStackTrace();
                 }
         }else{
             //获取服务注册中心
             ZookeeperRegisterCenter registerCenter4Consumer = ZookeeperRegisterCenter.getInstance();
             //初始化服务提供者列表到本地缓存
             registerCenter4Consumer.initProviderMap();
             //初始化Netty Channel
             Map> providerMap = registerCenter4Consumer.getServiceMetaDataMap4Consumer();
             if (MapUtils.isEmpty(providerMap)) {
                 throw new RuntimeException("service provider list is empty.");
             }
             NettyChannelPoolFactory.getInstance().initNettyChannelPoolFactory(providerMap);
         }
         return null;
     }
 }

rpc:provider 标签，这个是服务端服务发布标签。通过这个标签表明服务端想要将哪些服务发布出来。

对应的解析器：
将需要暴露的服务注册中 zookeeper。

public class ProviderBeanDefinitionParser implements BeanDefinitionParser {

     private final Class> beanClass;

     public ProviderBeanDefinitionParser(Class> beanClass) {
         this.beanClass = beanClass;
     }
     @Override
     public BeanDefinition parse(Element element, ParserContext parserContext) {
         System.out.println("15");
         String interfaces = element.getAttribute("interf");
         String impl = element.getAttribute("impl");

         int port = Configuration.getInstance().getPort();
         InetAddress addr = null;
         try {
             addr = InetAddress.getLocalHost();
             String ip = addr.getHostAddress();
             if(port == 0) {
                 port = 32115;
             }
             List providerList = new ArrayList();
             ServiceProvider providerService = new ServiceProvider();
             providerService.setProvider(Class.forName(interfaces));
             providerService.setServiceObject(impl);
             providerService.setIp(ip);
             providerService.setPort(port);
             providerService.setTimeout(5000);
             providerService.setServiceMethod(null);
             providerService.setApplicationName("");
             providerService.setGroupName("nettyrpc");
             providerList.add(providerService);

             //注册到zk,元数据注册中心
             RegisterCenter4Provider registerCenter4Provider = ZookeeperRegisterCenter.getInstance();
             registerCenter4Provider.registerProvider(providerList);

         } catch (UnknownHostException e) {
             e.printStackTrace();
         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         }
         return null;
     }
 }

rpc:service 标签，这个标签表明客户端需要调用哪些服务端的接口，将对应的代理类注入到 Spring 中，在成需中可以直接使用 @Autowired 注入这个代理类，就可以像调用本地服务一样调用远程服务了。

对应的解析器：
将接口的代理类注入到 Spring 中，并且将消费者也就是客户端注册到注册中心。

public class ServiceBeanDefinitionParser implements BeanDefinitionParser {

     private final Class> beanClass;

     public ServiceBeanDefinitionParser(Class> beanClass) {
         this.beanClass = beanClass;
     }




     @Override
     public BeanDefinition parse(Element element, ParserContext parserContext) {



         String interfaces = element.getAttribute("interfaces");
         String ref = element.getAttribute("ref");
         Class clazz = null;
         try {
             clazz = Class.forName(interfaces);
         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         }
         BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(clazz);
         GenericBeanDefinition definition = (GenericBeanDefinition) builder.getRawBeanDefinition();

         definition.getConstructorArgumentValues().addGenericArgumentValue(clazz);

         definition.setBeanClass(ProxyFactory.class);
         definition.setAutowireMode(GenericBeanDefinition.AUTOWIRE_BY_TYPE);

         BeanDefinitionRegistry beanDefinitionRegistry = parserContext.getRegistry();
         beanDefinitionRegistry.registerBeanDefinition(ref,definition);

         //获取服务注册中心
         ZookeeperRegisterCenter registerCenter4Consumer = ZookeeperRegisterCenter.getInstance();

         //将消费者信息注册到注册中心
         ServiceConsumer invoker = new ServiceConsumer();
         List consumers = new ArrayList();
         consumers.add(invoker);
         invoker.setConsumer(clazz);
         invoker.setServiceObject(interfaces);
         invoker.setGroupName("");
         registerCenter4Consumer.registerConsumer(consumers);

         return definition;
     }
 }

定义一个 NamespaceHandler 来注册对应的标签和 BeanDefinitionParser。

public class RpcNamespaceHandler extends NamespaceHandlerSupport {
     @Override
     public void init() {
         registerBeanDefinitionParser("procotol", new ProcotolBeanDefinitionParser(Configuration.class));
 //        registerBeanDefinitionParser("register", new RegisterBeanDefinitionParser(Configuration.class));
         registerBeanDefinitionParser("application", new ApplicationBeanDefinitionParser(Configuration.class));
         registerBeanDefinitionParser("provider", new ProviderBeanDefinitionParser(Configuration.class));
  //       registerBeanDefinitionParser("role", new ServerBeanDefinitionParser(Configuration.class));
         registerBeanDefinitionParser("service", new ServiceBeanDefinitionParser(Configuration.class));
     }
 }

在 Spring 中注册上面的 schema 和 handler。
spring.handlers, 这里要将 schema 和我们自定义的 handler 类 mapping 起来。

http\://paul.com/schema=com.paul.spring.RpcNamespaceHandler

spring.schema，表明 xsd 文件的位置。

http\://paul.com/schema/rpc.xsd=META-INF/rpc.xsd

通过上面的配置我们实现了根据配置来做通信协议，序列化协议的选择以及客户端代理类注入到 Spring 中方便我们以后调用，还实现了服务端的启动，以及对应注册到注册中心的功能。