qq_37863962

dubbo

duboo

一、SOP前述

1、垂直架构：

根据业务把项目垂直切割成多个项目

优点：

系统拆分，流量分担，解决并发问题

不同系统进行优化

水平扩展、负载均衡、容错提高

系统独立，互不影响、迭代下频率高

缺点：

服务系统之间接口调用硬编码

搭建集群之后，实现负载均衡比较复杂

服务系统接口调用监控不到位调用方式不统一

数据库资源浪费，充斥慢查询，主从同步延迟大

2、分布式sop：

即面向服务的架构。它是在垂直划分的基础上,将每个项目拆分出多个具备松耦合的服务

duboo核心功能

接口的远程方法调用，

智能容错和负载均衡，

服务自动注册和发现。

分层

应用层:

距离用户最近的一层，使用tomcat 作为web容器接收用户请求，使用下游的dubbo提供的接口来返回数据并且该层禁止访问数据库

业务服务层:

根据具体的业务场景演变而来的模块

基础业务层:

基础服务层:

这一层是与业务无关的模块是一些通用的服务

存储层:

分级:

按照业务性质分层同一层的业务也要做好分级依据业务的重要性进行分级按照二八定律网站80%的流量都在核心功能上面要优先保证核心业务的稳定。

隔离:

不同性质不同重要性的业务做好隔离包括业务缓存 DB 中间件都要做好隔离比如核心业务的数据库要和活动相关的数据库隔离

调用 :

总体上调用要单向可以跨层调用但不能出现逆向调用

优点

1、服务以接口为粒度，为开发者屏蔽远程调用底层细节使用Dubbo 面向接口远程方法调用，屏蔽了底层调用细节

2、业务分层以后架构更加清晰并且每个业务模块职责单一扩展性更强

3、数据隔离，权限回收，数据访问都通过接口让系统更加稳定安全服务应用本身无状态化这里的无状态化指的是应用本身不做内存级缓存而是把数据存入 db

4、服务责任易确定每个服务可以确定责任人这样更容易保证服务质量和稳定

缺点

1、粒度控制复杂如果没有控制好服务的粒度服务的模块就会越来越多就会引发超时分布式事务等问题

2、服务接口数量不宜控制容易引发接口爆炸所以服务接口建议以业务场景进行单位划分并对相近的业务做抽象防止接口爆炸

3、版本升级兼容困难尽量不要删除方法字段枚举类型的新增字段也可能不兼容

4、调用链路长服务质量不可监控调用链路变长下游抖动可能会影响到上游业务最终形成连锁反应服务质量不稳定同时链路的变成使得服务质量的监控变得困难

3、微服务架构

微服务是在SOA上做的升华 , 粒度更加细致，微服务架构强调的一个重点是“业务需要彻底的组件化和服

务化”。

二、duboo

#### 1、 服务治理

服务治理指的是用来管理SOA的采用和实现的过程。


Provider	暴露服务的服务提供方
Consumer	调用远程服务的服务消费方
Registry	服务注册与发现的注册中心
Monitor	统计服务的调用次数和调用时间的监控中心
Container	服务运行容器负责启动加载运行服务提供者

调用关系说明:

虚线代表异步调用实线代表同步访问

蓝色虚线是在启动时完成的功能

红色虚线是程序运行中执行的功能

2、服务注册中心Zookeeper

3、实战案例介绍

程序实现分为以下几步骤:

建立maven工程并且创建API模块: 用于规范双方接口协定
提供provider模块，引入API模块，并且对其中的服务进行实现。将其注册到注册中心上，对外来

统一提供服务。

提供consumer模块，引入API模块，并且引入与提供者相同的注册中心。再进行服务调用。

主工程（依赖）


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <groupId>com.lagougroupId>
    <artifactId>demo-baseartifactId>
    <packaging>pompackaging>
    <version>1.0-SNAPSHOTversion>
    <modules>
    //引入的项目
        <module>service-apimodule>
        <module>service-providermodule>
    modules>
    <properties>
    //这里冲突版本 注意和JDK版本
        <dubbo.version>2.7.1dubbo.version>
    properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.apache.dubbogroupId>
                <artifactId>dubboartifactId>
                <version>${dubbo.version}version>
            dependency>
            <dependency>
                <groupId>org.apache.dubbogroupId>
                <artifactId>dubbo-commonartifactId>
                <version>${dubbo.version}version>
            dependency>
            <dependency>
                <groupId>org.apache.dubbogroupId>
                <artifactId>dubbo-registry-zookeeperartifactId>
                <version>${dubbo.version}version>
                <exclusions>
                    <exclusion>
                        <groupId>org.apache.dubbogroupId>
                        <artifactId>dubbo-remoting-apiartifactId>
                    exclusion>
                    <exclusion>
                        <groupId>org.apache.dubbogroupId>
                        <artifactId>dubbo-commonartifactId>
                    exclusion>
                exclusions>
            dependency>
            <dependency>
                <groupId>org.apache.dubbogroupId>
                <artifactId>dubbo-registry-nacosartifactId>
                <version>${dubbo.version}version>
            dependency>
            <dependency>
                <groupId>org.apache.dubbogroupId>
                <artifactId>dubbo-rpc-dubboartifactId>
                <version>${dubbo.version}version>
                <exclusions>
                    <exclusion>
                        <groupId>org.apache.dubbogroupId>
                        <artifactId>dubbo-remoting-apiartifactId>
                    exclusion>
                    <exclusion>
                        <groupId>org.apache.dubbogroupId>
                        <artifactId>dubbo-commonartifactId>
                    exclusion>
                exclusions>
            dependency>
            <dependency>
                <groupId>org.apache.dubbogroupId>
                <artifactId>dubbo-remoting-netty4artifactId>
                <version>${dubbo.version}version>
                <exclusions>
                    <exclusion>
                        <groupId>org.apache.dubbogroupId>
                        <artifactId>dubbo-remoting-apiartifactId>
                    exclusion>
                exclusions>
            dependency>
            <dependency>
                <groupId>org.apache.dubbogroupId>
                <artifactId>dubbo-serialization-hessian2artifactId>
                <version>${dubbo.version}version>
                <exclusions>
                    <exclusion>
                        <groupId>org.apache.dubbogroupId>
                        <artifactId>dubbo-commonartifactId>
                    exclusion>
                exclusions>
            dependency>
        dependencies>
    dependencyManagement>

    <dependencies>
        
        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>1.2.16version>
        dependency>
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-apiartifactId>
            <version>1.7.5version>
        dependency>
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-log4j12artifactId>
            <version>1.7.5version>
        dependency>

        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>fastjsonartifactId>
            <version>1.2.62version>
        dependency>
    dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-compiler-pluginartifactId>
                <version>3.3version>
                <configuration>
                    <source>1.8source>
                    <target>1.8target>
                configuration>
            plugin>
        plugins>
    build>

project>

api项目依赖

  <dependencies>
        <dependency>
            <groupId>org.apache.dubbogroupId>
            <artifactId>dubboartifactId>
        dependency>
    dependencies>

service-provider 项目依赖

<dependencies>
        <dependency>//引入服务的API
            <groupId>com.lagougroupId>
            <artifactId>service-apiartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>
        <dependency>
            <groupId>org.apache.dubbogroupId>
            <artifactId>dubboartifactId>
        dependency>
        <dependency>
            <groupId>org.apache.dubbogroupId>
            <artifactId>dubbo-registry-zookeeperartifactId>
        dependency>
        <dependency>
            <groupId>org.apache.dubbogroupId>
            <artifactId>dubbo-rpc-dubboartifactId>
        dependency>
        <dependency>
            <groupId>org.apache.dubbogroupId>
            <artifactId>dubbo-remoting-netty4artifactId>
        dependency>
        <dependency>
            <groupId>org.apache.dubbogroupId>
            <artifactId>dubbo-serialization-hessian2artifactId>
        dependency>
    dependencies>

服务提供者演示

