Dubbo的基本使用

郑懿148
65 阅读4分钟

Dubbo的基本使用

软件架构的演变

单体架构

image.png

优点

简单:开发部署都很方便，小型项目首选

缺点

  • 项目启动慢
  • 可靠性差

单体架构存在的问题:

  • 项目启动慢
  • 可靠性差
  • 可伸缩性差
  • 扩展性和可维护性差
  • 性能低

垂直架构

image.png 垂直架构是指将单体架构中的多个模块拆分为多个独立的项目。形成多个独立的单体架构。

垂直架构存在的问题:

  • 重复功能太多

分布式架构

image.png 是指在垂直架构的基础上,将公共业务模块抽取出来,作为独立的服务供其他调用者消费，以实现服务的共享和重用。底层通过RPC（远程过程调用实现）

RPC: Remote Procedure Call远程过程调用。

有非常多的协议和技术来都实现了RPC的过程。比如:

  • HTTP REST风格
  • Java RMI规范
  • WebService SOAP协议
  • Hession等等。

分布式架构存在的问题:

  • 服务提供方一旦产生变更,所有消费方都需要变更。

SOA

image.png Service- Oriented Architecture,面向服务的架构。是一个组件模型,它将应用程序的不同功能单元(称为服务)进行拆分，并通过这些服务之间定义良好的接口和契约联系起来。

ESB

(Enterparise Servce Bus)：企业服务总线,服务中介。

主要是提供了一个服务于服务之间的交互。ESB包含的功能如:负载均衡，流量控制，加密处理，服务的监控，异常处理，监控告急等等。

dubbo 概述

Dubbo概念

  • Dubbo是阿里巴巴公司开源的一个高性能、轻量级的Java RPC框架。
  • 致力于提供高性能和透明化的RPC远程服务调用方案,以及SOA服务治理方案。
  • 官网: htp://ubbo.apache.orgo

image.png

节点角色说明: .

  • Provider: 暴露服务的服务提供方
  • Contahier: 服务运行容器
  • Consumer: 调用远程服务的服务消费方
  • Registry: 服务注册与发现的注册中心
  • Monitor:统计服务的调用次数和调用时间的监控中心

dubbo快速入门

服务提供方

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>

   <groupId>com.bxg</groupId>
   <artifactId>dubbo-provider</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>war</packaging>

   <properties>
      <maven.compiler.source>8</maven.compiler.source>
      <maven.compiler.target>8</maven.compiler.target>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <spring.version>5.0.5.RELEASE</spring.version>
   </properties>

   <dependencies>
      <!--spring springmvc begin-->
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context</artifactId>
         <version>${spring.version}</version>
      </dependency>
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-beans</artifactId>
         <version>${spring.version}</version>
      </dependency>
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-webmvc</artifactId>
         <version>${spring.version}</version>
      </dependency>
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-jdbc</artifactId>
         <version>${spring.version}</version>
      </dependency>
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-aspects</artifactId>
         <version>${spring.version}</version>
      </dependency>
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-jms</artifactId>
         <version>${spring.version}</version>
      </dependency>
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context-support</artifactId>
         <version>${spring.version}</version>
      </dependency>
      <!--spring springmvc end-->

      <!-- dubbo相关 -->
      <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>dubbo</artifactId>
         <version>2.6.0</version>
      </dependency>
      <dependency>
         <groupId>org.apache.zookeeper</groupId>
         <artifactId>zookeeper</artifactId>
         <version>3.4.6</version>
      </dependency>
      <dependency>
         <groupId>com.github.sgroschupf</groupId>
         <artifactId>zkclient</artifactId>
         <version>0.1</version>
      </dependency>
      <dependency>
         <groupId>javassist</groupId>
         <artifactId>javassist</artifactId>
         <version>3.12.1.GA</version>
      </dependency>
      <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>fastjson</artifactId>
         <version>1.2.47</version>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>2.3.2</version>
            <configuration>
               <source>1.8</source>
               <target>1.8</target>
            </configuration>
         </plugin>
         <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <configuration>
               <!-- 指定端口 -->
               <port>8081</port>
               <!-- 请求路径 -->
               <path>/</path>
            </configuration>
         </plugin>
      </plugins>
   </build>

</project>

web.xml

<!DOCTYPE web-app PUBLIC
      "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
      "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
   <display-name>Archetype Created Web Application</display-name>
   <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:applicationContext*.xml</param-value>
   </context-param>
   <listener>
      <listener-class>org.springframework.web.context.ContextLoaderListener
      </listener-class>
   </listener>
