开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 网络协议 -> Dubbo快速上手 -- 带你了解Dubbo使用、原理 -> 正文阅读

[网络协议]Dubbo快速上手 -- 带你了解Dubbo使用、原理

📒博客首页：崇尚学技术的科班人
🍣今天给大家带来的文章是《Dubbo快速上手 -- 带你了解Dubbo使用、原理》🍣
🍣希望各位小伙伴们能够耐心的读完这篇文章🍣
🙏博主也在学习阶段，如若发现问题，请告知，非常感谢🙏
💗同时也非常感谢各位小伙伴们的支持💗

1、基础知识

1.1、分布式基础理论

（1）、什么是分布式系统？

分布式系统是若干独立计算机的集合，这些计算机对于用户来说就像单个相关系统。
分布式系统是建立在网络之上的软件系统。
随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，需要一个治理系统确保架构有条不紊的演进。

（2）、应用架构的发展演变

在这里插入图片描述

单一应用架构 -> 垂直应用架构 -> 分布式服务架构 -> 流动计算架构

（3）、RPC

什么是RPC？

RPC是指远程过程调用，是一种进程间通信方式，它是一种技术的思想，而不是规范。它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过程或函数，而不用程序员显式编码这个远程调用的细节。

RPC基本原理

在这里插入图片描述

由于业务需求，A 模块需要调用 B 模块的相关业务功能的话。那么 A 模块会将对应执行功能代码的函数参数通过网络连接进行传递给 B 模块。在这个需要传递对应数据的网络通信中，我们需要对数据进行序列化。
B 模块在接收到数据之后会首先对数据进行反序列化，然后执行相关功能代码产生返回值，然后再将对应的返回值进行序列化，再通过网络通信传输给 A 模块。
A 模块收到对应的执行结果之后会对返回值进行反序列化，从而 A 模块就获得了它想要获得的结果。
RPC 的两个核心模块：通讯、序列化。

1.2、Dubbo

（1）、简介

Dubbo 是一款高性能、轻量级的开源 Java RPC。它提供了三大核心能力：面向接口的远程方法调用、智能容错和负载均衡、以及服务自动注册和发现。

（2）、基本概念

在这里插入图片描述

角色概念

服务提供者：暴露服务的服务提供方，服务提供者在启动时，想注册中心注册自己提供的服务。
服务消费者：调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者从提供者地址列表中基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
注册中心：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
监控中心：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

调用关系说明

服务容器负责启动，加载，运行服务提供者。
服务提供者在启动时，向注册中心注册自己提供的服务。
服务消费者在启动时，向注册中心订阅自己所需的服务。
注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
服务消费者从提供者地址列表中，基于如负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

1.3、环境搭建

（1）、搭建 zookeeper 注册中心

windows 版本 zookeeper 下载地址

下载成功之后，我们进行解压之后，我们需要对 conf 目录下的 zoo_sample.cfg 进行复制改名成 zoo.cfg，并修改其中的内容，修改为dataDir = ../data。

# 在 bin 目录下执行以下代码启动
zkServer.cmd

# 使用客户端进行连接
zkCli.cmd

# 获取节点
get /

# 新增节点
create /xiao 123456

（2）、安装 dubbo-admin 管理控制台

dubbo-admin下载地址

# 解压之后在 src\main\resources\application.properties 指定zookeeper地址
dubbo.registry.address=zookeeper://127.0.0.1:2181

# 打包dubbo-admin
mvn clean package -Dmaven.test.skip=true

# 在 jar 的当前目录下运行
java -jar dubbo-admin-0.0.1-SNAPSHOT.jar

# 运行之后在 localhost:7001 进行访问，账户和密码都是 root

（3）、gmall-interface模块

UserAddress

import java.io.Serializable;

/**
 * 用户地址
 * @author xiao
 *
 */
public class UserAddress implements Serializable {
	
