dubbo-源码阅读之bean装配过程(四)

最新推荐文章于 2021-11-18 14:22:21 发布
最新推荐文章于 2021-11-18 14:22:21 发布
阅读量193 收藏
点赞数
文章标签： java 大数据
原文链接：http://www.cnblogs.com/LQBlog/p/9391229.html
版权

Spring自定义schema 

我们再使用dubbo进行时 会经常看到这样的标签

 <!--开启注解扫描-->
    <context:component-scan base-package="com.liqiang.service.impl"></context:component-scan>
    <!-- 提供方应用信息，用于计算依赖关系 -->
    <dubbo:application name="userSystemProvider"  />

    <!-- 服务注册中心地址 其他参数请看用户指南-->
    <dubbo:registry address="zookeeper://192.168.65.128:2181?backup=192.168.65.128:2182,192.168.65.128:2183" />
    <!-- 用dubbo协议在20880端口暴露服务 -->
    <dubbo:protocol name="dubbo" port="20880" />
    <!--发布服务-->
    <dubbo:service interface="com.liqiang.service.UserService" ref="userServiceImpl"></dubbo:service>
    <!--发布服务-->
    <dubbo:service interface="com.liqiang.service.ProductService" ref="productServiceImpl"></dubbo:service>

其实是利用spring2.0的对自定义schema的支持实现的 。下面我们模拟一一下dubbo的标签实现

1.添加POM依赖

    <properties>
        <springframework.version>4.0.0.RELEASE</springframework.version>
    </properties>
    <dependencies>
        <!-- **************************** Spring 依赖 **************************** -->
        <!-- 添加Spring-core包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <!-- 添加spring-tx包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <!-- Spring ORM 相关-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <!-- 添加spring-jdbc包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <!--添加spring-web包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <!-- 添加spring-context包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${springframework.version}</version>
        </dependency>

        <!--添加aspectjweaver包 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.5</version>
        </dependency>
    </dependencies>

2.创建xsd文件

在resource下创建文件xsd文件dubbo.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://liqiang/schema/dubbo"
            xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:beans="http://www.springframework.org/schema/beans"
            targetNamespace="http://liqiang/schema/dubbo" elementFormDefault="qualified"
            attributeFormDefault="unqualified">
    <xsd:import namespace="http://www.springframework.org/schema/beans" />
    <xsd:element name="server"><!--定义标签后缀名字-->
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:extension base="beans:identifiedType">
                    <xsd:attribute name="interface" type="xsd:string" use="required"/><！--标签属性定义-->
                    <xsd:attribute name="ref" type="xsd:string" use="required" />
                </xsd:extension>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>

</xsd:schema>
targetNamespace:为命名空间地址

3.创建自定义spring bean标签解析器

//定义自定义的scheme解析器
public class SimpleDateFormatBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
    protected Class getBeanClass(Element element) {
        return DubboConfig.class;
    }
    protected void doParse(Element element, BeanDefinitionBuilder bean) {
        String interfaceFullName = element.getAttribute("interface");
        String refName = element.getAttribute("ref");
        if (StringUtils.hasText(interfaceFullName)) {
            bean.addPropertyValue("interfaceFullName", interfaceFullName);
        }
        if (StringUtils.hasText(refName)) {
            bean.addPropertyValue("refName", refName);
        }
    }
}

4.注册自定义解析器Handle

/**
 * 注册自定义scheme解析器
 */
public class MyNamespaceHandler extends NamespaceHandlerSupport {
    public void init() {
        //必须是elementName
        registerBeanDefinitionParser("server", new SimpleDateFormatBeanDefinitionParser());
    }
}

5.注册之定义Handle与spring产生关联

1.在resource目录下创建META-INF目录并创建spring.handlers和spring.schemas文件

 

spring.handlers内容

 指向 自定义解析注册handle类的fullname

http\://liqiang/schema/dubbo=com.liqiang.test.MyNamespaceHandler

spring.schemas

http\://liqiang/schema/dubbo/dubbo.xsd=dubbo.xsd

6.创建spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://liqiang/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://liqiang/schema/dubbo http://liqiang/schema/dubbo/dubbo.xsd">
    <dubbo:server id="test" interface="com.liqiang.userService" ref="userServiceImpl"></dubbo:server>

