SpringCloud+Dubbo3 = 王炸！

ゞ浴缸里的玫瑰 2024-03-26 12:28 64阅读 0赞

### 前言 ###

### 全链路异步化的大趋势来了 ###

随着业务的发展，微服务应用的流量越来越大，使用到的资源也越来越多。

在微服务架构下，大量的应用都是 SpringCloud 分布式架构，这种架构总体上是**全链路同步模式**。

**全链路同步模式**不仅造成了资源的极大浪费，并且在流量发生激增波动的时候，受制于系统资源而无法快速的扩容。

全球后疫情时代，降本增效是大背景。如何降本增效？

可以通过技术升级，**全链路同步模式** ，升级为 **全链路异步模式**。

先回顾一下全链路同步模式架构图

![2b45f03e8f594b17969f86e170d667d4.png][]

**全链路同步模式** ，如何升级为 **全链路异步模式**， 就是一个一个 环节的异步化。

40岁老架构师尼恩，持续深化自己的3高架构知识宇宙，当然首先要去完成一次牛逼的**全链路异步模式 微服务实操，下面是尼恩的实操过程、效果、压测数据(性能足足提升10倍多)。**

**全链路异步模式**改造 具体的内容，请参考尼恩的深度文章：[全链路异步，让你的 SpringCloud 性能优化10倍+][SpringCloud _10]

并且，上面的文章，作为尼恩 全链路异步的架构知识，收录在《[尼恩Java面试宝典][Java]》V46版的架构专题中

> 注：本文以 PDF 持续更新，最新尼恩 架构笔记、面试题 的PDF文件，请从这里获取：[码云][Link 1]

### SpringCloud + Dubbo 完成 RPC 异步 ###

高并发时代来了， 各大项目有越来越强烈的诉求，全链路异步， 是性能优化的一个杀手锏。

全链路异步核心环境，就是RPC的异步化。

使用Dubbo来替换Feign，足足可以提升10倍性能。

所以，SpringCloud + Dubbo RPC 的集成 是一个比较刚性的需求。

**有小伙伴查招聘网站，发现很多需要有SpringCloud + Dubbo 的集成经验，刚好印证了这点。**

接下来，尼恩一步一步带着大家，来做一下 SpringCloud + Dubbo RPC 的集成实验+性能测试。

见证一下奇迹： 使用Dubbo 提升10倍的性能。

### Dubbo3应用的宏观架构 ###

Dubbo3应用架构，如下图所示：

![bb08927427bb40f5af9c5e318da7a9e7.png][]

从上面的图中，整体的的Dubbo的Rpc框架中，核心的组件有：

*  config-center 配置中心，接下来使用 nacos
 *  Consumer消费端， 业务服务，使用Dubbo SDK 完成服务发现
 *  Provider服务提供端，业务服务，使用Dubbo SDK 完成服务注册
 *  Registry注册中心 配置中心，接下来使用 nacos

### Dubbo3 应用架构的核心组件 ###

两大部分：

*  一个Dubbo SDK
 *  三中心

**Dubbo SDK**

Dubbo SDK作为模块，被微服务所引入和依赖。跟随着微服务组件被部署在分布式集群各个位置，实现各个微服务组件间的协作，主要是服务的注册、服务的发现

**三中心**

Dubbo3包含一些中心化组件，主要有3个，这包括：

*  注册中心
    
     *  协调Consumer消费者与Provider服务提供者之间的地址注册与发现。
 *  配置中心
    
     *  存储Dubbo启动阶段的全局配置，保证配置的跨环境共享与全局一致性
     *  负责服务治理规则（路由规则、动态配置等）的存储与推送。
 *  元数据中心
    
     *  接收Provider服务端上报的服务接口元数据，为Admin等控制台提供运维能力（如服务测试、接口文档等）
     *  作为服务发现机制的补充，提供额外的接口/方法级别配置信息的同步能力，相当于注册中心的额外扩展。

以上三个中心，由Nacos组件承担，

所以在下面的实操中，无论dubbo-Provider还是dubbo-consumer，配置文件中都是这么配置的：

dubbo:
      scan:
        base-packages: com.crazymaker.cloud.dubbo
      application:
        name:  ${
        spring.application.name}
      protocol:
        name: dubbo
        port: -1
      registry:
        address: nacos://${
        NACOS_SERVER:cdh1:8848}
        username: nacos
        password: nacos
        parameters:
          namespace: dubbo
          group: DUBBO_GROUP
      config-center:
        address: nacos://${
        NACOS_SERVER:cdh1:8848}
        username: nacos
        password: nacos
        group: DUBBO_GROUP
      metadata-report:
        address: nacos://${
        NACOS_SERVER:cdh1:8848}
        username: nacos
        password: nacos
        group: DUBBO_GROUP

### SpringBoot整合Dubbo3.0基础准备 ###

阿里早已把dubbo捐赠给了Apache，现在dubbo由Apache在维护更新，dubbo也已经成了Apache下的顶级项目。

### SpringCloud+Nacos+Dubbo3.0 ###

#### 版本说明 ####

*  SpringCloud:**Hoxton.SR8**
 *  SpringCloudAlibaba:**2.2.3.RELEASE**
 *  SpringBoot:**2.3.4.RELEASE**
 *  Nacos:**2.0.3**
 *  Dubbo:**3.0.7**

#### 项目结构介绍 ####

##### 1、dubbo的依赖的坐标 #####