dubbo.application.name=service-provider
dubbo.protocol.name=dubbo
dubbo.protocol.port=20889

代码：

public class DubboPureMain {
    public static void main(String[] args) throws  Exception{
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProviderConfiguration.class);
        context.start();
        System.in.read();//阻止住进程结束
    }
    
    @Configuration
    @EnableDubbo(scanBasePackages = "com.lagou.service.Impl")
    @PropertySource("classpath:/dubbo-provider.properties")
    static  class  ProviderConfiguration{//配置类
        @Bean
        public RegistryConfig   registryConfig(){//注册中心
            RegistryConfig  registryConfig  = new RegistryConfig();
            registryConfig.setAddress("zookeeper://127.0.0.1:2181?timeout=10000");
            //registryConfig.setTimeout(10000);
            return   registryConfig;
        }
    }

}

sonsumer 项目

dubbo.application.name=service-consumer
dubbo.registry.address=zookeeper://127.0.0.1:2181
dubbo.consumer.timeout=4000

@Component //spring容器管理
public class ConsumerComponet {
    @Reference //springboot 引入
    HellowService hellowService;
    public String  say(String name){
        return  hellowService.say(name);
    }
}

public class ConsumerMain {
    public static void main(String[] args) throws  Exception {
        System.out.println("-------------");
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConsumerConfiguration.class);
        context.start();
        // 获取消费者组件
        ConsumerComponet service = context.getBean(ConsumerComponet.class);
        while(true){
            System.in.read();
            String  hello = service.say("world");
            System.out.println("result:"+hello);
        }
    }
    @Configuration
    @PropertySource("classpath:/dubbo-consumer.properties")
    @ComponentScan(basePackages = "com.lagou.bean")
    @EnableDubbo
    static  class  ConsumerConfiguration{

    }
}

4、dubbo管理控制台dubbo-admin

主要包含：

服务管理、路由规则、动态配置、服务降级、访问控制、权重调整、负载均衡等管理功能

安装步骤

1.从git 上下载项目 https://github.com/apache/dubbo-admin 
2.修改项目下的dubbo.properties文件 
注意dubbo.registry.address对应的值需要对应当前使用的Zookeeper的ip地址和端口号 
• dubbo.registry.address=zookeeper://zk所在机器ip:zk端口 
• dubbo.admin.root.password=root • dubbo.admin.guest.password=guest 
3.切换到项目所在的路径 使用mvn 打包 mvn clean package -Dmaven.test.skip=true 
4.java 命令运行 java -jar 对应的jar包

5、Dubbo配置项说明官网有详细说明

dubbo.application.name=service-consumer
dubbo.registry.address=zookeeper://127.0.0.1:2181
dubbo.consumer.timeout=4000

dubbo.application.name=service-provider4
dubbo.protocol.name=rmi
dubbo.protocol.port=20889
dubbo.application.owner=zimu

1、dubbo:application

org.apache.dubbo.confifig.ApplicationConfifig 代表当前应用的信息

1. name: 当前应用程序的名称，在dubbo-admin中我们也可以看到，这个代表这个应用名称。我们 在真正时是时也会根据这个参数来进行聚合应用请求。 
2. owner: 当前应用程序的负责人，可以通过这个负责人找到其相关的应用列表，用于快速定位到责 任人。 
3. qosEnable : 是否启动QoS 默认true 
4. qosPort : 启动QoS绑定的端口 默认22222 
5. qosAcceptForeignIp: 是否允许远程访问 默认是false

2、dubbo:registry

org.apache.dubbo.confifig.RegistryConfifig, , 代表该模块所使用的注册中心。

1. id : 当当前服务中provider或者consumer中存在多个注册中心时，则使用需要增加该配置。在一些公司，会通过业务线的不同选择不同的注册中心，所以一般都会配置该值。
2. address : 当前注册中心的访问地址。
3. protocol : 当前注册中心所使用的协议是什么。也可以直接在 address 中写入，比如使用
zookeeper，就可以写成 zookeeper://xx.xx.xx.xx:2181 
4. timeout : 当与注册中心不再同一个机房时，大多会把该参数延长。

3、dubbo:protocol

org.apache.dubbo.confifig.ProtocolConfifig, 指定服务在进行数据传输所使用的协议

1. id : 在大公司，可能因为各个部门技术栈不同，所以可能会选择使用不同的协议进行交互。这里在多个协议使用时，需要指定。
2. name : 指定协议名称。默认使用 dubbo 。

4、 dubbo:service

org.apache.dubbo.confifig.ServiceConfifig, 用于指定当前需要对外暴露的服务信息，后面也会具体讲解。和 dubbo:reference 大致相同

1. interface : 指定当前需要进行对外暴露的接口是什么。
2. ref : 具体实现对象的引用，一般我们在生产级别都是使用Spring去进行Bean托管的，所以这里面一般也指的是Spring中的BeanId。 
3. version : 对外暴露的版本号。不同的版本号，消费者在消费的时候只会根据固定的版本号进行消费

5、dubbo:reference

org.apache.dubbo.confifig.ReferenceConfifig, 消费者的配置，这里只做简单说明，后面会具体讲解。

1. id : 指定该Bean在注册到Spring中的id。 
2. interface: 服务接口名
3. version : 指定当前服务版本，与服务提供者的版本一致。
4. registry : 指定所具体使用的注册中心地址。这里面也就是使用上面在 dubbo:registry 中所声
明的id。

6、dubbo:method

org.apache.dubbo.confifig.MethodConfifig, 用于在制定的 dubbo:service 或者 dubbo:reference 中的更具体一个层级，指定具体方法级别在进行RPC操作时候的配置，可以理解为对这上面层级中的配置针对于具体方法的特殊处理。

1. name : 指定方法名称，用于对这个方法名称的RPC调用进行特殊配置。
2. async: 是否异步 默认false

7、dubbo:service和dubbo:reference详解

1. mock: 用于在方法调用出现错误时，当做服务降级来统一对外返回结果，后面我们也会对这个方法做更多的介绍。
2. timeout: 用于指定当前方法或者接口中所有方法的超时时间。我们一般都会根据提供者的时长来具体规定。比如我们在进行第三方服务依赖时可能会对接口的时长做放宽，防止第三方服务不稳定导致服务受损。
3. check: 用于在启动时，检查生产者是否有该服务。我们一般都会将这个值设置为false，不让其进行检查。因为如果出现模块之间循环引用的话，那么则可能会出现相互依赖，都进行check的话，那么这两个服务永远也启动不起来。
4. retries: 用于指定当前服务在执行时出现错误或者超时时的重试机制。
	1. 注意提供者是否有幂等，否则可能出现数据一致性问题
	2. 注意提供者是否有类似缓存机制，如出现大面积错误时，可能因为不停重试导致雪崩
5. executes: 用于在提供者做配置，来确保最大的并行度。
	1. 可能导致集群功能无法充分利用或者堵塞
	2. 但是也可以启动部分对应用的保护功能
	3. 可以不做配置，结合后面的熔断限流使用

注意遇到问题：

1、No application config found or it’s not a valid config! Please add

1.jdk1.8+dubbo版本是2.7.5版本是没有问题

2.jdk11+dubbo版本是2.7.1版本是没有问题的

2、 qos-server can not bind localhost:22222, dubbo version: 2.7.1, current host: 192.168.1.3

dubbo.application.qosEnable=true
dubbo.application.qosPort=33333
dubbo.application.qosAcceptForeignIp=false

三、Dubbo高级实战

1、JDK中的SPI

SPI遵循如下约定：
1、当服务提供者提供了接口的一种具体实现后，在META-INF/services目录下创建一个以“接口全
限定名”为命名的文件，内容为实现类的全限定名；
2、接口实现类所在的jar包放在主程序的classpath中；
3、主程序通过java.util.ServiceLoader动态装载实现模块，它通过扫描META-INF/services目录下
的配置文件找到实现类的全限定名，把类加载到JVM； 4、SPI的实现类必须携带一个无参构造方法；