</web-app>

创建服务接口

package com.bxg.service;

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

创建服务实现类

注意：服务实现类上使用的Service注解是Dubbo提供的，用于对外发布服务

package com.bxg.service.impl;

import com.alibaba.dubbo.config.annotation.Service;
import com.bxg.service.HelloService;

@Service
public class HelloServiceImpl implements HelloService {
   public String sayHello(String name) {
      return "hello " + name;
   }
}

在dubbodemo_provider工程中src/main/resources下创建applicationContext-service.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">

   <!-- 当前应用名称，用于注册中心计算应用间依赖关系，注意：消费者和提供者应用名不要一样 -->
   <dubbo:application name="dubbodemo_provider"/>
   <!-- 连接服务注册中心zookeeper ip为zookeeper所在服务器的ip地址-->
   <dubbo:registry address="zookeeper://192.168.67.128:2181"/>
   <!-- 注册 协议和port 端口默认是20880 -->
   <dubbo:protocol name="dubbo" port="20881"></dubbo:protocol>
   <!-- 扫描指定包，加上@Service注解的类会被发布为服务 -->
   <dubbo:annotation package="com.bxg.service.impl"/>
</beans>

启动运行

tomcat7:run

服务消费方开发

pom.xml

pom.xml配置和上面服务提供者相同，只需要将Tomcat插件的端口号改为8082即可

web.xml

<!DOCTYPE web-app PUBLIC
      "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
      "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
   <display-name>Archetype Created Web Application</display-name>
   <servlet>
      <servlet-name>springmvc</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet
      </servlet-class>
      <!-- 指定加载的配置文件 ，通过参数contextConfigLocation加载 -->
      <init-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>classpath:applicationContext-web.xml</param-value>
      </init-param>
      <load-on-startup>1</load-on-startup>
   </servlet>
   <servlet-mapping>
      <servlet-name>springmvc</servlet-name>
      <url-pattern>*.do</url-pattern>
   </servlet-mapping>
</web-app>

将服务提供者工程中的HelloService接口复制到当前工程

编写Controller

package com.bxg.controller;

import com.alibaba.dubbo.config.annotation.Reference;
import com.bxg.service.HelloService;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/demo")
public class HelloController {
   @Reference
   private HelloService helloService;

   @RequestMapping("/hello")
   @ResponseBody
   public String getName(String name) {
      //远程调用
      String result = helloService.sayHello(name);
      System.out.println(result);
      return result;
   }
}

注意：Controller中注入HelloService使用的是Dubbo提供的@Reference注解

在dubbodemo_consumer工程中src/main/resources下创建applicationContext-web.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">
   <!-- 当前应用名称，用于注册中心计算应用间依赖关系，注意：消费者和提供者应用名不要一样 -->
   <dubbo:application name="dubbodemo-consumer"/>
   <!-- 连接服务注册中心zookeeper ip为zookeeper所在服务器的ip地址-->
   <dubbo:registry address="zookeeper://192.168.67.128:2181"/>
   <!-- 包扫描的方式 引用服务 扫描@Reference -->
   <dubbo:annotation package="com.bxg.controller"/>
</beans>

运行测试

tomcat7:run启动

在浏览器输入http://localhost:8082/demo/hello.do?name=Jack，查看浏览器输出结果

dubbo高级特性

dubbo-admin

dubbo-admin

  • dubbo-admin管理平台，是图形化的服务管理页面
  • 从注册中心中获取到所有的提供者 /消费者进行配置管理
  • 路由规则、动态配置、服务降级、访问控制、权重调整、负载均衡等管理功能
  • dubbo- admin是一个前后端分离的项目。前端使用vue，后端使用springboot
  • 安装dubbo-admin其实就是部署该项目

安装详见

juejin.cn/post/722175…

序列化

  • dubbo 内部已经将序列化和反序列化的过程内部封装了
  • 我们只需要在定义pojo类时实现seriali zable接口即可
  • 一般会定义一 个公共的pojo模块,让生产者和消费者都依赖该模块。

image.png

User对象未实现seriali zable接口 错误信息：

image.png

解决办法：

User implements Serializable

地址缓存

注册中心挂了，服务是否可以正常访问？

  • 可以，因为dubbo服务消费者在第一-次调用时，会将服务提供方地址缓存到本地，以后在调用则不会访问注册中心。
  • 当服务提供者地址发生变化时，注册中心会通知服务消费者。

超时