Maven 依赖的坐标是Apache官方最新的`3.0.4`坐标。

<dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-bom</artifactId>
        <version>${dubbo.version}</version>
        <type>pom</type>
        <scope>import</scope>
    </dependency>

![6f750dfc46cd4b33ae1f9c0d7531a259.png][]

如果使用的老版本的Dubbo，比如下面的这些依赖， 现在需要去掉啦

<dependency>
        <groupId>com.alibaba.spring.boot</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
        <version>2.0.0</version>
    </dependency>
    
    <dependency>
        <groupId>io.dubbo.springboot</groupId>
        <artifactId>spring-boot-starter-dubbo</artifactId>
        <version>1.0.0</version>
    </dependency>

##### 2、 注册中心的依赖的坐标 #####

老的项目采用zookeeper为注册中心，当然，咱们的电脑里的虚拟机，其实都已经安装好zookeeper服务器，并已经启动。

所以，如果要使用ZK，对于咱们技术自由圈（疯狂创客圈的新名字）的小伙伴来说，也是非常方便的。

但是SpringCloud项目上一般使用的注册中，不是appolo，不是eureka，而是nacos。

现在Dubbo也支持nacos， 所以我们使用Nacos作为注册中心

<dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-registry-nacos</artifactId>
        <version>${dubbo.version}</version>
        <exclusions>
            <exclusion>
                <groupId>com.alibaba.nacos</groupId>
                <artifactId>nacos-client</artifactId>
            </exclusion>
        </exclusions>
    
        <type>pom</type>
    </dependency>

这里有个版本兼容性的bug，尼恩稍微花了一点点时间，才解决这个问题。

具体的话，视频中给大家详细说一下。

#### SpringBoot整合Dubbo3.0大致步骤 ####

*  SpringBoot 项目创建
 *  Dubbo 服务提供方实现
 *  Dubbo 服务消费方实现
 *  自定义Filter拦截所有消费请求
 *  自定义LoadBalance完成特殊场景负载均衡

#### 模块结构 ####

接下来演示下整合的模块结构，注意，是Springcloud 项目的老项目升级，

不是一个全新的项目，很多老的代码，要复用的

所以，就是在原来的crazy-SpringCloud 微服务项目上改造

但是这里仅仅演示 dubbo，所以，在原理的 脚手架里边，增加了两个子模块，

**注意： 模块里边，并没有去掉原来的SpringCloud OpenFeign 的RPC调用, 而是两种RPC 调用共存。**

方便后续在业务中快速运用，完整结构如下：

1.  consumer，服务消费方模块；
2.  provider，服务提供方模块；
3.  统一定义服务接口和实体类，被其他工程模块引用；

consumer，服务消费方模块\\ provider，服务提供方模块；如下图

![d5d9a13a01f6427e9a1698ba80e08dc0.png][]

统一定义服务接口和实体类，被其他工程模块引用； 所以，这个之前fegin 的RPC 接口，现在接着给Dubbo用。

![6a6c64aa310a4c6c8381b23cfa18a6d0.png][]

#### Dubbo微服务注册发现的相关配置 ####

*  命名空间隔离
 *  微服务注册中心配置

#### 命名空间隔离 ####

在nacos 的命名空间， 用来做 dubbo 的命名空间隔离

首先创建nacos的命名空间

![e51ccb5dc14e4db9970f06dd7cb8d1a6.png][]

命名id 是要用到的， 这里需要填写，

主要，不要自动生产

![04b614e759fe4fcf9a86614ed4b87f43.png][]

### 微服务yml配置 ###

微服务 yml 配置， yml配置 dubbo nacos 命名空间

dubbo:
      scan:
    	base-packages: xxx
      protocol:
        name: dubbo
        port: -1
      # 注册中心配置
      registry:
        address: nacos://xxx
     	parameters:
       		namespace: dubbo
        group: DUBBO_GROUP
    
    dubbo:
      application:
        name:  ${
        spring.application.name}
      protocol:
        name: dubbo
        port: -1
      registry:
        address: nacos://${
        NACOS_SERVER:cdh1:8848}
        username: nacos
        password: nacos
        parameters:
          namespace: dubbo
          group: DUBBO_GROUP
      config-center:
        address: nacos://${
        NACOS_SERVER:cdh1:8848}
        username: nacos
        password: nacos
        group: DUBBO_GROUP
      metadata-report:
        address: nacos://${
        NACOS_SERVER:cdh1:8848}
        username: nacos
        password: nacos
        group: DUBBO_GROUP

### common-service 模块 ###

服务接口 进行**利旧** **复用**

还是之前的 UserClient 老接口，open fegn注解都不去掉

package com.crazymaker.springcloud.user.info.remote.client;
    
    import com.crazymaker.springcloud.common.dto.UserDTO;
    import com.crazymaker.springcloud.common.result.RestOut;
    import com.crazymaker.springcloud.standard.config.FeignConfiguration;
    import com.crazymaker.springcloud.user.info.remote.fallback.UserClientFallbackFactory;
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RequestParam;
    
    /**
     * Feign 客户端接口
     * @description: 用户信息 远程调用接口
     * @date 2019年7月22日
     */
    
    @FeignClient(value = "uaa-provider",
            configuration = FeignConfiguration.class,
    //        fallback = UserClientFallback.class,
            fallbackFactory = UserClientFallbackFactory.class,
            path = "/uaa-provider/api/user")
    public interface UserClient
    {
        
          /**
         * 远程调用 RPC 方法：获取用户详细信息
         * @param userId 用户 Id
         * @return 用户详细信息
         */
        @RequestMapping(value = "/detail/v1", method = RequestMethod.GET)
        RestOut<UserDTO> detail(@RequestParam(value = "userId") Long userId);
    
        @RequestMapping(value = "/hello/v1", method = RequestMethod.GET)
        public String hello(@RequestParam(value = "name") String name);
    }