2、 Dubbo中的SPI

实现方式

api项目创建
（1）导入坐标 dubbo
（2）创建接口
 在接口上 使用@SPI
 
 
 impl项目创建
（1）导入 api项目 的依赖
（2）建立实现类，为了表达支持多个实现的目的，这里分别创建两个实现。分别为
HumanHelloService 和 DogHelloService 。 （3）SPI进行声明操作，在 resources 目录下创建目录 META-INF/dubbo 目录，在目录下创建名称为
com.lagou.dubbo.study.spi.demo.api.HelloService的文件，文件内部配置两个实现类名称和对应的全
限定名：
main项目创建
（1）导入坐标 接口项目 和 实现类项目
（2）创建DubboSpiMain
和原先调用的方式不太相同， dubbo 有对其进行自我重新实现 需要借助ExtensionLoader，创建新的运
行项目。这里demo中的示例和java中的功能相同，查询出所有的已知实现，并且调用

dubbo自己做SPI原因

1. JDK 标准的 SPI 会一次性实例化扩展点所有实现，如果有扩展实现初始化很耗时，但如果没用上也加 载，会很浪费资源
2. 如果有扩展点加载失败，则所有扩展点无法使用 
3. 提供了对扩展点包装的功能(Adaptive)，并且还支持通过set的方式对其他的扩展点进行注入

3、Dubbo SPI中的Adaptive功能

Dubbo中的Adaptive功能，主要解决的问题是如何动态的选择具体的扩展点。通过 getAdaptiveExtension 统一对指定接口对应的所有扩展点进行封装，通过URL的方式对扩展点来进行动态选择。 (dubbo中所有的注册信息都是通过URL的形式进行处理的。)这里同样采用相同的方式进行实现

方式：

（1）创建接口

human=com.lagou.service.impl.HumanHelloService

dog=com.lagou.service.impl.DogHelloService

JDK 标准的 SPI 会一次性实例化扩展点所有实现，如果有扩展实现初始化很耗时，但如果没用上也加

载，会很浪费资源

如果有扩展点加载失败，则所有扩展点无法使用
提供了对扩展点包装的功能(Adaptive)，并且还支持通过set的方式对其他的扩展点进行注入api中的 HelloService 扩展如下方法, 与原先类似，在sayHello中增加 Adaptive 注解，并且在参数中

提供URL参数.注意这里的URL参数的类为 org.apache.dubbo.common.URL

其中@SP可以指定一个字符串参数，用于指明该SPI的默认实现。

（2）创建实现类

与上面Service实现类代码相似，只需增加URL形参即可

（3）编写DubboAdaptiveMain

最后在获取的时候方式有所改变，需要传入URL参数，并且在参数中指定具体的实现类参数

如:

public class DubboAdaptiveMain { public static void main(String[] args) { URL url = URL.valueOf("test://localhost/hello?hello.service=dog"); final HelloService adaptiveExtension = ExtensionLoader.getExtensionLoader(HelloService.class).getAdaptiveExtension(); adaptiveExtension.sayHello(url); } }

注意：
因为在这里只是临时测试，所以为了保证URL规范，前面的信息均为测试值即可，关键的点在于
hello.service 参数，这个参数的值指定的就是具体的实现方式。关于为什么叫
hello.service 是因为这个接口的名称，其中后面的大写部分被dubbo自动转码为 . 分割。
通过 getAdaptiveExtension 来提供一个统一的类来对所有的扩展点提供支持(底层对所有的扩展
点进行封装)。
调用时通过参数中增加 URL 对象来实现动态的扩展点使用。
如果URL没有提供该参数，则该方法会使用默认在 SPI 注解中声明的实现。

4、 Dubbo调用时拦截操作

步骤如下：

（1）实现 org.apache.dubbo.rpc.Filter 接口

（2）使用 org.apache.dubbo.common.extension.Activate 接口进行对类进行注册通过group 可以

指定生产端消费端如:

@Activate(group = {CommonConstants.CONSUMER)

（3）计算方法运行时间的代码实现

（4）在 META-INF.dubbo 中新建 org.apache.dubbo.rpc.Filter 文件，并将当前类的全名写入

timerFilter=包名.过滤器的名字

注意：一般类似于这样的功能都是单独开发依赖的，所以再使用方的项目中只需要引入依赖，在调用接

口时，该方法便会自动拦截。

5、负载均衡策略

负载均衡基本配置

//在服务消费者一方配置负载均衡策略
@Reference(check = false,loadbalance = "random")


//在服务提供者一方配置负载均衡 
@Service(loadbalance = "random")
public class HelloServiceImpl implements HelloService { 
    public String sayHello(String name) { return "hello " + name; }
}

自定义负载均衡器

负载均衡器在Dubbo中的SPI接口是 org.apache.dubbo.rpc.cluster.LoadBalance , 可以通过实现这

个接口来实现自定义的负载均衡规则。

（1）自定义负载均衡器

在上一节的案例基础上创建名称为dubbo-spi-loadbalance的Maven模块，并创建负载均衡器

OnlyFirstLoadbalancer。这里功能只是简单的选取所有机器中的第一个(按照字母排序 + 端口排序)。

（2）配置负载均衡器

在dubbo-spi-loadbalance工程的 META-INF/dubbo 目录下新建

org.apache.dubbo.rpc.cluster.LoadBalance 文件，并将当前类的全名写入

onlyFirst=包名.负载均衡器

（3）在服务提供者工程实现类中编写用于测试负载均衡效果的方法启动不同端口时方法返回的信息

不同

（4）启动多个服务要求他们使用同一个接口注册到同一个注册中心但是他们的dubbo通信端口不同

timerFilter=包名.过滤器的名字

//在服务消费者一方配置负载均衡策略 
@Reference(check = false,loadbalance = "random") 
//在服务提供者一方配置负载均衡 
@Service(loadbalance = "random") 
public class HelloServiceImpl implements HelloService { 
    public String sayHello(String name) { 
   	 return "hello " + name; 
	} 
}

onlyFirst=包名.负载均衡器（5）在服务消费方指定自定义负载均衡器 onlyFirst

（6）测试自定义负载均衡的效果

6、异步调用

6-1 异步调用实现

（1）为了能够模拟等待，通过 int timeToWait参数，标明需要休眠多少毫秒后才会进行返回。

String sayHello(String name, int timeToWait);

（2）接口实现为了模拟调用耗时可以让线程等待一段时间

（3）在消费者端，配置异步调用注意消费端默认超时时间1000毫秒如果提供端耗时大于1000毫秒会

出现超时

可以通过改变消费端的超时时间通过timeout属性设置即可单位毫秒

<dubbo:reference id="helloService" interface="com.lagou.service.HelloService"> 		         <dubbo:method name="sayHello" async="true" /> 
dubbo:reference>

（4）测试，我们休眠100毫秒，然后再去进行获取结果。方法在同步调用时的返回值是空，我们可以通

过 RpcContext.getContext().getFuture() 来进行获取Future对象来进行后续的结果等待操作。

6-2、注意异步获取返回结果为null

异步调用时获取结果为null 这时候应该使用RpcContext 来获取结果

RpcContext：试一次请求的零时的上下文记录器，内部的实现是一个 ThreadLocal，我们看一下内部实现

来获取

private static final ThreadLocal<RpcContext> LOCAL = new ThreadLocal<RpcContext>() {
        @Override
        protected RpcContext initialValue() {
            return new RpcContext();
        }
    };

6-3异步不能直接获取数据原因：

在ConsumerContextFilter中，我们会创建RpcContext并且初始化一些数据，然后在后续的业务中我们可以给RpcContext里面添加attachments属性，进行属性的传递，在ContextFilter中接收设置的attachments属性值。

RpcContext.getContext()
                .setInvoker(invoker)
                .setInvocation(invocation)
                .setLocalAddress(NetUtils.getLocalHost(), 0)
                .setRemoteAddress(invoker.getUrl().getHost(),
                        invoker.getUrl().getPort());

在调用provider时，会经过ContextFilter，在这里我们就可以获取到consumer传过来的参数，然后依然是设置到自己的RpcContext，在后续业务中使用

Map<String, String> attachments = invocation.getAttachments();
RpcContext.getContext()
                .setInvoker(invoker)
                .setInvocation(invocation)
                .setLocalAddress(invoker.getUrl().getHost(),
                        invoker.getUrl().getPort());
 
        // mreged from dubbox
        // we may already added some attachments into RpcContext before this filter (e.g. in rest protocol)
        if (attachments != null) {
            if (RpcContext.getContext().getAttachments() != null) {
                RpcContext.getContext().getAttachments().putAll(attachments);
            } else {
                RpcContext.getContext().setAttachments(attachments);
            }
        }

这里我们为什么会在invocation中拿到数据呢？我们看一下在调用DubboInvoker的时候，其实是走的抽象类AbstractInvoker中的invoke方法，这里会拿到之前设置的RpcContext的Attachments的值，设置到invocation的attachm

if (attachment != null && attachment.size() > 0) {
            invocation.addAttachmentsIfAbsent(attachment);
        }
        Map<String, String> context = RpcContext.getContext().getAttachments();
        if (context != null) {
            invocation.addAttachmentsIfAbsent(context);
        }

而且这里是可以实现异步调用的

if (getUrl().getMethodParameter(invocation.getMethodName(), Constants.ASYNC_KEY, false)) {
            invocation.setAttachment(Constants.ASYNC_KEY, Boolean.TRUE.toString());
        }

这里通过获取async参数，如果配置了这个参数，我们会设置invocation中为异步

然后在DubboInvoker中，判断是不是异步，如果是异步设置setFuture，然后直接相应，后续通过RpcContext获取值

boolean isAsync = RpcUtils.isAsync(getUrl(), invocation);
else if (isAsync) {
                ResponseFuture future = currentClient.request(inv, timeout);
                RpcContext.getContext().setFuture(new FutureAdapter<Object>(future));
                return new RpcResult();
            }

7、线程池

1、实现

public class WachingThreadPool  extends FixedThreadPool  implements  Runnable{
    private  static  final Logger  LOGGER = LoggerFactory.getLogger(WachingThreadPool.class);
    // 定义线程池使用的阀值
    private  static  final  double  ALARM_PERCENT = 0.90;
    private  final Map<URL, ThreadPoolExecutor>    THREAD_POOLS = new ConcurrentHashMap<>();
    public  WachingThreadPool(){
        // 每隔3秒打印线程使用情况
        Executors.newSingleThreadScheduledExecutor().scheduleWithFixedDelay(this,1,3, TimeUnit.SECONDS);
    }
    // 通过父类创建线程池
    @Override
    public Executor getExecutor(URL url) {
         final  Executor executor = super.getExecutor(url);
         if(executor instanceof  ThreadPoolExecutor){
             THREAD_POOLS.put(url,(ThreadPoolExecutor)executor);
         }
         return  executor;
    }

    @Override
    public void run() {
         // 遍历线程池
         for (Map.Entry<URL,ThreadPoolExecutor> entry: THREAD_POOLS.entrySet()){
              final   URL  url = entry.getKey();
              final   ThreadPoolExecutor  executor = entry.getValue();
              // 计算相关指标
              final  int  activeCount  = executor.getActiveCount();
              final  int  poolSize = executor.getCorePoolSize();
              double  usedPercent = activeCount / (poolSize*1.0);
              LOGGER.info("线程池执行状态:[{}/{}:{}%]",activeCount,poolSize,usedPercent*100);
              if (usedPercent > ALARM_PERCENT){
                  LOGGER.error("超出警戒线! host:{} 当前使用率是:{},URL:{}",url.getIp(),usedPercent*100,url);
              }

         }
    }
}

2、声明

SPI声明，创建文件 META-INF/dubbo/org.apache.dubbo.common.threadpool.ThreadPool

3、在服务提供方项目引入该依赖

4、在服务提供方项目中设置使用该线程池生成器

5、接下来需要做的就是模拟整个流程，因为该线程当前是每1秒抓一次数据，所以我们需要对该方法

的提供者超过1秒的时间(比如这里用休眠 Thread.sleep )，消费者则需要启动多个线程来并行执行，来

模拟整个并发情况。

6、在调用方则尝试简单通过for循环启动多个线程来执行查看服务提供方的监控情况

8、路由

1、我们通过ipconfifig来查询到我们的IP地址，并且单独启动一个客户端，来进行如下配置(这里假设

我们希望隔离掉本机的请求，都发送到另外一台机器上)。

public class DubboRouterMain { 
public static void main(String[] args) { 
     RegistryFactory registryFactory = 	     ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension() ; Registry registry =      registryFactory.getRegistry(URL.valueOf("zookeeper://127.0.0.1:2181")); registry.register(URL.valueOf("condition://0.0.0.0/com.lagou.service.HelloService?category=routers&force=true&dynamic=true&rule=" + URL.encode("=> host != 你的 机器ip不能是127.0.0.1"))); 
     } 
 }

2、通过这个程序执行后，我们就通过消费端不停的发起请求，看到真实的请求都发到了除去本机以

外的另外一台机器上。

3、路由器详解

route:// 表示路由规则的类型，支持条件路由规则和脚本路由规则，可扩展，必填。
0.0.0.0 表示对所有 IP 地址生效，如果只想对某个 IP 的生效，请填入具体 IP，必填。 com.lagou.service.HelloService 表示只对指定服务生效，必填。
category=routers 表示该数据为动态配置类型，必填。 
dynamic : 是否为持久数据，当指定服务重启时是否继续生效。必填。
runtime : 是否在设置规则时自动缓存规则，如果设置为true则会影响部分性能。
rule : 是整个路由最关键的配置，用于配置路由规则。
... => ... 在这里 => 前面的就是表示消费者方的匹配规则，可以不填(代表全部)。 => 后方则必
须填写，表示当请求过来时，如果选择提供者的配置。官方这块儿也给出了详细的示例，可以按照
那里来讲。
其中使用最多的便是 host 参数。 必填。

4、思路

1.利用zookeeper的路径感知能力，在服务准备进行重启之前将当前机器的IP地址和应用名写入 zookeeper。 
2.服务消费者监听该目录，读取其中需要进行关闭的应用名和机器IP列表并且保存到内存中。
3.当前请求过来时，判断是否是请求该应用，如果是请求重启应用，则将该提供者从服务列表中移除。

（1）引入 Curator 框架，用于方便操作Zookeeper

（2）编写Zookeeper的操作类，用于方便进行zookeeper处理

（3）编写需要进行预发布的路径管理器，用于缓存和监听所有的待灰度机器信息列表。

（4）编写路由类(实现 org.apache.dubbo.rpc.cluster.Router )，主要目的在于对

ReadyRestartInstances 中的数据进行处理，并且移除路由调用列表中正在重启中的服务。

（5）由于 Router 机制比较特殊，所以需要利用一个专门的 RouterFactory 来生成，原因在于并不是

所有的都需要添加路由，所以需要利用 @Activate 来锁定具体哪些服务才需要生成使用。

@Activate public class RestartingInstanceRouterFactory implements RouterFactory { @Override 
  public Router getRouter(URL url) {
    return new RestartingInstanceRouter(url); 
	} 
}

（6）对 RouterFactory 进行注册，同样放入到

META-INF/dubbo/org.apache.dubbo.rpc.cluster.RouterFactory 文件中。

restartInstances=com.lagou.router.RestartingInstanceRouterFactory

（7）将dubbo-spi-router项目引入至 consumer 项目的依赖中。

（8）这时直接启动程序，还是利用上面中所写好的 consumer 程序进行执行，确认各个 provider 可以

正常执行。

（9）单独写一个 main 函数来进行将某台实例设置为启动中的状态，比如这里我们认定为当前这台机器

中的 service-provider 这个提供者需要进行重启操作。

ReadyRestartInstances.create().addRestartingInstance("service-provider", "正在 重新启动的机器IP");

（10）执行完成后，再次进行尝试通过 consumer 进行调用，即可看到当前这台机器没有再发送任何请

求

（11）一般情况下，当机器重启到一定时间后，我们可以再通过 removeRestartingInstance 方法对

这个机器设定为既可以继续执行。

（12）调用完成后，我们再次通过 consumer 去调用，即可看到已经再次恢当前机器的请求参数。

9、服务降级

dubbo 服务降级实现方式

第一种在 dubbo 管理控制台配置服务降级

屏蔽和容错

mock=force:return+null

表示消费方对该服务的方法调用都直接返回 null 值，不发起远程调用。用来屏蔽不重要服务不可

用时对调用方的影响。

mock=fail:return+null

表示消费方对该服务的方法调用在失败后，再返回 null 值，不抛异常。用来容忍不重要服务不稳

定时对调用方的影响。

第二种指定返回简单值或者null

如果是标注则使用@Reference(mock=“return null”) @Reference(mock=“return 简单值”)

也支持 @Reference(mock=“force:return null”)

第三种使用java代码动态写入配置中心

RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension() ;Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://IP:端 口")); registry.register(URL.valueOf("override://0.0.0.0/com.foo.BarService? category=configurators&dynamic=false&application=foo&mock=force:return+null"));

第四种整合整合 hystrix 会在后期SpringCloud课程中详细讲解

四、源码

1、调用链

说明淡绿色代表了服务生产者的范围淡蓝色代表了服务消费者的范围红色箭头代表了调用的方

向

业务逻辑层 RPC层(远程过程调用) Remoting (远程数据传输)

整体链路调用的流程:

消费者通过Interface进行方法调用统一交由消费者端的 Proxy 通过ProxyFactory 来进行代理

对象的创建使用到了 jdk javassist技术

2.交给Filter 这个模块做一个统一的过滤请求在SPI案例中涉及过

3.接下来会进入最主要的Invoker调用逻辑

通过Directory 去配置中新读取信息最终通过list方法获取所有的Invoker

通过Cluster模块根据选择的具体路由规则来选取Invoker列表

通过LoadBalance模块根据负载均衡策略选择一个具体的Invoker 来处理我们的请求

如果执行中出现错误并且Consumer阶段配置了重试机制则会重新尝试执行

继续经过Filter 进行执行功能的前后封装 Invoker 选择具体的执行协议
客户端进行编码和序列化然后发送数据
到达Consumer中的 Server 在这里进行反编码和反序列化的接收数据
使用Exporter选择执行器
交给Filter 进行一个提供者端的过滤到达 Invoker 执行器
通过Invoker 调用接口的具体实现然后返回

2、Dubbo源码整体设计

图例说明：

图中左边淡蓝背景的为服务消费方使用的接口，右边淡绿色背景的为服务提供方使用的接口，位于

中轴线上的为双方都用到的接口。图中从下至上分为十层，各层均为单向依赖，右边的黑色箭头代表层之间的依赖关系，每一层都可

以剥离上层被复用，其中，Service 和 Confifig 层为 API，其它各层均为 SPI。

图中绿色小块的为扩展接口，蓝色小块为实现类，图中只显示用于关联各层的实现类。

图中蓝色虚线为初始化过程，即启动时组装链，红色实线为方法调用过程，即运行时调时链，紫色

三角箭头为继承，可以把子类看作父类的同一个节点，线上的文字为调用的方法。

Dubbo源码整体设计与调用链路十分相似。只不过这里可以看到接口的一些具体实现以及左侧也

有更为详细的层次划分，我们在后面的源码解析时也会着重介绍其中比较重要的模块实现。

分层介绍***

Business 业务逻辑层

service 业务层包括我们的业务代码比如接口实现类直接面向开发者

RPC层远程过程调用层

confifig 配置层对外提供配置以ServiceConfifig ReferenceConfifig 为核心可以直接初始化配置

类也可以解析配置文件生成

proxy 服务代理层无论是生产者还是消费者框架都会产生一个代理类整个过程对上层透明就是

业务层对远程调用无感

registry 注册中心层封装服务地址的注册与发现以服务的URL为中心

cluster 路由层 (集群容错层) 提供了多个提供者的路由和负载均衡并且它桥接注册中心以

Invoker为核心

monitor 监控层 RPC调用相关的信息如调用次数成功失败的情况调用时间等在这一层完成

protocol 远程调用层封装RPC调用无论是服务的暴露还是服务的引用都是在Protocol中作为主

功能入口负责Invoker的整个生命周期 Dubbo中所有的模型都向Invoker靠拢

Remoting层远程数据传输层

exchange 信息交换层封装请求和响应的模式如把请求由同步转换成异步

transport 网络传输层统一网络传输的接口比如 netty 和 mina 统一为一个网络传输接口

serialize 数据序列化层负责管理整个框架中的数据传输的序列化和反序列化

3、服务注册与消费源码剖析

1、接口服务

只有一个提供者和消费者。 com.lagou.service.HelloService 为我们所提供的服务。

public interface HelloService { String sayHello(String name); }

可以在这里看到所有的都是在dubbo层级下的

dubbo跟节点下面是当前所拥有的接口名称，如果有多个接口，则会以多个子节点的形式展开

每个服务下面又分别有四个配置项

consumers: 当前服务下面所有的消费者列表(URL)

providers: 当前服务下面所有的提供者列表(URL)

confifiguration: 当前服务下面的配置信息信息，provider或者consumer会通过读取这里的配

置信息来获取配置

routers: 当消费者在进行获取提供者的时，会通过这里配置好的路由来进行适配匹配规则。

可以看到，dubbo基本上很多时候都是通过URL的形式来进行交互获取数据的，在URL中也会保存

很多的信息。后面也会对URL的规则做详细介绍。

提供者会在 providers 目录下进行自身的进行注册。

消费者会在 consumers 目录下进行自身注册，并且监听 provider 目录，以此通过监听提供者增

加或者减少，实现服务发现。

Monitor模块会对整个服务级别做监听，用来得知整体的服务情况。以此就能更多的对整体情况做

监控。

4、服务的注册过程分析

首先 ServiceConfig 类拿到对外提供服务的实际类 ref(如：HelloServiceImpl),然后通过

ProxyFactory 接口实现类中的 getInvoker 方法使用 ref 生成一个 AbstractProxyInvoker 实例，

到这一步就完成具体服务到 Invoker 的转化。接下来就是 Invoker 转换到 Exporter 的过程。

查看ServiceConfifig 类

重点查看 ProxyFactory 和 Protocol 类型的属性以及 ref

下面我们就看一下Invoker 转换成 Exporter的过程

其中会涉及到 RegistryService接口 RegistryFactory 接口和注册provider到注册中心流程的过程

（1）RegistryService代码解读,这块儿的代码比较简单，主要是对指定的路径进行注册，解绑，监听和

取消监听，查询操作。也是注册中心中最为基础的类。

public interface RegistryService { 
/*** 进行对URL的注册操作，比如 provider，consumer，routers等 */ 
void register(URL url);
/*** 解除对指定URL的注册，比如provider，consumer，routers等 */ 
void unregister(URL url);
/*** 增加对指定URL的路径监听，当有变化的时候进行通知操作 */ 
void subscribe(URL url, NotifyListener listener);
/*** 解除对指定URL的路径监听，取消指定的listener */
void unsubscribe(URL url, NotifyListener listener); 
/*** 查询指定URL下面的URL列表，比如查询指定服务下面的consumer列表 */ List<URL> lookup(URL url); 
}

（2）我们再来看 RegistryFactory ，是通过他来生成真实的注册中心。通过这种方式，也可以保证一

个应用中可以使用多个注册中心。可以看到这里也是通过不同的protocol参数，来选择不同的协议。

@SPI("dubbo") 
public interface RegistryFactory { 
/*** 获取注册中心地址 */
    @Adaptive({"protocol"}) 
    Registry getRegistry(URL url);
}

（3）一个服务是如何注册到注册中心上去的。其中比较关键的一个类是

RegistryProtocol ，他负责管理整个注册中心相关协议。并且统一对外提供服务。这里我们主要以

RegistryProtocol.export 方法作为入口，这个方法主要的作用就是将我们需要执行的信息注册并且

导出。

（4） register 方法, 这里面做的比较简单，主要是从 RegistoryFactory 中获取注

册中心，并且进行地址注册。

 public void register(URL registryUrl, URL registeredProviderUrl) {
        // 获取注册中心 
        Registry registry = registryFactory.getRegistry(registryUrl);
        // 对当前的服务进行注册 
        registry.register(registeredProviderUrl);
        // ProviderModel 表示服务提供者模型，此对象中存储了与服务提供者相关的信息。 
        // 比如服务的配置信息，服务实例等。每个被导出的服务对应一个 ProviderModel。 
        ProviderModel model = ApplicationModel.getProviderModel(registeredProviderUrl.getServiceKey());
        model.addStatedUrl(new ProviderModel.RegisterStatedURL(registeredProviderUrl, registryUrl, true));
    }

（5）这里我们再跟里面的register方法之前，先来介绍一下Registry中的类目录结构

+- RegistryService 
| +- Registry 
| | +- AbstractRegistry 
| | | +- FailbackRegistry 
| | | | +- ZookeeperRegistry 
| | | | +- NacosRegistry 
| | | | +- ...

目录结构描述如下：

在这里每个层级代表继承自父级

这里面 RegistryService 就是我们之前所讲对外提供注册机制的接口。

其下面 Registry 也同样是一个接口，是对 RegistryService 的集成，并且继承了 Node 接口，

说明注册中心也是基于URL去做的。

AbstractRegistry 是对注册中心的封装，其主要会对本地注册地址的封装，主要功能在于远程

注册中心不可用的时候，可以采用本地的注册中心来使用。

FailbackRegistry 从名字中可以看出来，失败自动恢复，后台记录失败请求，定时重发功能。

最深的一层则更多是真实的第三方渠道实现。

（6）下面我们来看一下在 FailbackRegistry 中的实现, 可以在这里看到他的主要作用是调用第三方的

实现方式，并且在出现错误时增加重试机制。

 public void register(URL url) {
// 上层调用 // 主要用于保存已经注册的地址列表
        super.register(url);
// 将一些错误的信息移除(确保当前地址可以在出现一些错误的地址时可以被删除) removeFailedRegistered(url);
        removeFailedUnregistered(url);
        try {
// 发送给第三方渠道进行注册操作 
            doRegister(url);
        } catch (Exception e) {
            Throwable t = e;
// 记录日志 
            boolean check = getUrl().getParameter(Constants.CHECK_KEY, true) && url.getParameter(Constants.CHECK_KEY, true) && !CONSUMER_PROTOCOL.equals(url.getProtocol());
            boolean skipFailback = t instanceof SkipFailbackWrapperException;
            if (check || skipFailback) {
                if (skipFailback) {
                    t = t.getCause();
                }
                throw new IllegalStateException("Failed to register " + url + " to registry " + getUrl().getAddress() + ", cause: " + t.getMessage(), t);
            } else {
                logger.error("Failed to register " + url + ", waiting for retry, cause: " + t.getMessage(), t);
            }// 后台异步进行重试，也是Failback比较关键的代码
            addFailedRegistered(url);
        }
    }

（7）下面我们再来看看Zookeeper中 doRegister 方法的实现, 可以看到这里的实现也比较简单，关键

在于 toUrlPath 方法的实现。关于 dynamic 的值，我们也在上面有看到，他的URL也是true的。

    public void doRegister(URL url) {
        try {
// 进行创建地址 
            zkClient.create(toUrlPath(url), url.getParameter(DYNAMIC_KEY, true));
        } catch (Throwable e) {
            throw new RpcException("Failed to register " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e); }
    }

（8）解读 toUrlPath 方法。可以看到这里的实现也是比较简单，也验证了我们之前的路径规则。

 private String toUrlPath(URL url) {
// 分类地址 + url字符串
        return toCategoryPath(url) + PATH_SEPARATOR + URL.encode(url.toFullString());
    }

    private String toCategoryPath(URL url) {
// 服务名称 + category(在当前的例子中是providers)
        return toServicePath(url) + PATH_SEPARATOR + url.getParameter(CATEGORY_KEY, DEFAULT_CATEGORY);
    }

    private String toServicePath(URL url) {
// 接口地址 
        String name = url.getServiceInterface();
        if (ANY_VALUE.equals(name)) {
            return toRootPath();
        }
// 根节点 + 接口地址
        return toRootDir() + URL.encode(name);
    }

5、URL规则详解和服务本地缓存

protocol://host:port/path?key=value&key=value provider://192.168.20.1:20883/com.lagou.service.HelloService? anyhost=true&application=service- provider2&bind.ip=192.168.20.1&bind.port=20883&category=configurators&check=fals e&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&interface=com.lagou.se rvice

URL主要有以下几部分组成：

protocol: 协议，一般像我们的 provider 或者 consumer 在这里都是人为具体的协议

host: 当前 provider 或者其他协议所具体针对的地址，比较特殊的像 override 协议所指定的

host就是 0.0.0.0 代表所有的机器都生效

port: 和上面相同，代表所处理的端口号

path: 服务路径，在 provider 或者 consumer 等其他中代表着我们真实的业务接口

key=value: 这些则代表具体的参数，这里我们可以理解为对这个地址的配置。比如我们 provider

中需要具体机器的服务应用名，就可以是一个配置的方式设置上去。

注意：Dubbo中的URL与java中的URL是有一些区别的，如下：

这里提供了针对于参数的 parameter 的增加和减少(支持动态更改)

提供缓存功能，对一些基础的数据做缓存.

6、本地缓存

（1）首先从构造方法讲起, 这里方法比较简单，主要用于确定需要保存的文件信息。并且从系统中读取

已有的配置信息。

    public AbstractRegistry(URL url) {
        setUrl(url);
// Start file save timer 
        syncSaveFile = url.getParameter(REGISTRY_FILESAVE_SYNC_KEY, false);
// 默认保存路径(home/.dubbo/dubbo-registry-appName-address-port.cache) 
        String defaultFilename = System.getProperty("user.home") + "/.dubbo/dubbo- registry-" + url.getParameter(APPLICATION_KEY) + "-" + url.getAddress().replaceAll(":", "-") + ".cache";
        String filename = url.getParameter(FILE_KEY, defaultFilename);
// 创建文件 
        File file = null; if (ConfigUtils.isNotEmpty(filename)) {
            file = new File(filename);
            if (!file.exists() && file.getParentFile() != null && !file.getParentFile().exists()) { if (!file.getParentFile().mkdirs()) {
                throw new IllegalArgumentException("Invalid registry cache file " + file + ", cause: Failed to create directory " + file.getParentFile() + "!"); }
            }
        }this.file = file;
// 加载已有的配置文件
        loadProperties(); notify(url.getBackupUrls()); }

（2）我们可以看到这个类中最为关键的一个属性为 properties ，我们可以通过寻找，得知这个属性

的设置值只有在一个地方: saveProperties ，我们来看一下这个方法。这里也有一个我们值得关注的

点，就是基于版本号的的更改。

private void saveProperties(URL url) {
        if (file null){
            return;
        }
        try {
            StringBuilder buf = new StringBuilder();
// 获取所有通知到的地址 
            Map<String, List<URL>> categoryNotified = notified.get(url);
            if (categoryNotified != null) {
                for (List<URL> us : categoryNotified.values()) {
                    for (URL u : us) {
// 多个地址进行拼接
                        if (buf.length() > 0) {
                            buf.append(URL_SEPARATOR);
                        }
                        buf.append(u.toFullString());
                    }
                }
            }
// 保存数据
            properties.setProperty(url.getServiceKey(), buf.toString());
// 保存为一个新的版本号 
// 通过这种机制可以保证后面保存的记录，在重试的时候，不会重试之前的版本 
            long version = lastCacheChanged.incrementAndGet();
// 需要同步保存则进行保存 if (syncSaveFile) { doSaveProperties(version); } else {
// 否则则异步去进行处理
            registryCacheExecutor.execute(new SaveProperties(version));
        }
    } catch(
    Throwable t)

    {
        logger.warn(t.getMessage(), t);
    }
}