	private Integer id;
    private String userAddress; //用户地址
    private String userId; //用户id
    private String consignee; //收货人
    private String phoneNum; //电话号码
    private String isDefault; //是否为默认地址    Y-是     N-否
    
    public UserAddress() {
		super();
		// TODO Auto-generated constructor stub
	}
    
	public UserAddress(Integer id, String userAddress, String userId, String consignee, String phoneNum,
			String isDefault) {
		super();
		this.id = id;
		this.userAddress = userAddress;
		this.userId = userId;
		this.consignee = consignee;
		this.phoneNum = phoneNum;
		this.isDefault = isDefault;
	}
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getUserAddress() {
		return userAddress;
	}
	public void setUserAddress(String userAddress) {
		this.userAddress = userAddress;
	}
	public String getUserId() {
		return userId;
	}
	public void setUserId(String userId) {
		this.userId = userId;
	}
	public String getConsignee() {
		return consignee;
	}
	public void setConsignee(String consignee) {
		this.consignee = consignee;
	}
	public String getPhoneNum() {
		return phoneNum;
	}
	public void setPhoneNum(String phoneNum) {
		this.phoneNum = phoneNum;
	}
	public String getIsDefault() {
		return isDefault;
	}
	public void setIsDefault(String isDefault) {
		this.isDefault = isDefault;
	}
    
    


}

UserService

import java.util.List;

import com.xiao.gmall.bean.UserAddress;

/**
 * 用户服务
 * @author xiao
 *
 */
public interface UserService {
	
	/**
	 * 按照用户id返回所有的收货地址
	 * @param userId
	 * @return
	 */
	public List<UserAddress> getUserAddressList(String userId);

}

OrderService

import com.xiao.gmall.bean.UserAddress;

import java.util.List;


public interface OrderService {
	
	/**
	 * 初始化订单
	 * @param userId
	 */
	public List<UserAddress> initOrder(String userId);

}

（4）、user-service-provider模块

POM

 <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>gmall-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.6.2</version>
        </dependency>

        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>2.12.0</version>
        </dependency>
    </dependencies>

provider.xml

<?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://code.alibabatech.com/schema/dubbo"
       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">

        <!--  1. 指定当前服务/应用的名称 （同样的服务名字相同，不要和别的服务同名）      -->
        <dubbo:application name="user-service-provider"></dubbo:application>

        <!--   2. 指定注册中心的位置     -->
<!--        <dubbo:registry address="zookeeper://127.0.0.1:2181"></dubbo:registry>-->
        <dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"></dubbo:registry>

        <!--   3. 指定通信规则（通信协议？通信端口）     -->
        <dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>

        <!--   4. 暴露对应的服务 ref:指的就是接口的实现类  -->
        <dubbo:service interface="com.xiao.gmall.service.UserService" ref="userServiceImpl"></dubbo:service>

        <!--   5. 对应的实现类     -->
        <bean id="userServiceImpl" class="com.xiao.gmall.service.impl.UserServiceImpl"></bean>
</beans>

MainApplication

import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

/**
 * @author ：小肖
 * @date ：Created in 2022/2/23 15:17
 */
public class MainApplication {
    public static void main(String[] args) throws IOException {
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("provider.xml");
        ioc.start();

        System.in.read();
    }
}

UserServiceImpl

import com.xiao.gmall.bean.UserAddress;
import com.xiao.gmall.service.UserService;

import java.util.Arrays;
import java.util.List;

/**
 * @author ：小肖
 * @date ：Created in 2022/2/23 9:33
 */
public class UserServiceImpl implements UserService {

    @Override
    public List<UserAddress> getUserAddressList(String userId) {
        System.out.println("UserServiceImpl.....old...");
        // TODO Auto-generated method stub
        UserAddress address1 = new UserAddress(1, "北京市昌平区宏福科技园综合楼3层", "1", "李老师", "010-56253825", "Y");
        UserAddress address2 = new UserAddress(2, "深圳市宝安区西部硅谷大厦B座3层（深圳分校）", "1", "王老师", "010-56253825", "N");
		/*try {
			Thread.sleep(4000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}*/
        return Arrays.asList(address1,address2);
    }
}