### 服务提供者实操：dubbo-provider 服务 ###

#### pom依赖 ####

<dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-registry-nacos</artifactId>
        <exclusions>
            <exclusion>
                <artifactId>nacos-client</artifactId>
                <groupId>com.alibaba.nacos</groupId>
            </exclusion>
        </exclusions>
    </dependency>
    
    
    
    <dependency>
        <groupId>com.alibaba.nacos</groupId>
        <artifactId>nacos-client</artifactId>
        <version>${nacos-client-verson}</version>
    </dependency>

#### 服务实现类 ####

package com.crazymaker.cloud.dubbo.demo.sevice;
    
    import com.crazymaker.springcloud.common.dto.UserDTO;
    import com.crazymaker.springcloud.common.result.RestOut;
    import com.crazymaker.springcloud.user.info.remote.client.UserClient;
    import org.apache.dubbo.config.annotation.DubboService;
    import org.springframework.stereotype.Component;
    
    @DubboService
    @Component
    
    public class UserClientDubboService implements UserClient {
        
        @Override
        public RestOut<UserDTO> detail(Long userId) {
        
            UserDTO dto=new UserDTO();
            dto.setUserId(userId);
            dto.setNickname(" dubbo rpc test");
            return RestOut.success(dto).setRespMsg("操作成功");
        }
    
        @Override
        public String hello(String name) {
        
            return "from dubbo provider : 你好，"+name;
        }
    }

#### dubbo和Feign的一个不同 ####

*  dubbo的服务发布和暴露，直接在 service 层加上注解 ，就完成了

比如：上面的案例中，加上一个类级别的 注解，就可以 暴露这个服务接口 @DubboService

*  而 Feign 的服务接口发布，是在 @Controller 层完成的。

相对来说，比 使用 Dubbo 更为笨重

#### Provider的Dubbo+Nacos配置文件 ####

spring:
      security:
        enabled: false
      application:
        name: dubbo-provider-demo
    
    
    server:
      port: 28088
      servlet:
        context-path: /dubbo-provider-demo
    
    #### 暴露端点
    management:
      endpoints:
        web:
          base-path: "/actuator"  # 配置 Endpoint 的基础路径
          exposure:
            include: '*'  #在yaml 文件属于关键字，所以需要加引号
      endpoint:
        logfile:
          # spring boot admin  client不配置日志文件路径（同时配置logback-spring.xml对应的日志输出配置，否则无法输出日志），
          # 控制台上的Logging模块下的Logfile会报错：Fetching logfile failed.Request failed with status code 404
          external-file: ${
        log_dubbo_provider_demo_path_full:C:/logs/dubbo-provider-demo/logs/output.log}
          enabled: true
        health:
          show-details: always
        # 未配置/注释 以下内容
    #  boot:
    #    admin:
    #      context-path: consumer
      metrics:
        tags:
          application:  ${
        spring.application.name}
        export:
          prometheus:
            enabled: true
            step: 1m
            descriptions: true
    
    dubbo:
      scan:
        base-packages: com.crazymaker.cloud.dubbo
      application:
        name:  ${
        spring.application.name}
      protocol:
        name: dubbo
        port: -1
      registry:
        address: nacos://${
        NACOS_SERVER:cdh1:8848}
        username: nacos
        password: nacos
        parameters:
          namespace: dubbo
          group: DUBBO_GROUP
      config-center:
        address: nacos://${
        NACOS_SERVER:cdh1:8848}
        username: nacos
        password: nacos
        group: DUBBO_GROUP
      metadata-report:
        address: nacos://${
        NACOS_SERVER:cdh1:8848}
        username: nacos
        password: nacos
        group: DUBBO_GROUP

#### 启动类 加上@EnableDubbo 注解 ####

package com.crazymaker.cloud.dubbo.demo.starter;
    
    import com.crazymaker.springcloud.common.util.IpUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.context.ConfigurableApplicationContext;
    import org.springframework.core.env.Environment;
    import springfox.documentation.swagger2.annotations.EnableSwagger2;
    
    import java.net.Inet4Address;
    import java.util.Optional;
    
    @EnableSwagger2
    @EnableDiscoveryClient
    @Slf4j
    @EnableDubbo
    
    @SpringBootApplication(scanBasePackages =
            {
        
                    "com.crazymaker.cloud.dubbo.demo",
            }
    )
    
    
    public class DubboProviderApplication {
        
        public static void main(String[] args) {
        
            try {
        
                ConfigurableApplicationContext applicationContext = SpringApplication.run(DubboProviderApplication.class, args);
    
                Environment env = applicationContext.getEnvironment();
                String port = env.getProperty("server.port");
                String name = env.getProperty("spring.application.name");
    
                String path = env.getProperty("server.servlet.context-path");
                if (StringUtils.isBlank(path)) {
        
                    path = "";
                }
                Optional<Inet4Address> ip = IpUtil.getLocalIp4Address();
    
              log.info("\n----------------------------------------------------------\n\t" +
                        name.toUpperCase() + " is running! Access URLs:\n\t" +
                        "Local: \t\thttp://" + ip.get() + ":" + port + path + "/\n\t" +
                        "swagger-ui: \thttp://" + ip.get() + ":" + port + path + "/swagger-ui.html\n\t" +
                        "actuator: \thttp://" + ip.get() + ":" + port + path + "/actuator/info\n\t" +
                        "----------------------------------------------------------");
    
            } catch (Exception e) {
        
                log.error("服务启动报错", e);
    
            }
        }
    }