（3）下面我们再来看看是如何进行保存文件的。这里的实现也比较简单，主要比较关键的代码在于利

用文件级锁来保证同一时间只会有一个线程执行。

public void doSaveProperties(long version) {
        if (version < lastCacheChanged.get()) {
            return;
        }
        if (file null){
            return;
        }// Save try {
// 使用文件级别所，来保证同一段时间只会有一个线程进行读取操作 
        File lockfile = new File(file.getAbsolutePath() + ".lock");
        if (!lockfile.exists()) {
            lockfile.createNewFile();
        }
        try (RandomAccessFile raf = new RandomAccessFile(lockfile, "rw"); FileChannel channel = raf.getChannel()) {
// 利用文件锁来保证并发的执行的情况下，只会有一个线程执行成功(原因在于可能是跨 VM的) 
            FileLock lock = channel.tryLock();
            if (lock null){
                throw new IOException("Can not lock the registry cache file " + file.getAbsolutePath() + ", ignore and retry later, maybe multi java process use the file, please config: dubbo.registry.file=xxx.properties");
            }
// Save 
            try {
                if (!file.exists()) {
                    file.createNewFile();
                }
// 将配置的文件信息保存到文件中
                try (FileOutputStream outputFile = new FileOutputStream(file)) {
                    properties.store(outputFile, "Dubbo Registry Cache");
                }
            } finally {
// 解开文件锁 
                lock.release();
            }
        }
    } catch(
    Throwable e)

    {
// 执行出现错误时，则交给专门的线程去进行重试
        savePropertiesRetryTimes.incrementAndGet();
        if (savePropertiesRetryTimes.get() >= MAX_RETRY_TIMES_SAVE_PROPERTIES) {
            logger.warn("Failed to save registry cache file after retrying " + MAX_RETRY_TIMES_SAVE_PROPERTIES + " times, cause: " + e.getMessage(), e);
            savePropertiesRetryTimes.set(0);
            return;
        }
        if (version < lastCacheChanged.get()) {
            savePropertiesRetryTimes.set(0);
            return;
        } else {
            registryCacheExecutor.execute(new SaveProperties(lastCacheChanged.incrementAndGet()));
        }
        logger.warn("Failed to save registry cache file, will retry, cause: " + e.getMessage(), e);
    }
}