（5）、order-service-consumer模块

POM

 <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>gmall-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.6.2</version>
        </dependency>

        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>2.12.0</version>
        </dependency>
    </dependencies>

consumer.xml

<?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:context="http://www.springframework.org/schema/context"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       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
               http://www.springframework.org/schema/context
               http://www.springframework.org/schema/context/spring-context.xsd">

    <!--   扫描包 -->
    <context:component-scan base-package="com.xiao.gmall.service.impl"></context:component-scan>

    <!--  1. 指定当前服务/应用的名称 （同样的服务名字相同，不要和别的服务同名）      -->
    <dubbo:application name="order-service-consumer"></dubbo:application>

    <dubbo:registry address="zookeeper://127.0.0.1:2181"></dubbo:registry>

    <dubbo:reference interface="com.xiao.gmall.service.UserService" id="userService"></dubbo:reference>


</beans>

MainApplication

import com.xiao.gmall.service.OrderService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

/**
 * @author ：小肖
 * @date ：Created in 2022/2/23 15:34
 */
public class MainApplication {
    public static void main(String[] args) throws IOException {
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("consumer.xml");
        OrderService orderService = ioc.getBean(OrderService.class);
        orderService.initOrder("1");

        System.in.read();
    }
}

OrderServiceImpl

/**
 * 1、将服务提供者注册到注册中心（暴露服务）
 * 		1）、导入dubbo依赖（2.6.2）\操作zookeeper的客户端(curator)
 * 		2）、配置服务提供者
 * 
 * 2、让服务消费者去注册中心订阅服务提供者的服务地址
 * @author xiao
 *
 */
@Service
public class OrderServiceImpl implements OrderService {


	@Autowired
	UserService userService;

	@Override
	public List<UserAddress> initOrder(String userId) {
		// TODO Auto-generated method stub
		System.out.println("用户id："+userId);
		//1、查询用户的收货地址
		List<UserAddress> addressList = userService.getUserAddressList(userId);
		for (UserAddress userAddress : addressList) {
			System.out.println(userAddress.getUserAddress());
		}
		return addressList;
	}
	
	

}

（6）、测试结果

控制台输出如下

用户id：1
北京市昌平区宏福科技园综合楼3层
深圳市宝安区西部硅谷大厦B座3层（深圳分校）

2、配置

（1）、配置文件加载顺序

虚拟机参数 > application.properties > dubbo.properties

（2）、启动时检查

启动时检查：就是消费者启动的时候会进行对服务提供者的检查，如果服务提供者未在注册中心中注册的话，那么就会抛出异常。

<!--  关闭某个服务的启动时检查  -->
<dubbo:reference interface="com.xiao.gmall.service.UserService" id="userService" check="false"></dubbo:reference>

<!--  全局统一配置关闭启动时检查  -->
<dubbo:consumer check="false"/>
<!--  关闭注册中心的启动时检查  -->
<dubbo:registry check="false"/>

（3）、超时时间配置

超时时间配置：为了防止线程发生大量的阻塞。
精确优先（方法级优先，接口级次之，全局配置再次之）。
消费者优先（如果级别一样，则消费方优先，提供方次之）。

<!--  关闭某个服务的启动时检查 check="false" -->
    <!--  消费者超时时间的配置  -->
    <dubbo:reference interface="com.xiao.gmall.service.UserService" id="userService" timeout="5000">
        <dubbo:method name="getUserAddressList" timeout="1000"></dubbo:method>
    </dubbo:reference>
    <!--消费者的超时时间的全局配置-->
    <dubbo:consumer timeout="1000"></dubbo:consumer>