#### 启动、体验Provider ####

打包之后，在 咱们优雅的虚拟机centos8中，优雅的启动一下,

来一个优雅的启动命令

[root@centos1 work]# cd dubbo-provider-demo-1.0-SNAPSHOT/bin/
    [root@centos1 bin]# sh ./deploy.sh start
    PORT:28088
    JVM:-server -Xms512m -Xmx2048m
    nohup java -server -Xms512m -Xmx2048m -Dserver.port=28088   -jar /work/dubbo-provider-demo-1.0-SNAPSHOT/lib/dubbo-provider-demo-1.0-SNAPSHOT.jar com.crazymaker.cloud.dubbo.demo.starter.DubboProviderApplication  &
     log file : /work/logs/dubbo-provider-demo-1.0-SNAPSHOT/output.log

太爽… 有个vagrant+Centos 开发环境， 开发Java应用，爽到不要不要的

关键是： 在这个虚拟机 box 文件中，尼恩给大家预装了K8S 云原生环境，大家一键导入省了N多麻烦。基于这个环境， 下一步咱们就开始 “左手大数据、右手云原生” 的高端实操

继续看，屏幕的下面，下面还有swagger体验地址

![7bb30e7b085b431a88d7eaa00d951355.png][]

使用这个地址，可以在浏览器开起Swagger -UI 的界面

http:///cdh1:28088/dubbo-provider-demo/swagger-ui.html

开启之后的效果，但是，这个和dubbo没有关系

因为dubbo的服务并没有在swagger ui 展示

![a4dfd17ec1ec4e81ab96e2f856ecc220.png][]

#### 在Nacos查看Dubbo服务的注册情况 ####

通过nacos，可以看到 dubbo的服务啦

![c607a4a4ef18418fa06afe34aaa2aafc.png][]

具体的细节，咱们后面讲dubbo视频的时候，再说

这里先把性能优化起来

### 服务消费者实操：dubbo-consumer 服务 ###

### consumer模块 ###

![22c93145bbb14ac494efc982cc76419a.png][]

#### 消费者实现类 ####

package com.crazymaker.cloud.dubbo.demo.consumer.controller;
    
    import com.crazymaker.springcloud.common.dto.UserDTO;
    import com.crazymaker.springcloud.common.result.RestOut;
    import com.crazymaker.springcloud.user.info.remote.client.UserClient;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    import org.apache.dubbo.config.annotation.DubboReference;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("/user")
    @Api(tags = "Dubbo-RPC  完成远程调用")
    public class UserConsumerController {
        
    
    
        //注入  @DubboReference 注解配置 所配置的 EchoClient 客户端Feign实例
         @DubboReference(loadbalance = "groupLoadBalance")
        private UserClient userService;
    
        //用户详情
        @ApiOperation(value = "用户详情接口")
        @RequestMapping(value = "/detail/v1", method = RequestMethod.GET)
        RestOut<UserDTO> detail(@RequestParam(value = "userId", required = true)Long userId) {
        
            RestOut<UserDTO> ret = userService.detail(userId);
            return ret;
        }
    }

#### 消费者Dubbo+Nacos配置文件 ####

spring:
      security:
        enabled: false
      application:
        name: dubbo-consumer-demo
    #http://cdh1:18081/dubbo-consumer-demo/swagger-ui.html
    
    server:
      port: 18081
      servlet:
        context-path: /dubbo-consumer-demo
    
    #### 暴露端点
    management:
      endpoints:
        web:
          base-path: "/actuator"  # 配置 Endpoint 的基础路径
          exposure:
            include: '*'  #在yaml 文件属于关键字，所以需要加引号
      endpoint:
        health:
          show-details: always
      metrics:
        tags:
          application: ${
        spring.application.name}
    #  boot:
    #    admin:
    #      context-path: consumer
    
    dubbo:
      scan:
        base-packages: com.crazymaker.cloud.dubbo
      application:
        name:  ${
        spring.application.name}
      protocol:
        name: dubbo
        port: -1
      registry:
        address: nacos://${
        NACOS_SERVER:cdh1:8848}
        username: nacos
        password: nacos
        parameters:
          namespace: dubbo
          group: DUBBO_GROUP
      config-center:
        address: nacos://${
        NACOS_SERVER:cdh1:8848}
        username: nacos
        password: nacos
        group: DUBBO_GROUP
      metadata-report:
        address: nacos://${
        NACOS_SERVER:cdh1:8848}
        username: nacos
        password: nacos
        group: DUBBO_GROUP

#### 启动类 加上@EnableDubbo 注解 ####