7、 Dubbo 消费过程分析

首先 ReferenceConfig 类的 init 方法调用 createProxy() ,期间使用 Protocol 调用 refer 方法生

成 Invoker 实例(如上图中的红色部分)，这是服务消费的关键。接下来使用ProxyFactory把 Invoker

转换为客户端需要的接口(如：HelloService)。

8、SPI源码剖析

（1）SPI在之前都有使用过，其中最重要的类就是 ExtensionLoader ，它是所有Dubbo中SPI的入口。

我们通过分析源码来学习 ExtensionLoader 是怎么加载的。这里会具体介绍

org.apache.dubbo.common.extension.ExtensionLoader.getExtensionLoader 和

org.apache.dubbo.common.extension.ExtensionLoader.getExtension 方法。

getExtensionLoader 获取扩展点加载器并加载所对应的所有的扩展点实现

getExtension 根据name 获取扩展的指定实现

getExtensionLoader 加载过程

private static <T> boolean withExtensionAnnotation(Class<T> type) {
// 包含`@SPI`注解在接口上
        return type.isAnnotationPresent(SPI.class);
    }

    public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
        @SuppressWarnings("unchecked")
// 必须传入类型 
        if (type == null) {
            throw new IllegalArgumentException("Extension type null");
        }
// 必须是接口类型 
        if (!type.isInterface()) {
            throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");
        }