</beans>

留意加粗备份为你自定义标签的命名空间和xsd

7.测试

public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-application.xml");
        DubboConfig dubboConfig = (DubboConfig) ctx.getBean("test");
        System.out.println(dubboConfig.getInterfaceFullName()+"|"+dubboConfig.getRefName());

    }

输出

 Dubbo对自定义Schame实现

我们知道 自定义Schame 需要定义解析器，和注册解析的handle  所以我们直接看dubbo对应的类就行了

DubboNamespaceHandler

    public void init() {
        this.registerBeanDefinitionParser("application", new DubboBeanDefinitionParser(ApplicationConfig.class, true));
        this.registerBeanDefinitionParser("module", new DubboBeanDefinitionParser(ModuleConfig.class, true));
        this.registerBeanDefinitionParser("registry", new DubboBeanDefinitionParser(RegistryConfig.class, true));
        this.registerBeanDefinitionParser("monitor", new DubboBeanDefinitionParser(MonitorConfig.class, true));
        this.registerBeanDefinitionParser("provider", new DubboBeanDefinitionParser(ProviderConfig.class, true));
        this.registerBeanDefinitionParser("consumer", new DubboBeanDefinitionParser(ConsumerConfig.class, true));
        this.registerBeanDefinitionParser("protocol", new DubboBeanDefinitionParser(ProtocolConfig.class, true));
        this.registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));
        this.registerBeanDefinitionParser("reference", new DubboBeanDefinitionParser(ReferenceBean.class, false));
        this.registerBeanDefinitionParser("annotation", new DubboBeanDefinitionParser(AnnotationBean.class, true));
    }

dubbo所有标签都是交给DubboBeanDefinitionParser解析的。内部根据传入的class判断是什么标签。并用对应的Config内进行封装

DubboBeanDefinitionParser

public class DubboBeanDefinitionParser implements BeanDefinitionParser {public DubboBeanDefinitionParser(Class<?> beanClass, boolean required) {
        this.beanClass = beanClass;
        this.required = required;
    }

    public BeanDefinition parse(Element element, ParserContext parserContext) {
        return parse(element, parserContext, this.beanClass, this.required);
    }

    private static BeanDefinition parse(Element element, ParserContext parserContext, Class<?> beanClass, boolean required) {
        RootBeanDefinition beanDefinition = new RootBeanDefinition();
        .........//省略部分代码
        if (ProtocolConfig.class.equals(beanClass)) {
            String[] arr$ = parserContext.getRegistry().getBeanDefinitionNames();
            len$ = arr$.length;

            for(int i$ = 0; i$ < len$; ++i$) {
                String name = arr$[i$];
                BeanDefinition definition = parserContext.getRegistry().getBeanDefinition(name);
                PropertyValue property = definition.getPropertyValues().getPropertyValue("protocol");
                if (property != null) {
                    Object value = property.getValue();
                    if (value instanceof ProtocolConfig && id.equals(((ProtocolConfig)value).getName())) {
                        definition.getPropertyValues().addPropertyValue("protocol", new RuntimeBeanReference(id));
                    }
                }
            }
        } else if (ServiceBean.class.equals(beanClass)) {
            className = element.getAttribute("class");
            if (className != null && className.length() > 0) {
                RootBeanDefinition classDefinition = new RootBeanDefinition();
                classDefinition.setBeanClass(ReflectUtils.forName(className));
                classDefinition.setLazyInit(false);
                parseProperties(element.getChildNodes(), classDefinition);
                beanDefinition.getPropertyValues().addPropertyValue("ref", new BeanDefinitionHolder(classDefinition, id + "Impl"));
            }
        } else if (ProviderConfig.class.equals(beanClass)) {
            parseNested(element, parserContext, ServiceBean.class, true, "service", "provider", id, beanDefinition);
        } else if (ConsumerConfig.class.equals(beanClass)) {
            parseNested(element, parserContext, ReferenceBean.class, false, "reference", "consumer", id, beanDefinition);
        }
       .......//省略部分代码
}