package com.crazymaker.cloud.dubbo.demo.consumer.starter;
    
    import com.crazymaker.springcloud.common.util.IpUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.actuate.autoconfigure.security.servlet.ManagementWebSecurityAutoConfiguration;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
    import org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration;
    import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
    import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.openfeign.EnableFeignClients;
    import org.springframework.context.ConfigurableApplicationContext;
    import org.springframework.core.env.Environment;
    import springfox.documentation.swagger2.annotations.EnableSwagger2;
    
    import java.net.Inet4Address;
    import java.util.Optional;
    
    @EnableSwagger2
    @EnableDiscoveryClient
    @Slf4j
    @EnableDubbo
    
    @SpringBootApplication(
            scanBasePackages =
                    {
        
                            "com.crazymaker.cloud.dubbo.demo",
                            "com.crazymaker.springcloud.standard"
                    },
            exclude = {
        SecurityAutoConfiguration.class,
                    //排除db的自动配置
                    DataSourceAutoConfiguration.class,
                    DataSourceTransactionManagerAutoConfiguration.class,
                    HibernateJpaAutoConfiguration.class,
                    SecurityAutoConfiguration.class,
                    ManagementWebSecurityAutoConfiguration.class,
                    //排除redis的自动配置
                    RedisAutoConfiguration.class,
                    RedisRepositoriesAutoConfiguration.class})
    //启动Feign
    @EnableFeignClients(basePackages =
            {
        "com.crazymaker.cloud.dubbo.demo.consumer.client"})
    public class DubboConsumerApplication {
        
    
        public static void main(String[] args) {
        
            try {
        
                ConfigurableApplicationContext applicationContext = SpringApplication.run(DubboConsumerApplication.class, args);
    
                Environment env = applicationContext.getEnvironment();
                String port = env.getProperty("server.port");
                String name = env.getProperty("spring.application.name");
    
                String path = env.getProperty("server.servlet.context-path");
                if (StringUtils.isBlank(path)) {
        
                    path = "";
                }
                Optional<Inet4Address> ip = IpUtil.getLocalIp4Address();
    
                log.info("\n----------------------------------------------------------\n\t" +
                        name.toUpperCase() + " is running! Access URLs:\n\t" +
                        "Local: \t\thttp://" + ip.get() + ":" + port + path + "/\n\t" +
                        "swagger-ui: \thttp://" + ip.get() + ":" + port + path + "/swagger-ui.html\n\t" +
                        "actuator: \thttp://" + ip.get() + ":" + port + path + "/actuator/info\n\t" +
                        "----------------------------------------------------------");
    
            } catch (Exception e) {
        
                log.error("服务启动报错", e);
    
            }
        }
    }

#### 启动、体验 Consumer ####

打包之后，在 咱们优雅的虚拟机 centos8 中，优雅的启动一下,

来一个优雅的启动命令

[root@centos1 bin]# cd ../../dubbo-consumer-demo-1.0-SNAPSHOT/bin/
    [root@centos1 bin]# sh ./deploy.sh start
    PORT:18081
    JVM:-server -Xms512m -Xmx2048m
    nohup java -server -Xms512m -Xmx2048m -Dserver.port=18081   -jar /work/dubbo-consumer-demo-1.0-SNAPSHOT/lib/dubbo-consumer-demo-1.0-SNAPSHOT.jar com.crazymaker.cloud.dubbo.demo.consumer.starter.DubboConsumerApplication  &
    nohup: appending output to 'nohup.out'

太爽… 有个vagrant+Centos 开发环境， 开发Java应用，爽到不要不要的

关键是： 在这个虚拟机 box 文件中，尼恩给大家预装了K8S 云原生环境，大家一键导入省了N多麻烦。

下一步，基于这个环境， 咱们就开始 “左手大数据、右手云原生” 的高端实操

继续看，屏幕的下面，下面还有swagger体验地址

![6a43523357ef4c6692439486ed82a70f.png][]

使用这个地址，可以在浏览器开起Swagger -UI 的界面

http:///10.0.2.15:18081/dubbo-consumer-demo/swagger-ui.html

注意，要修改一下 host，修改之后为

http://cdh1:18081/dubbo-consumer-demo/swagger-ui.html

Feign 和Dubbo 两大RPC调用 并存的效果，如下：

![a5106cbd63d54840968d291e6a5b440f.png][]

#### 在Nacos查看Dubbo服务的注册情况 ####

通过nacos，可以看到 dubbo的服务的消费者啦

![eb92b937d0a247c29d3edeb65f6369e3.png][]

具体的细节，咱们后面讲dubbo视频的时候，再说

这里先把性能优化起来

### 性能的对比测试 ###

然后进行了性能的对比验证

**dubbo 的压测数据**

wrk -t8 -c200 -d30s --latency  http://cdh1:18081/dubbo-consumer-demo/user/detail/v1?userId=1
    
    [root@centos1 src]# wrk -t8 -c200 -d30s --latency  http://cdh1:18081/dubbo-consumer-demo/user/detail/v1?userId=1
    Running 30s test @ http://cdh1:18081/dubbo-consumer-demo/user/detail/v1?userId=1
      8 threads and 200 connections
      Thread Stats   Avg      Stdev     Max   +/- Stdev
        Latency    30.10ms   45.68ms 644.45ms   95.43%
        Req/Sec     1.12k   465.63     2.36k    66.87%
      Latency Distribution
         50%   18.94ms
         75%   28.43ms
         90%   46.21ms
         99%  283.56ms
      264316 requests in 30.07s, 148.47MB read
    Requests/sec:   8788.96
    Transfer/sec:      4.94MB