// 必须包含SPI的注解
        if (!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type (" + type + ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
        }
// 尝试从已经加载过的数据中去读取(缓存功能)
        ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        if (loader == null) {
// 如果没有的话，才会进行初始化，并且放入到缓存汇总
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
            loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

（2）具体看一下 ExtensionLoader 的构造器函数, 这里他的实现比较简单，并没有做太多的操作。主

要是对type进行赋值操作，然后获取 ExtensionFactory 对象。

private ExtensionLoader(Class type) { 
this.type = type; 
// 这里需要对对象的工厂做额外的创建，可以看到扩展的工厂也是一个扩展点
objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension( )); 
}

（3）具体再来关注一下 ExtensionFactory 是做什么用的, 从这里我们可以大概的看出来，他是通过传

入扩展点类型和真正的名称来获取扩展的。这里就和我们SPI中的具体名称实现相挂钩。

@SPI public interface ExtensionFactory {
/*** Get extension. 
** @param type object type. 
* @param name object name. 
* @return object instance.
*/ 
 T getExtension(Class type, String name);
}

（4）可以在 dubbo-common/src/main/resources/META-

INF/dubbo/internal/org.apache.dubbo.common.extension.ExtensionFactory 中看到，他默认

有三个实现的提供

spring=org.apache.dubbo.config.spring.extension.SpringExtensionFactory adaptive=org.apache.dubbo.common.extension.factory.AdaptiveExtensionFactory spi=org.apache.dubbo.common.extension.factory.SpiExtensionFactory

（5）可以看到在 AdaptiveExtensionFactory 中是使用 @Adaptive 标记的。这里可以通过类名基本

看出来，他其实最主要的作用是进行代理其他的ExtensionFactory。其中比较重要的方法在于

getSupportedExtensions 方法，获取所有支持的扩展信息实现。

 @Adaptive
    public class AdaptiveExtensionFactory implements ExtensionFactory {
        private final List<ExtensionFactory> factories;

        public AdaptiveExtensionFactory() {
// 获取针对ExtensionFactory扩展加载器 
            ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
            List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
// 获取支持的扩展
            for (String name : loader.getSupportedExtensions()) {
// 将所有的ExtensionFactory进行缓存 
                list.add(loader.getExtension(name));
            }
            factories = Collections.unmodifiableList(list);
        }

        @Override
        public <T> T getExtension(Class<T> type, String name) {
            for (ExtensionFactory factory : factories) {
// 交给每个真实的ExtensionFactory来处理
                T extension = factory.getExtension(type, name);
                if (extension != null) {
                    return extension;
                }
            }
            return null;
        }
    }

（6）获取所有支持的扩展信息实现: ExtensionLoader.getSupportedExtensions ，这里可以看到，

其实比较关键的方法在于 getExtensionClasses 方法

public Set getSupportedExtensions() { 
// 获取所有的扩展类信息 
Map> clazzes = getExtensionClasses(); 
// 返回所有的扩展点名称
return Collections.unmodifiableSet(new TreeSet<>(clazzes.keySet()));
}

（7）观察 getExtensionClasses 的实现,可以看到这里其实主要做的就是一件事情，防止重复被加

载，所以真正的的实现还需要专门去查看 loadExtensionClasses 方法

在我们通过名称获取扩展类之前,首先需要根据配置文件解析出扩展类名称到扩展类的映射关系表

classes

之后再根据扩展项名称从映射关系表中获取取对应的扩展类即可。相关过程代码分析如下

private Map> getExtensionClasses() { 
// 从缓存中获取已加载的扩展类 
Map> classes = cachedClasses.get(); 
// 双重检查 if (classes == null) {
// 为空的话，则锁住，标识只会被执行一次
synchronized (cachedClasses) { 
classes = cachedClasses.get(); if (classes == null) {
// 进行加载信息 加载扩展类 
classes = loadExtensionClasses(); cachedClasses.set(classes); }
} 
}return classes;
}