image.png

  • 服务消费者在调用服务提供者的时候发生了阻塞、等待的情形,这个时候,服务消费者会直等待下去。
  • 在某个峰值时刻，大量的请求都在同时请求服务消费者,会造成线程的大量堆积，势必会造成雪崩。
  • dubbo利用超时机制来解决这个问题，设置-个超时时间, 在这个时间段内，无法完成服务访问,则自动断开连接。
  • 使用timeout属性配置超时时间，默认值1000，单位毫秒
//timeout 超时时间 单位毫秒 retries 重试次数
@Service(timeout = 3000,retries=0)

重试

image.png

  • 设置了超时时间，在这个时间段内，无法完成服务访问,则自动断开连接。
  • 如果出现网络抖动,则这一次请求就会失败。
  • Dubbo提供重试机制来避免类似问题的发生。
  • 通过retries属性来设置重试次数。默认为2次
//timeout 超时时间 单位毫秒 retries 重试次数
@Service(timeout = 3000,retries=0)

多版本

image.png

灰度发布

当出现新功能时,会让一部分用户先使用新功能，用户反馈没问题时，再将所有用户迁移到新功能。

dubbo中使用version属性来设置和调用同一个接口的不同版本

生产者配置

@Service(version="v2.0")
public class UserServiceImp12 implements UserService {...}

消费者配置

@Reference(version = "v2.0")//远程注入
private UserService userService;

负载均衡

负载均衡策略(4种) :

  • Random:按权重随机，默认值。按权重设置随机概率。
  • RoundRobin: 按权重轮询。
  • LeastActive: 最少活跃调用数,相同活跃数的随机。
  • ConsistentHash:一 致性Hash,相同参数的请求总是发到同一提供者。

image.png

服务提供者配置

@Service(weight = 100)
public class UserServiceImp12 implements UserService {...}

application.xml 配置parameter key

image.png

消费者配置

//@Reference(loadbalance = "roundrobin")
//@Reference(loadbalance = "leastactive")
//@Reference(loadbalance = "consistenthash")
@Reference(loadbalance = "random")//默认 按权重随机
private UserService userService;

集群容错

image.png

集群容错模式:

  • Failover Cluster:失败重试。默认值。当出现失败，重试其它服务器，默认重试2次，使用retries配置。一般用于读操作
  • Failfast Cluster :快速失败,发起-次调用，失败立即报错。通常用于写操作。
  • Failsafe Cluster:失败安全，出现异常时，直接忽略。返回一个空结果。
  • Failback Cluster:失败自动恢复,后台记录失败请求,定时重发。
  • Forking Cluster :并行调用多个服务器，只要一个成功即返回。
  • Broadcast Cluster: 广播调用所有提供者,逐个调用，任意一台报错则报错。

消费者配置

@Reference(cluster = "failover")//远程注入
private UserService userService;

服务降级

服务降级：当服务器压力剧增的情况下，根据实际业务情况及流量，对一些服务和页面有策略的不处理或换种简单的方式处理，从而释放服务器资源以保证核心交易正常运作或高效运作

服务降级方式:

  • mock= force:return null：表示消费方对该服务的方法调用都直接返回null值,不发起远程调用。用来屏蔽不重要服务不可用时对调用方的影响。
  • mock=fail:return null：表示消费方对该服务的方法调用在失败后，再返回null值,不抛异常。用来容忍不重要服务不稳定时对调用方的影响

image.png

消费方配置