![5fca843de8c445e2827f8bbce5b2fa19.png][]

**feign 的压测数据**

![026d705c815e46d295c5d300cb60befc.png][]

wrk -t8 -c200 -d30s --latency  http://cdh1:18081/dubbo-consumer-demo/echo/variable/11
    
    [root@centos1 src]# wrk -t8 -c200 -d30s --latency  http://cdh1:18081/dubbo-consumer-demo/echo/variable/11
    Running 30s test @ http://cdh1:18081/dubbo-consumer-demo/echo/variable/11
      8 threads and 200 connections
      Thread Stats   Avg      Stdev     Max   +/- Stdev
        Latency   321.50ms  294.59ms   2.00s    61.77%
        Req/Sec    87.18     43.39   232.00     67.00%
      Latency Distribution
         50%  309.06ms
         75%  503.06ms
         90%  687.99ms
         99%    1.21s
      20495 requests in 30.10s, 7.64MB read
      Socket errors: connect 0, read 0, write 0, timeout 49
    Requests/sec:    680.90
    Transfer/sec:    259.99KB

**从数据来看， dubbo rpc 是feign rpc 性能10倍**

#### Dubbo比Feign高10倍以上的本质 ####

Dubbo比Feign高10倍以上的本质，不是在于应用层的协议，和传输格式

面试的时候，太多的小伙伴被问到： Dubbo比Feign性能高，说说原因。

小伙伴首先回答的是：

*Dubbo 是TCP 层的传输协议，Feign是应用层 的HTTP传输协议，所以性能低。*

这个答案不是本质原因，HTTP是有些冗余的头部报文，但是不至于差10倍。能差0.5倍，就已经顶天了。

差10倍的原因：是 同步链路 与异步链路 的 区别。

或者说：*Dubbo比Feign高10倍以上的本质，是RPC 调用异步化*

RPC 调用主要的框架有：

![d9be5355304940789bb82bef6e60bca1.png][]

特点是：

*  feign 是同步IO 、阻塞模式的同步 RPC框架
 *  dubbo 是基于Netty的非阻塞IO + Reactor 反应堆线程模型的 异步RPC框架

异步RPC 调用，等待upstream 上游 response 返回时，线程不处于block 状态

作为微服务架构中数据流量最大的一部分，RPC 调用异步化的收益巨大；

dubbo 的异步RPC，仅仅 SpringCloud 微服务全链路 异步的一个环节， SpringCloud 全链路 异步有5个以上的环节。

有关 微服务全链路 异步高性能改造，请参考尼恩的深度文章：

[全链路异步，让你的 SpringCloud 性能优化10倍+][SpringCloud _10]

高并发、云原生、大数据时代，很多组件都是 全异步的、响应式的。

大家一定要掌握全链路异步的底层原理，掌握好 响应式编程的底层原理和实操，为 “左手大数据、右手云原生” 做好技术准备。

后面尼恩也会写一些列的博文，为大家“左手大数据、右手云原生” 做好技术储备。

具体请关注尼恩的疯狂创客圈社群（50+）。

#### Dubbo 与 SpringCloud 的通信 Openfeign的区别 ####

##### 1、协议支持方面 #####

*  Feign更加优雅简单。  
    Feign是通过REST API实现的远程调用，基于Http传输协议，服务提供者需要对外暴露Http接口供消费者调用，服务粒度是http接口级的。  
    很多文章说：通过短连接的方式进行通信，不适合高并发的访问。  
    *尼恩纠错： Feign 并不是短链接，而是长连接 ，具体请 阅读 尼恩 的《Java 高并发核心编程 卷1 加强版》*
 *  Dubbo方式更灵活。  
    Dubbo是通过RPC调用实现的远程调用，支持多传输协议(Dubbo、Rmi、http、redis等等)，可以根据业务场景选择最佳的方式，非常灵活。  
    默认的Dubbo协议：利用Netty，TCP传输，单一、异步、长连接，适合数据量小、高并发和服务提供者远远少于消费者的场景。Dubbo通过TCP长连接的方式进行通信，服务粒度是方法级的。

##### 2、通信性能方面 #####

*  Feign基于Http传输协议，底层实现是rest。在高并发场景下性能不够理想。
 *  Dubbo框架的通信协议采用RPC协议，属于传输层协议，提升了交互的性能，保持了长连接，高性能。

##### 3、线程模型方面 #####

*  Feign使用的是阻塞式的线程模型， 在请求和响应直之间， IO线程是阻塞的，死等到超时。
 *  Dubbo使用的是异步非阻塞式的线程模型（Netty的Reactor反应器）， 在请求和响应直之间， IO线程是非阻塞的，有限的线程，可以处理大量的请求。

这点是性能的核心。

### SpringCloud + Dubbo RPC 的集成的价值 ###

高并发时代来了， 各大项目有越来越强烈的诉求，全链路异步， 是性能优化的一个杀手锏。

使用Dubbo来替换Feign，足足可以提升10倍性能。

所以，SpringCloud + Dubbo RPC 的集成 是一个比较刚性的需求。

有小伙伴查招聘网站，发现很多需要有SpringCloud + Dubbo 的集成经验，刚好印证了这点。

尼恩强烈建议大家，做一下 SpringCloud + Dubbo RPC 的集成，在同一个微服务下，同时使用了Feign + Dubbo。