 注意 上面并没有立刻创建对应的对象到spring容器  而是通过BeanDefinition  进行封装 class 哪些参数等。。将beanDefinition交于spring框架初始化

转载于:https://www.cnblogs.com/LQBlog/p/9391229.html

denggouya9281
关注
dubbo源码解析(二)springBoot+dubbo案例整合
liushangzaibeijing的博客
05-17 6万+
本篇博文从springBoot+dubbo的整合示例出来，分析了duubo采用注解形式相关流程， 本文所解析的这些源码均不涉及dubbo的核心功能，仅仅是讲了dubbo启动之后，如何获取到配置，如果进行配置装配，方便大家后续有个好的理解
dubbo源码分析之八-dubbo的spi机制
热门推荐
liushangzaibeijing的博客
07-18 5万+
本片博文以spi机制为切入点，首先了解spi机制，介绍了java自己的SPI实现方式和源码分析，并通过其缺点引出了Dubbo的SPI机制，通过对其使用示例、流程、源码分析等详细分析了其相关流程，其中对ExtensionLoader、@Adaptive,@Activate,@SPI注解进行使用介绍。希望这边文章能让读者很好的了解java SPI和Dubbo的SPI机制。
7.1 服务暴露前的准备-ServiceBean的装配
weixin_33787529的博客
10-02 125
dubbo的服务暴露以第一章 第一个dubbo项目中的dubbo-demo-provider来讲述。 列出dubbo-demo-provider的xml配置： 1 &lt;?xml version="1.0" encoding="UTF-8"?&gt; 2 &lt;beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 3 ...
自定义Spring配置标签
loveyu0428的专栏
08-23 305
引言： 在Sping中，一般使用&lt;bean&gt;这样的元素来配置一个bean，Spring在创建容器的时候会扫描这些配置，根据配置创建对象存放于容器中，然后我们再从容器中取出，或者在配置其他bean的时候作为属性注入。使用bean配置的一个限制是我们必须遵循配置文件的XML Schema定义，这在大多数情况下不会出现问题。但是在一些情况下，我们希望实现更为灵活的bean配置。Spring...
Spring 实现自定义 bean 的扩展
古时的风筝
07-27 533
Spring mvc 提供了扩展 xml 的机制，用来编写自定义的 xml bean ，例如 dubbo 框架，就利用这个机制实现了好多的 dubbo bean，比如<dubbo:application> 、<dubbo:registry>等等，只要安装这个标准的扩展方式实现配置即可。 扩展自定义 bean 的意义何在 假设我们要使用一个开源框架或者一套 API，我们肯定希望以下两点： 易用性，即配置简单，要配置的地方越少越好 封装性，调用简单，也就是越高层封..
spring自定义标签之二 —— 规范定义XSD
sammor
06-23 377
引言：        spring的配置文件中，一切的标签都是spring定义好的。&lt;bean/&gt;等等，有了定义的规范，才能让用户填写的正常可用。想写自定义标签，但首先需要了解XML Schema Definition(XSD) 的。   标签定义：        对于该类标签的定义，spring中有着相应的XSD定义文档        http://www.spri...
spring自定义标签之规范定义XSD
数据库天地
05-17 278
引言： spring的配置文件中，一切的标签都是spring定义好的。&lt;bean/&gt;等等，有了定义的规范，才能让用户填写的正常可用。想写自定义标签，但首先需要了解XML Schema Definition(XSD) 的。 标签定义： 对于该类标签的定义，spring中有着相应的XSD定义文档 http://www.springframework....
深度学习dubbo源码这一篇就够了
liushangzaibeijing的博客
10-13 5万+
本篇博文是作者dubbo源码分析的汇总文章，文章从实战角度出发 整合示例+入口分析+dubbo服务发布和调用原理分析，同时对之前dubbo源码分析专栏的文章的错误点进行了修正，深度学习dubbo源码这一篇就够了
dubbo源码学习总结
张三的博客
11-18 1328
前言 总结 内容主要包括dubbo 框架的spi 实现，服务暴露实现，服务调用实现，以及个人感觉里面比较好的设计分享。涉及的代码部分较多。主要是自己的主观理解，如有纰漏 可以随时指正。 RPC rpc 框架在使用时可以让使用者调用远程的接口的时候犹如调本地接口一样，然而一个远程过程调用一定是会使用网络和序列化的，因此简单一点看，dubbo或者说所有的rpc框架提供的核心的能力就是通过动态代理的方式把接口的网络操作和序列化操作代理掉，对于使用者是透明的。dubbo在这个核心能力之上，外加了一些过滤，负.
2. Dubbo源码解析之服务暴露过程
guomeiran130的博客
03-02 255
2. Dubbo源码解析之服务暴露过程2.1 Dubbo自定义xml解析器2.1.1 DubboNamespaceHandler 添加过程2.1.2 DubboBeanDefinitionParser 添加过程2.1.3 DubboBeanDefinitionParser 解析过程2.2 装配 ServiceBean2.2.1 初始化静态成员2.2.2 构造函数初始化2.2.3 ApplicationContext 与 afterPropertiesSet 初始化2.2.4 Spring上下文刷新时事件监听
Dubbo 如何一步一步拿到bean
weixin_33840661的博客
04-08 1742
为什么80%的码农都做不了架构师？>>> ...
Spring初始化之扩展xml配置文件
shuangyue的专栏
02-26 1678
在spring2.0之后支持xml schema的方式扩展xml的配置。这样对于一些常用的属性较多的bean的配置，可以采用这种方式进行简化 要使用这种方式，只需要做以下几件事情： 1.定义xml schema文件(.xsd格式) 2.实现NamespaceHandler接口，将Xml Element元素转换为BeanDefinition,并注册到BeanDefinitionRe
手写类似dubbo的rpc框架第一章《自定义配置xml》
bugstack虫洞栈
05-16 1759
案例介绍 本案例通过三个章节来实现一共简单的rpc框架，用于深入学习rpc框架是如何通信的，当前章节主要介绍如何自定义xml文件并进行解析。想解析自定义的xml首先定义自己的xsd文件，并且实现spring的NamespaceHandlerSupport、BeanDefinitionParser，两个方法进行处理。 远程过程调用协议 RPC（Remote Procedure Call）—远程过程...
dubbo源码学习（四）初始化过程细节:解析服务
jycwl的专栏
04-25 9997
初学dubbo的源码，只做尝试性的去学习，做为自己学习的一个记录，各位看官如果觉得写的有错误或理解的不对，请在留言区告诉我，互相学习。本人能力有限，有大神进入 时请指点。 前面大概介绍了一下关于学习dubbo源码的一些基本知识，今天将真正去看dubbo内部的实现过程，看dubbo的源码前我先把dubbo的用户指南和开发指指南大概的看了一遍，然后从上面找到相应的切入点去看源码，今天将介绍的是dub
dubbo学习六--泛化，回声测试，上下文信息，隐式传参，异步调用，本地调用
金溪的博客
01-03 6681
泛化引用   &lt;dubbo:reference id="barService" interface="com.foo.BarService" generic="true" /&gt;   GenericService barService = (GenericService) applicationContext.getBean("barService");...
dubbo源码002：DubboBeanDefinitionParser
notOnlyRush的博客
05-03 881
com.alibaba.dubbo.config.spring.schema.DubboBeanDefinitionParser此类中，根据构造参数，生成不同的配置构造参数为         public DubboBeanDefinitionParser(Class beanClass , boolean required )在解析具体的标签的时候，调用BeanDefinitionParser对...
dubbo与spring整合之@Service、@Reference注解处理过程
JAVA技术爱好者
02-27 6495
dubbo与spring整合之@Service、@Reference注解处理过程dubbo整合spring的必要性整体的架构流程@EnableDubboDubboConfigConfigurationRegistrarDubboComponentScanRegistrarReferenceAnnotationBeanPostProcessor dubbo整合spring的必要性 dubbo是一款高性能的服务框架，但是如果是单独使用的话，会比较麻烦，而且很多注册中心的代码都需要自己写，因为还需要一套自己的IO
dubbo-py 源码
最新发布
04-28
dubbo-py 的源码结构清晰，主要分为 dubbo_client 和 dubbo_codec 两个模块，其中 dubbo_client 模块实现了 Dubbo 协议的客户端，dubbo_codec 模块实现了 Dubbo 协议的序列化和反序列化操作。 在 dubbo_client 模块...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值