@Reference(cluster = "failover")//远程注入
private UserService userService;
//远程注入
@Reference(mock =“ force :return null")//不再调用userService的服务
private UserService userService;

Dubbo和Springboot整合

父工程pom依赖

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>

   <groupId>com.bxg</groupId>
   <artifactId>dubbo-springboot-demo1</artifactId>
   <packaging>pom</packaging>
   <version>1.0-SNAPSHOT</version>
   <modules>
      <module>dubbo-spring-interface</module>
      <module>dubbo-spring-provider</module>
      <module>dubbo-spring-consumer</module>
   </modules>

   <properties>
      <maven.compiler.source>8</maven.compiler.source>
      <maven.compiler.target>8</maven.compiler.target>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <dubbo-version>2.7.8</dubbo-version>
      <spring-boot.version>2.3.0.RELEASE</spring-boot.version>
   </properties>

   <dependencyManagement>
      <dependencies>
         <!-- Spring Boot -->
         <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>

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

         <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
            <version>${dubbo-version}</version>
            <exclusions>
               <exclusion>
                  <groupId>org.springframework</groupId>
                  <artifactId>spring</artifactId>
               </exclusion>
               <exclusion>
                  <groupId>javax.servlet</groupId>
                  <artifactId>servlet-api</artifactId>
               </exclusion>
               <exclusion>
                  <groupId>log4j</groupId>
                  <artifactId>log4j</artifactId>
               </exclusion>
            </exclusions>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <dependencies>
      <!-- Dubbo Spring Boot Starter -->
      <dependency>
         <groupId>org.apache.dubbo</groupId>
         <artifactId>dubbo-spring-boot-starter</artifactId>
         <version>${dubbo-version}</version>
      </dependency>
      <!-- Dubbo核心组件 -->
      <dependency>
         <groupId>org.apache.dubbo</groupId>
         <artifactId>dubbo</artifactId>
      </dependency>
      <!--Spring Boot 依赖 -->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
         <version>${spring-boot.version}</version>
      </dependency>
      <!-- Zookeeper客户端框架 -->
      <dependency>
         <groupId>org.apache.curator</groupId>
         <artifactId>curator-framework</artifactId>
         <version>4.0.1</version>
      </dependency>
      <!-- Zookeeper dependencies -->
      <dependency>
         <groupId>org.apache.dubbo</groupId>
         <artifactId>dubbo-dependencies-zookeeper</artifactId>
         <version>${dubbo-version}</version>
         <type>pom</type>
         <exclusions>
            <exclusion>
               <groupId>org.slf4j</groupId>
               <artifactId>slf4j-log4j12</artifactId>
            </exclusion>
         </exclusions>
      </dependency>
   </dependencies>

</project>

公用RPC接口工程

为便于客户端与服务端的RPC接口引用， 这里对RPC接口做统一封装。 image.png 定义了一个订单服务接口， 用于测试验证。

package com.bxg.dubbo.spring.api;

public interface OrderService {
   /**
    * 获取订单详情
    *
    * @param orderId
    * @return
    */
   String getOrder(Long orderId);
}

服务端工程

工程结构

image.png

pom依赖

<?xml version="1.0" encoding="UTF-8"?>
<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">
   <parent>
      <artifactId>dubbo-springboot-demo1</artifactId>
      <groupId>com.bxg</groupId>
      <version>1.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>

   <artifactId>dubbo-spring-provider</artifactId>

   <properties>
      <maven.compiler.source>8</maven.compiler.source>
      <maven.compiler.target>8</maven.compiler.target>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>

   <dependencies>
      <!-- Dubbo Spring Boot Starter -->
      <dependency>
         <groupId>org.apache.dubbo</groupId>
         <artifactId>dubbo-spring-boot-starter</artifactId>
         <version>${dubbo-version}</version>
      </dependency>
      <!-- Dubbo 核心依赖 -->
      <dependency>
         <groupId>org.apache.dubbo</groupId>
         <artifactId>dubbo</artifactId>
      </dependency>
      <!-- 公用RPC接口依赖 -->
      <dependency>
         <groupId>com.bxg</groupId>
         <artifactId>dubbo-spring-interface</artifactId>
         <version>1.0-SNAPSHOT</version>
      </dependency>
   </dependencies>

</project>

RPC服务接口

package com.bxg.dubbo.spring.provider.service.impl;

import java.util.concurrent.TimeUnit;

import com.bxg.dubbo.spring.api.OrderService;
import org.apache.dubbo.config.annotation.DubboService;

import org.springframework.beans.factory.annotation.Value;

@DubboService(version = "${dubbo.spring.provider.version}")
public class OrderServiceImpl implements OrderService {

   /**
    * 服务端口
    */
   @Value("${server.port}")
   private String serverPort;

   @Value("${dubbo.spring.provider.version}")
   private String serviceVersion;

   /**
    * 获取订单详情
    *
    * @param orderId
    * @return
    */
   public String getOrder(Long orderId) {
      try {
         TimeUnit.SECONDS.sleep(2);
      }
      catch (InterruptedException e) {
         throw new RuntimeException(e);
      }
      String result = "get order detail, orderId = " + orderId + ", serverPort = "
            + serverPort + ",serviceVersion=" + serviceVersion;
      System.out.println(result);
      return result;
   }
}

工程配置

# 服务端口
server.port=18081
# 应用程序名称
spring.application.name=dubbo-spring-provider
# Dubbo服务扫描路径
dubbo.scan.base-packages=com.bxg
# Dubbo 通讯协议
dubbo.protocol.name=dubbo
# Dubbo服务提供的端口， 配置为-1，代表为随机端口 默认 20880
dubbo.protocol.port=-1
## Dubbo 注册器配置信息
dubbo.registry.address=zookeeper://192.168.67.128:2181
dubbo.registry.file = ${user.home}/dubbo-cache/${spring.application.name}/dubbo.cache
dubbo.spring.provider.version = 1.0.0

Spring Boot启动程序

package com.bxg.dubbo.spring.provider;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(scanBasePackages = "com.bxg")
public class DubboSpringProviderApplication {
   public static void main(String[] args) {
      SpringApplication.run(DubboSpringProviderApplication.class, args);
   }
}

消费端工程

工程结构

image.png

POM依赖

<?xml version="1.0" encoding="UTF-8"?>
<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">
   <parent>
      <artifactId>dubbo-springboot-demo1</artifactId>
      <groupId>com.bxg</groupId>
      <version>1.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>

   <artifactId>dubbo-spring-consumer</artifactId>

   <properties>
      <maven.compiler.source>8</maven.compiler.source>
      <maven.compiler.target>8</maven.compiler.target>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>

   <dependencies>
      <!-- Dubbo Spring Boot Starter -->
      <dependency>
         <groupId>org.apache.dubbo</groupId>
         <artifactId>dubbo-spring-boot-starter</artifactId>
         <version>${dubbo-version}</version>
      </dependency>
      <!-- 公用RPC接口依赖 -->
      <dependency>
         <groupId>com.bxg</groupId>
         <artifactId>dubbo-spring-interface</artifactId>
         <version>1.0-SNAPSHOT</version>
      </dependency>
   </dependencies>

</project>

消费端调用

package com.bxg.dubbo.spring.consumer.controller;

import com.bxg.dubbo.spring.api.OrderService;
import org.apache.dubbo.config.annotation.DubboReference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/order")
public class OrderController {
   private final Logger logger = LoggerFactory.getLogger(getClass());
   /**
    * 订单服务接口
    */
   @DubboReference(version = "${dubbo.spring.provider.version}", retries = 3, loadbalance = "roundrobin",
         stub = "com.bxg.dubbo.spring.consumer.stub.OrderServiceStub")
   private OrderService orderService;

   /**
    * 获取订单详情接口
    *
    * @param orderId
    * @return
    */
   @RequestMapping("/getOrder")
   @ResponseBody
   public String getOrder(Long orderId) {
      String result = null;
      try {
         result = orderService.getOrder(orderId);
      }
      catch (Exception e) {
         logger.error(e.getMessage(), e);
      }
      return result;
   }
}

工程配置

# 服务端口
server.port=18084
#服务名称
spring.application.name=dubbo-spring-consumer
#服务版本号
dubbo.spring.provider.version = 1.0.0
#消费端注册器配置信息
dubbo.registry.address=zookeeper://192.168.67.128:2181
dubbo.registry.file = ${user.home}/dubbo-cache/${spring.application.name}/dubbo.cache

Spring Boot启动程序

package com.bxg.dubbo.spring.consumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(scanBasePackages = "com.bxg")
public class DubboSpringConsumerApplication {
   public static void main(String[] args) {
      SpringApplication.run(DubboSpringConsumerApplication.class, args);
   }
}

工程调用验证

  1. 启动ZK注册中心
  2. 启动服务端， 运行DubboSpringProviderApplication
  3. 启动消费端， 运行DubboSpringConsumerApplication
  4. 请求获取订单接口， 地址： http://127.0.0.1:18084/order/getOrder? orderId=1001 调用成功：

image.png

Dubbo高阶配置运用

不同配置覆盖关系

关于配置参看官方文档：dubbo.apache.org/zh/docsv2.7… r/configuration/

image.png

配置规则：

  • 方法级优先，接口级次之，全局配置再次之。
  • 如果级别一样，则消费方优先，提供方次之。

属性配置优先级

image.png

优先级从高到低

超时设定

全局配置类

package com.bxg.dubbo.spring.consumer.config;

import org.apache.dubbo.config.ProviderConfig;

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

/**
 * @Description 服务消费端Dubbo服务提供者全局配置
 * @Author 郑懿
 * @Date 2023/4/17 11:32
 **/
@Configuration
public class DubboCustomConfig {

   /**
    * 服务端
    * @return
    */
   @Bean
   public ProviderConfig registryConfig() {
      ProviderConfig providerConfig = new ProviderConfig();
      // 设定超时时间为5S
      providerConfig.setTimeout(1000);
      return providerConfig;
   }

}

消费方配置

/**
 * 订单服务接口
 */
@DubboReference(version = "${dubbo.spring.provider.version}", retries = 3, loadbalance = "roundrobin",
      stub = "com.bxg.dubbo.spring.consumer.stub.OrderServiceStub")
private OrderService orderService;

本地存根调用

image.png 把 Stub 暴露给用户，Stub 可以决定要不要去调 Proxy。

客户端存根实现：

package com.bxg.dubbo.spring.consumer.stub;

import com.bxg.dubbo.spring.api.OrderService;

/**
 * @Description
 * @Author 郑懿
 * @Date 2023/4/17 12:49
 **/
public class OrderServiceStub implements OrderService {

   private final OrderService orderService;

   // 构造函数传入真正的远程代理对象
   public OrderServiceStub(OrderService orderService) {
      this.orderService = orderService;
   }

   /**
    * 获取订单详情
    *
    * @param orderId
    * @return
    */
   @Override
   public String getOrder(Long orderId) {
      // 在客户端执行, 预先验证参数是否合法，等等
      try {
         if (null != orderId) {
            return orderService.getOrder(orderId);
         }
         return "参数校验错误！";
      }
      catch (Exception e) {
         //容错处理
         return "出现错误：" + e.getMessage();
      }
   }
}

修改客户端调用配置

/**
 * 订单服务接口
 */
@DubboReference(version = "${dubbo.spring.provider.version}", retries = 3, loadbalance = "roundrobin",
      stub = "com.bxg.dubbo.spring.consumer.stub.OrderServiceStub")
private OrderService orderService;

服务降级运用

服务动态禁用

启动单个服务节点，进入Dubbo Admin， 创建动态配置规则：

configVersion: v2.7
enabled: true
configs:
  - side: provider
    addresses:
      - '0.0.0.0:20880'
    parameters:
      timeout: 3000
      disabled: true

image.png

将disabled属性改为 false，

configVersion: v2.7
enabled: true
configs:
  - side: provider
    addresses:
      - '0.0.0.0:20880'
    parameters:
      timeout: 3000
      disabled: false

image.png

服务降级

image.png

降级测试（force方式）

configVersion: v2.7
enabled: true
configs:
  - side: consumer
    addresses:
      - 0.0.0.0
    parameters:
      timeout: 3000
      mock: 'force:return null'

客户端调用， 会直接屏蔽， 并且服务端控制台不会有任何调 用记录： image.png

降级测试（fail方式）

configVersion: v2.7
enabled: true
configs:
  - side: consumer
    addresses:
      - 0.0.0.0
    parameters:
      timeout: 3000
      mock: 'force:return null'

这里为了触发调用异常， 超时时间缩短为1秒。

注意这里的超时时间可能不会起作用，最终的超时时间还是得 看项目中配置，故在服务提供方将线程休眠时间延长，造成调 用超时。

客户端调用， 会出现降级显示为空:

image.png

并发与连接控制

实际运用， 会碰到高并发与峰值场景， Dubbo是可以做到并发与连接数控 制。可使用jmeter进行测试！

并发数控制

服务端控制
服务级别
<dubbo:service interface="com.foo.BarService" executes="10" />

服务器端并发执行（或占用线程池线程数）不能超过 10 个。

方法级别
<dubbo:service interface="com.foo.BarService"> 
    <dubbo:method name="sayHello" executes="3" />
</dubbo:service>

限制具体的方法，服务器端并发执行（或占用线程池线程数）不能超过3 个。

客户端控制
调用的服务控制
<dubbo:reference interface="com.foo.BarService" actives="10" />

每客户端并发执行（或占用连接的请求数）不能超过 10 个。

调用的服务方法控制
<dubbo:reference interface="com.foo.BarService">
    <dubbo:method name="sayHello" actives="10" />
</dubbo:service>

dubbo:reference比dubbo:service优先。

客户端负载配置
<dubbo:reference interface="com.foo.BarService" loadbalance="leastactive" />

负载策略为最小连接数时， Loadbalance 会调用并发数最小的Provider。

连接数控制

服务端连接控制
<dubbo:provider protocol="dubbo" accepts="10" />

限制服务器端接受的连接不能超过 10 个

客户端连接控制

<dubbo:reference interface="com.foo.BarService" connections="10" /> 限制客户端服务使用连接不能超过 10 个

如果 dubbo:service 和 dubbo:reference 都配了 connections，dubbo:reference 优先。

avatar
文章
阅读
粉丝