*尼恩提示：很多小伙伴来找尼恩改简历，但是发现一点漂亮的技术亮点都没有，如果确实找不到亮点，可以把这个实操做一下，写入简历，作为亮点。如果确实不清楚怎么写入简历，可以来找尼恩进行简历指导。保证 脱胎换骨、金光闪闪、天衣无缝。*

![d95015de8c3943b28a70fe5f2f5c4cc8.png][]

### 参考文献 ###

[全链路异步，让你的 SpringCloud 性能优化10倍+][SpringCloud _10]

https://blog.csdn.net/wpc2018/article/details/122634049

https://www.jianshu.com/p/7d80b94068b3

https://blog.csdn.net/yhj\_911/article/details/119540000

http://bjqianye.cn/detail/6845.html

https://blog.csdn.net/hao134838/article/details/110824092

https://blog.csdn.net/weixin\_34096182/article/details/91436704

https://blog.csdn.net/fly910905/article/details/121682625

https://gaocher.github.io/2020/01/05/mono-create/

### 推荐阅读： ###

《[响应式圣经：10W字，实现Spring响应式编程自由][10W_Spring]》

《[4次迭代，让我的 Client 优化 100倍！泄漏一个 人人可用的极品方案！][4_ Client _ 100_]》

《[100亿级订单怎么调度，来一个大厂的极品方案][100]》

《[Linux命令大全：2W多字，一次实现Linux自由][Linux_2W_Linux]》

《[阿里一面：你做过哪些代码优化？来一个人人可以用的极品案例][Link 2]》

《[网易二面：CPU狂飙900%，该怎么处理？][CPU_900]》

《[阿里二面：千万级、亿级数据，如何性能优化？ 教科书级 答案来了][Link 3]》

《[峰值21WQps、亿级DAU，小游戏《羊了个羊》是怎么架构的？][21WQps_DAU]》

《[场景题：假设10W人突访，你的系统如何做到不 雪崩？][10W_]》

《[2个大厂 100亿级 超大流量 红包 架构方案][2_ 100_ _ _]》

《[Nginx面试题（史上最全 + 持续更新）][Nginx_ _]》

《[K8S面试题（史上最全 + 持续更新）][K8S_ _]》

《[操作系统面试题（史上最全、持续更新）][Link 4]》

《[Docker面试题（史上最全 + 持续更新）][Docker_ _]》

《[Springcloud gateway 底层原理、核心实战 (史上最全)][Springcloud gateway _]》

《[Flux、Mono、Reactor 实战（史上最全）][Flux_Mono_Reactor]》

《[sentinel （史上最全）][sentinel]》

《[Nacos (史上最全)][Nacos]》

《[TCP协议详解 (史上最全)][TCP_]》

《[分库分表 Sharding-JDBC 底层原理、核心实战（史上最全）][Sharding-JDBC]》

《[clickhouse 超底层原理 + 高可用实操 （史上最全）][clickhouse _ _ _]》

《[nacos高可用（图解+秒懂+史上最全）][nacos]》

《[队列之王： Disruptor 原理、架构、源码 一文穿透][Disruptor _]》

《[环形队列、 条带环形队列 Striped-RingBuffer （史上最全）][_ Striped-RingBuffer]》

《[一文搞定：SpringBoot、SLF4j、Log4j、Logback、Netty之间混乱关系（史上最全）][SpringBoot_SLF4j_Log4j_Logback_Netty]》

《[单例模式（史上最全）][Link 5]》

《[红黑树（ 图解 + 秒懂 + 史上最全）][_ _ _ _]》

《[分布式事务 （秒懂）][Link 6]》

《[缓存之王：Caffeine 源码、架构、原理（史上最全，10W字 超级长文）][Caffeine _10W_]》

《[缓存之王：Caffeine 的使用（史上最全）][Caffeine]》

《[Java Agent 探针、字节码增强 ByteBuddy（史上最全）][Java Agent _ ByteBuddy]》

《[Docker原理（图解+秒懂+史上最全）][Docker]》

《[Redis分布式锁（图解 - 秒懂 - 史上最全）][Redis_ - _ -]》

《[Zookeeper 分布式锁 - 图解 - 秒懂][Zookeeper _ - _ -]》

《[Zookeeper Curator 事件监听 - 10分钟看懂][Zookeeper Curator _ - 10]》

《[Netty 粘包 拆包 | 史上最全解读][Netty _ _ _]》

《[Netty 100万级高并发服务器配置][Netty 100]》

《[Springcloud 高并发 配置 （一文全懂）][Springcloud _ _]》