<!--   4. 暴露对应的服务 ref:指的就是接口的实现类  -->
<!--  服务提供者者超时时间的配置  -->
<dubbo:service interface="com.xiao.gmall.service.UserService" ref="userServiceImpl" timeout="5000">
        <dubbo:method name="getUserAddressList" timeout="1000"></dubbo:method>
</dubbo:service>
<!--服务提供者的超时时间的全局配置-->
<dubbo:provider timeout="1000"></dubbo:provider>

（4）、重试次数

retries：重试次数，不包含第一次调用。
幂等（设置重试次数）【查询、删除、修改】；非幂等（不能设置重试次数）【新增】

<dubbo:reference interface="com.xiao.gmall.service.UserService" id="userService" retries="3"></dubbo:reference>

（5）、多版本

我们可以在消费者对新旧版本功能对象进行都生成，并用 version 进行管理区别调用。

<dubbo:reference interface="com.xiao.gmall.service.UserService" id="userService" version="1.0.0"></dubbo:reference>

（6）、本地存根

UserServiceStub

import com.xiao.gmall.bean.UserAddress;
import com.xiao.gmall.service.UserService;
import org.springframework.util.StringUtils;

import java.util.List;

/**
 * @author ：小肖
 * @date ：Created in 2022/2/23 23:06
 */
public class UserServiceStub implements UserService {

    private final UserService userService;


    public UserServiceStub(UserService userService) {
        this.userService = userService;
    }

    @Override
    public List<UserAddress> getUserAddressList(String userId) {
        System.out.println("UserServiceStub....");
        if(!StringUtils.isEmpty(userId)){
            return userService.getUserAddressList(userId);
        }
        return null;
    }
}

配置

<dubbo:reference interface="com.xiao.gmall.service.UserService" id="userService" stub="com.xiao.gmall.service.impl.UserServiceStub"></dubbo:reference>

（7）、SpringBoot与dubbo整合的三种方式

导入 dubbo-starter，在 application.properties 配置属性，使用 @Service【暴露服务】使用 @Reference【引用服务】
保留 dubbo xml 配置文件：导入 dubbo-starter，使用 @ImportResource 导入 dubbo 的配置文件即可
使用注解 API 的方式：将每一个组件手动创建到容器中,让 dubbo 来扫描其他的组件。

对应的 config 配置类

import java.util.ArrayList;
import java.util.List;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.alibaba.dubbo.config.ApplicationConfig;
import com.alibaba.dubbo.config.MethodConfig;
import com.alibaba.dubbo.config.MonitorConfig;
import com.alibaba.dubbo.config.ProtocolConfig;
import com.alibaba.dubbo.config.ProviderConfig;
import com.alibaba.dubbo.config.RegistryConfig;
import com.alibaba.dubbo.config.ServiceConfig;
import com.atguigu.gmall.service.UserService;

@Configuration
public class MyDubboConfig {
	
	@Bean
	public ApplicationConfig applicationConfig() {
		ApplicationConfig applicationConfig = new ApplicationConfig();
		applicationConfig.setName("boot-user-service-provider");
		return applicationConfig;
	}
	
	//<dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"></dubbo:registry>
	@Bean
	public RegistryConfig registryConfig() {
		RegistryConfig registryConfig = new RegistryConfig();
		registryConfig.setProtocol("zookeeper");
		registryConfig.setAddress("127.0.0.1:2181");
		return registryConfig;
	}
	
	//<dubbo:protocol name="dubbo" port="20882"></dubbo:protocol>
	@Bean
	public ProtocolConfig protocolConfig() {
		ProtocolConfig protocolConfig = new ProtocolConfig();
		protocolConfig.setName("dubbo");
		protocolConfig.setPort(20882);
		return protocolConfig;
	}
	