（8）观察 loadExtensionClasses 方法实现。这里主要做了两件事情。1: 加载当前SPI的默认实现。2:

加载这个类的所有扩展点实现，并且按照name和Class对象的形式存储，下面会专门针对于

cacheDefaultExtensionName 和 loadDirectory 方法做说明

    private Map<String, Class<?>> loadExtensionClasses() {
// 加载默认扩展的实现名称 cacheDefaultExtensionName();
// 获取其中每一种实现的名称和对应的classes
// 具体的目录请参照下面的所有目录
        Map<String, Class<?>> extensionClasses = new HashMap<>();
// internal extension load from ExtensionLoader's ClassLoader first 
loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName(), true);
        loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"), true);
        loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName());
        loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
        loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName());
        loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
        return extensionClasses;
    }

观察 cacheDefaultExtensionName 方法实现。这里面的是实现比较简单，主要用于读取注解中value

值来获取到默认的名称。

    private void cacheDefaultExtensionName() {
// 获取当前类是否包含SPI注解，一般走到这里都是拥有这个注解的 
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if (defaultAnnotation == null) {
            return;
        }
// 来获取其的value值，这个值主要的作用是设置这个SPI中的默认扩展名
// 比如LoadBalance的默认实现就是random。就是通过这里进行的设置 
        String value = defaultAnnotation.value();
        if ((value = value.trim()).length() > 0) {
            String[] names = NAME_SEPARATOR.split(value);
            if (names.length > 1) {
                throw new IllegalStateException("More than 1 default extension name on extension " + type.getName() + ": " + Arrays.toString(names));
            }
            if (names.length 1){
                cachedDefaultName = names[0];
            }
        }
    }

观察 loadDirectory 方法实现。这里的主要功能是从这个文件夹中寻找真正的文件列表，并且对其中

的文件内容解析并且放入到 extensionClasses Map中，具体解析文件的内容实现，还要参考

loadResource 实现。

 private void loadDirectory(Map> extensionClasses, String dir, String type, boolean extensionLoaderClassLoaderFirst) {
// 文件名称规则: 路径/包名.接口名 String fileName = dir + type; try {
// 寻找classloader和url列表 Enumeration urls = null; ClassLoader classLoader = findClassLoader(); // try to load from ExtensionLoader's ClassLoader first 
// 如果需要的话, 需要先从当前类的ClassLoader中寻找 
        if (extensionLoaderClassLoaderFirst) {
            ClassLoader extensionLoaderClassLoader = ExtensionLoader.class.getClassLoader();
            if (ClassLoader.getSystemClassLoader() != extensionLoaderClassLoader) {
                urls = extensionLoaderClassLoader.getResources(fileName);
            }
        }
// 如果找不到任何的URL列表，则继续尝试去其当前线程的ClassLoader中寻找 
        if (urls == null || !urls.hasMoreElements()) {
            if (classLoader != null) {
                urls = classLoader.getResources(fileName);
            } else {
                urls = ClassLoader.getSystemResources(fileName);
            }
        }
// 如果存在文件的话 
        if (urls != null) {
            while (urls.hasMoreElements()) {
// 遍历每一个资源文件，并且进行加载资源信息到extensionClasses, 主要功能 是读取文件内容 java.net.URL resourceURL = urls.nextElement(); 
                loadResource(extensionClasses, classLoader, resourceURL);
            }
        }
    } catch(
    Throwable t)

    {
        logger.error("Exception occurred when loading extension class (interface: " + type + ", description file: " + fileName + ").", t);
    }
}

（9）进行观察 loadResource 实现，主要是用于读取文件操作，并且将方法交由 loadClass 来加载类

信息。加载类信息也是最重要的方法所在。

 private void loadResource(Map> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
        try {
            // 读取文件
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    // 截取文件#前面的内容
                    final int ci = line.indexOf('#');
                    if (ci >= 0) {
                        line = line.substring(0, ci);
                    }
                    line = line.trim();
                    // 如果有内容的话
                    if (line.length() > 0) {
                        try {
                            // 则进行加载key=value的形式数据
                            String name = null;
                            int i = line.indexOf('=');
                            if (i > 0) {
                                name = line.substring(0, i).trim();
                                line = line.substring(i + 1).trim();
                            }
                            if (line.length() > 0) {
                                // 对类信息进行加载操作
                                loadClass(extensionClasses, resourceURL, Class.forName(line, true, classLoader), name);
                            }
                        } catch (Throwable t) {
                            IllegalStateException e = new IllegalStateException("Failed to load extension class (interface: " + type + ", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);
                            exceptions.put(line, e);
                        }
                    }
                }
            }
        } catch (Throwable t) {
            logger.error("Exception occurred when loading extension class (interface: " + type + ", class file: " + resourceURL + ") in " + resourceURL, t);
        }
    }

（10）观察 loadClass 类的实现，可以看到这里是最终进行完成类映射的地方。关于Adaptive中的类

实现原理，我们放在这个章节中的偏后面进行细讲

 private void loadClass(Map> extensionClasses, java.net.URL resourceURL, Class clazz, String name) throws NoSuchMethodException {
// 当前扩展点的实现，必须是当前扩展接口的实现才可以
        if (!type.isAssignableFrom(clazz)) {
            throw new IllegalStateException("Error occurred when loading extension class (interface: " + type + ", class line: " + clazz.getName() + "), class " + clazz.getName() + " is not subtype of interface.");
        }
// 如果是包含了Adaptive注解，则认为是需要对扩展点包装的方法，这里只做了存储操作，存储至 cachedAdaptiveClass中

        if (clazz.isAnnotationPresent(Adaptive.class)) {
            cacheAdaptiveClass(clazz);
        } else if (isWrapperClass(clazz)) {
// 判断是否是wapper类型, 是否构造函数中有该接口类型的传入
// wrapper类型的意思是，对当前的扩展点实现封装功能处理 
            cacheWrapperClass(clazz);
        } else {
            clazz.getConstructor();
// 寻找他是否已经定义过了名称, 这里就不继续往里面细看了,主要是获取当前类的 org.apache.dubbo.common.Extension注解，如果有的话就使用这个名称，否则的话就是用当前类的 简单名称
            if (StringUtils.isEmpty(name)) {
                name = findAnnotationName(clazz);
                if (name.length() == 0) {
                    throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
                }
            }
// 否则的话，就对这个名称和class做映射关系
            String[] names = NAME_SEPARATOR.split(name);
            if (ArrayUtils.isNotEmpty(names)) {
// 如果当前类拥有Activate注解，则将其进行添加到cachedActivates对象中，意味 着需要执行 
                cacheActivateClass(clazz, names[0]);
// 进行名称映射保存
                for (String n : names) {
                    cacheName(clazz, n);
                    saveInExtensionClass(extensionClasses, clazz, n);
                }
            }
        }
    }

当执行完这几个方法之后，会对一下几个字段进行更新:

cachedAdaptiveClass: 当前Extension类型对应的AdaptiveExtension类型(只能一个)

cachedWrapperClasses: 当前Extension类型对应的所有Wrapper实现类型(无顺序)

cachedActivates: 当前Extension实现自动激活实现缓存(map,无序)

cachedNames: 扩展点实现类对应的名称(如配置多个名称则值为第一个)

根据name获取扩展点的方法 getExtension

（1） getExtension 方法实现。这里面同样主要作用是根据name对扩展点进行处理和进行加锁来创建

真实的引用，其中都是有使用缓存来处理。

public T getExtension(String name) { 
if (StringUtils.isEmpty(name)) { throw new IllegalArgumentException("Extension name null"); }
// 获取当前SPi的默认扩展实现类 
if ("true".equals(name)) { return getDefaultExtension(); }
// 获取当前类的holder，实现原理和cachedClasses的方式相同，都是建立同一个引用后再进行 加锁
final Holder