[2b45f03e8f594b17969f86e170d667d4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/9b2b9a95250b4c68bbc39628cefc20a2.png
[SpringCloud _10]: https://blog.csdn.net/crazymakercircle/article/details/129004814
[Java]: https://blog.csdn.net/crazymakercircle/article/details/124790425
[Link 1]: https://gitee.com/crazymaker/SimpleCrayIM/blob/master/%E7%96%AF%E7%8B%82%E5%88%9B%E5%AE%A2%E5%9C%88%E6%80%BB%E7%9B%AE%E5%BD%95.md
[bb08927427bb40f5af9c5e318da7a9e7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/b5e66dcd3d244ebda7595e4499a8092a.png
[6f750dfc46cd4b33ae1f9c0d7531a259.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/51b0015a39a14ac185dc06df780ea24a.png
[d5d9a13a01f6427e9a1698ba80e08dc0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c9abb298261648f98fedfd9b4a6d9c64.png
[6a6c64aa310a4c6c8381b23cfa18a6d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/0343f99fa234497c8f61bbbca1c6dcde.png
[e51ccb5dc14e4db9970f06dd7cb8d1a6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/1cc50b7f0235423ab404d9d8a6554a95.png
[04b614e759fe4fcf9a86614ed4b87f43.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/1deb834b34bd4aca9c77ef5544440d16.png
[7bb30e7b085b431a88d7eaa00d951355.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/872bc9a09f7a4d32b8af71f01a5fdadd.png
[a4dfd17ec1ec4e81ab96e2f856ecc220.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/de1baa6cef0e4e08afdc99b1f1148ec6.png
[c607a4a4ef18418fa06afe34aaa2aafc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/023a18b16cde413f81d1953617922e3b.png
[22c93145bbb14ac494efc982cc76419a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/6174855a93e844779bfd271038cbc455.png
[6a43523357ef4c6692439486ed82a70f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/94b2ac9fbaf04a21978142b63444ff95.png
[a5106cbd63d54840968d291e6a5b440f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/b7e10c68aeb94798baf2d10fb84897ac.png
[eb92b937d0a247c29d3edeb65f6369e3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/a4da168cdf7e4d8ba1c81977ea4ab7ba.png
[5fca843de8c445e2827f8bbce5b2fa19.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/25e3f579ab2e4dddacce60e72421a29e.png
[026d705c815e46d295c5d300cb60befc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/b5a30210caa44557943e38e8ab8bdea5.png
[d9be5355304940789bb82bef6e60bca1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2370307cc5384fa4884ccddc0f1fef55.png
[d95015de8c3943b28a70fe5f2f5c4cc8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/7c67d3594f1e401ea1e13e0a46144222.png
[10W_Spring]: https://blog.csdn.net/crazymakercircle/article/details/129022714
[4_ Client _ 100_]: https://blog.csdn.net/crazymakercircle/article/details/129117619
[100]: https://blog.csdn.net/crazymakercircle/article/details/129145200
[Linux_2W_Linux]: https://blog.csdn.net/crazymakercircle/article/details/128932396
[Link 2]: https://blog.csdn.net/crazymakercircle/article/details/129056726
[CPU_900]: https://blog.csdn.net/crazymakercircle/article/details/128805374
[Link 3]: https://blog.csdn.net/crazymakercircle/article/details/128848309
[21WQps_DAU]: https://blog.csdn.net/crazymakercircle/article/details/128725701
[10W_]: https://blog.csdn.net/crazymakercircle/article/details/128533821
[2_ 100_ _ _]: https://blog.csdn.net/crazymakercircle/article/details/128697096
[Nginx_ _]: https://blog.csdn.net/crazymakercircle/article/details/128684641
[K8S_ _]: https://blog.csdn.net/crazymakercircle/article/details/128671196
[Link 4]: https://blog.csdn.net/crazymakercircle/article/details/128708648
[Docker_ _]: https://blog.csdn.net/crazymakercircle/article/details/128670335
[Springcloud gateway _]: https://blog.csdn.net/crazymakercircle/article/details/125057567
[Flux_Mono_Reactor]: https://blog.csdn.net/crazymakercircle/article/details/124120506
[sentinel]: https://blog.csdn.net/crazymakercircle/article/details/125059491
[Nacos]: https://blog.csdn.net/crazymakercircle/article/details/125057545
[TCP_]: https://blog.csdn.net/crazymakercircle/article/details/114527369
[Sharding-JDBC]: https://blog.csdn.net/crazymakercircle/article/details/123420859
[clickhouse _ _ _]: https://blog.csdn.net/crazymakercircle/article/details/126992542
[nacos]: https://blog.csdn.net/crazymakercircle/article/details/120702536
[Disruptor _]: https://blog.csdn.net/crazymakercircle/article/details/128264803
[_ Striped-RingBuffer]: https://blog.csdn.net/crazymakercircle/article/details/128264508
[SpringBoot_SLF4j_Log4j_Logback_Netty]: https://blog.csdn.net/crazymakercircle/article/details/125135726
[Link 5]: https://blog.csdn.net/crazymakercircle/article/details/128265067
[_ _ _ _]: https://blog.csdn.net/crazymakercircle/article/details/125017316
[Link 6]: https://blog.csdn.net/crazymakercircle/article/details/109459593
[Caffeine _10W_]: https://blog.csdn.net/crazymakercircle/article/details/128123114
[Caffeine]: https://blog.csdn.net/crazymakercircle/article/details/113751575
[Java Agent _ ByteBuddy]: https://blog.csdn.net/crazymakercircle/article/details/126579528
[Docker]: https://blog.csdn.net/crazymakercircle/article/details/120747767
[Redis_ - _ -]: https://blog.csdn.net/crazymakercircle/article/details/116425814
[Zookeeper _ - _ -]: https://blog.csdn.net/crazymakercircle/article/details/85956246
[Zookeeper Curator _ - 10]: https://blog.csdn.net/crazymakercircle/article/details/85922561
[Netty _ _ _]: https://blog.csdn.net/crazymakercircle/article/details/83957259
[Netty 100]: https://blog.csdn.net/crazymakercircle/article/details/83758107
[Springcloud _ _]: https://blog.csdn.net/crazymakercircle/article/details/102557988