	/**
	 *<dubbo:service interface="com.atguigu.gmall.service.UserService" 
		ref="userServiceImpl01" timeout="1000" version="1.0.0">
		<dubbo:method name="getUserAddressList" timeout="1000"></dubbo:method>
	</dubbo:service>
	 */
	@Bean
	public ServiceConfig<UserService> userServiceConfig(UserService userService){
		ServiceConfig<UserService> serviceConfig = new ServiceConfig<>();
		serviceConfig.setInterface(UserService.class);
		serviceConfig.setRef(userService);
		serviceConfig.setVersion("1.0.0");
		
		//配置每一个method的信息
		MethodConfig methodConfig = new MethodConfig();
		methodConfig.setName("getUserAddressList");
		methodConfig.setTimeout(1000);
		
		//将method的设置关联到service配置中
		List<MethodConfig> methods = new ArrayList<>();
		methods.add(methodConfig);
		serviceConfig.setMethods(methods);
		
		//ProviderConfig
		//MonitorConfig
		
		return serviceConfig;
	}

}

3、高可用

3.1、zookeeper宕机与dubbo直连

监控中心宕掉不影响使用，只是丢失部分采样数据
数据库宕掉后，注册中心仍能通过缓存提供服务列表查询，但不能注册新服务
注册中心对等集群，任意一台宕掉后，将自动切换到另一台
注册中心全部宕掉后，服务提供者和服务消费者仍能通过本地缓存通讯
服务提供者无状态，任意一台宕掉后，不影响使用
服务提供者全部宕掉后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复

与 dubbo 直连

@Reference(url = "127.0.0.1:20880") // 与dubbo直连
UserService userService;

3.2、负载均衡策略与配置

Random LoadBalance：随机，按权重设置随机概率。
RoundRobin LoadBalance：轮循，按公约后的权重设置轮循比率。
LeastActive LoadBalance：最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。
ConsistentHash LoadBalance：一致性 Hash，相同参数的请求总是发到同一提供者。

<!--服务提供方-->
<dubbo:service interface="com.xiao.gmall.service.UserService" ref="userServiceImpl" loadbalance="random"></dubbo:service>


<dubbo:provider loadbalance="random"></dubbo:provider>


<!--消费者方-->
<dubbo:reference interface="com.xiao.gmall.service.UserService" id="userService" loadbalance="random" stub="com.xiao.gmall.service.impl.UserServiceStub"></dubbo:reference>


<dubbo:consumer loadbalance="random"></dubbo:consumer>

3.3、服务降级

服务降级：当服务器压力剧增的情况下，根据实际业务情况及流量，对一些服务和页面有策略的不处理或换种简单的方式处理，从而释放服务器资源以保证核心交易正常运作或高效运作。
mock=force:return+null 表示消费方对该服务的方法调用都直接返回 null 值，不发起远程调用。用来屏蔽不重要服务不可用时对调用方的影响。
mock=fail:return+null 表示消费方对该服务的方法调用在失败后，再返回 null 值，不抛异常。用来容忍不重要服务不稳定时对调用方的影响。

在这里插入图片描述

这里我们通过 dubbo 提供的监控中心进行配置。

3.4、整合 Hystrix

引入依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    <version>1.4.4.RELEASE</version>
</dependency>

开启注解

// 在主启动类上添加
@EnableHystrix

标识注解

// 在所需要容错的方法上添加
@HystrixCommand

fallback方法

@HystrixCommand(fallback = "hello")

4、原理

4.1、RPC原理

在这里插入图片描述

调用流程

服务消费方（client）调用以本地调用方式调用服务；
client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体；
client stub找到服务地址，并将消息发送到服务端；
server stub收到消息后进行解码；
server stub根据解码结果调用本地的服务；
本地服务执行并将结果返回给server stub；
server stub将返回结果打包成消息并发送至消费方；
client stub接收到消息，并进行解码；
服务消费方得到最终结果。

4.2、dubbo原理 – 框架设计

在这里插入图片描述

config 配置层：对外配置接口，以 ServiceConfig, ReferenceConfig 为中心，可以直接初始化配置类，也可以通过 spring 解析配置生成配置类
proxy 服务代理层：服务接口透明代理，生成服务的客户端 Stub 和服务器端 Skeleton, 以 ServiceProxy 为中心，扩展接口为 ProxyFactory
registry 注册中心层：封装服务地址的注册与发现，以服务 URL 为中心，扩展接口为 RegistryFactory, Registry, RegistryService
cluster 路由层：封装多个提供者的路由及负载均衡，并桥接注册中心，以 Invoker 为中心，扩展接口为 Cluster, Directory, Router, LoadBalance
monitor 监控层：RPC 调用次数和调用时间监控，以 Statistics 为中心，扩展接口为 MonitorFactory, Monitor, MonitorService
protocol 远程调用层：封装 RPC 调用，以 Invocation, Result 为中心，扩展接口为 Protocol, Invoker, Exporter
exchange 信息交换层：封装请求响应模式，同步转异步，以 Request, Response 为中心，扩展接口为 Exchanger, ExchangeChannel, ExchangeClient, ExchangeServer
transport 网络传输层：抽象 mina 和 netty 为统一接口，以 Message 为中心，扩展接口为 Channel, Transporter, Client, Server, Codec
serialize 数据序列化层：可复用的一些工具，扩展接口为 Serialization, ObjectInput, ObjectOutput, ThreadPool

4.3、dubbo原理 – 启动解析、加载配置文件

public class DubboNamespaceHandler extends NamespaceHandlerSupport {
    

    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 AnnotationBeanDefinitionParser());
    }
}

当启动的时候，DubboNamespaceHandler会进行对各式各样的 DubboBeanDefinitionParser 进行初始化，然后这些 DubboBeanDefinitionParser 会进行配置文件的读取和加载。

4.4、dubbo原理 – 服务暴露

在这里插入图片描述

触发 export() 暴露服务

public class ServiceBean<T> extends ServiceConfig<T> implements InitializingBean, DisposableBean, ApplicationContextAware, ApplicationListener<ContextRefreshedEvent>, BeanNameAware {
 
    public void onApplicationEvent(ContextRefreshedEvent event) {
      		//...
            this.export();
            //...
    }
}

doExportUrls()

public class ServiceConfig<T> extends AbstractServiceConfig {
    public synchronized void export() {
        //...
         this.doExport();
        //...    
    }
}

doExportUrlsFor1Protocol()

public class ServiceConfig<T> extends AbstractServiceConfig {
    private void doExportUrls() {
       //...
        this.doExportUrlsFor1Protocol(protocolConfig, registryURLs);
        //...

    }	
}

getInvoker()

public class ServiceConfig<T> extends AbstractServiceConfig {
    private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs){
    		//...
    	   Invoker<?> invoker = proxyFactory.getInvoker(this.ref, this.interfaceClass, registryURL.addParameterAndEncoded("export", url.toFullString()));
    	   //...
	}
}

openServer()

public class DubboProtocol extends AbstractProtocol {
	public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
		//...
		this.openServer(url);
		//...
 	}
}

registerProvider()

public class ProviderConsumerRegTable {
    public static ConcurrentHashMap<String, Set<ProviderInvokerWrapper>> providerInvokers = new ConcurrentHashMap();
    public static ConcurrentHashMap<String, Set<ConsumerInvokerWrapper>> consumerInvokers = new ConcurrentHashMap();
    public static void registerProvider(Invoker invoker, URL registryUrl, URL providerUrl) {
        ProviderInvokerWrapper wrapperInvoker = new ProviderInvokerWrapper(invoker, registryUrl, providerUrl);
        String serviceUniqueName = providerUrl.getServiceKey();
        Set<ProviderInvokerWrapper> invokers = (Set)providerInvokers.get(serviceUniqueName);
        if (invokers == null) {
            providerInvokers.putIfAbsent(serviceUniqueName, new ConcurrentHashSet());
            invokers = (Set)providerInvokers.get(serviceUniqueName);
        }

        invokers.add(wrapperInvoker);
    }
}