Spring、Spring Boot集成分布式服务框架Dubbo

最新推荐文章于 2022-02-13 20:42:21 发布
最新推荐文章于 2022-02-13 20:42:21 发布
阅读量406 收藏 2
点赞数 3
分类专栏： # Spring Boot # Spring # Spring Cloud 文章标签： 分布式 zookeeper java dubbo docker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38628046/article/details/109062097
版权
Spring Boot 同时被 3 个专栏收录
35 篇文章 1 订阅
订阅专栏
Spring
29 篇文章 1 订阅
订阅专栏
Spring Cloud
14 篇文章 0 订阅
订阅专栏

Spring、Spring Boot集成分布式服务框架Dubbo

一、Dobbo概述

Dubbo是阿里巴巴公司开源的一个高性能优秀的服务框架，使得应用可通过高性能的RPC(远程服务调用框架) 实现服务的输出和输入功能，可以和Spring框架无缝集成。 Dubbox是当当网的扩展版本,Dubbox 和Dubbo本质上没有区别，名字的含义扩展了Dubbo。 后来捐献给Apache基金会孵化，现已正式成为Apache顶级项目。

Apache Dubbo提供了六大核心能力：面向接口代理的高性能RPC调用，智能容错和负载均衡，服务自动注册和发现，高度可扩展能力，运行期流量调度，可视化的服务治理与运维。
在这里插入图片描述

核心部分

1.远程通讯，提供对多种基于长连接的NiO框架抽象封装，包括多种线程模型，序列化，以及“请求一响应”模式的信息交换方式。

2.集群容错: 提供基于接口方法的透明远程过程调用，包括多协议支持。以及负载均衡，失败容错，地址路由，动态配置等集群支持。 

3.自动发现:基于注册中心目录服务，使用服务消费能动态查找服务提供方，使地址透明，使用服务提供方可以平滑增加或减少服务器

Dubbo架构

在这里插入图片描述

节点角色说明：

Provider: 暴露服务的服务提供方。

Consumer: 调用远程服务的服务消费方。

Registry: 服务注册与发现的注册中心。

Monitor: 统计服务的调用次调和调用时间的监控中心。

Container: 服务运行容器。

Subscribe:订阅

Notify:通知

Invoke:调用

调用关系说明：

1. 服务容器负责启动，加载，运行服务提供者。

2. 服务提供者在启动时，向注册中心注册自己提供的服务。

3. 服务消费者在启动时，向注册中心订阅自己所需的服务。

4. 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。

5. 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。

6. 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

二、注册中心之Zookeeper

zookeeper概述

官方推荐使用zookeeper注册中心。注册中心负责服务地址的注册与查找，相当于目录服务，服务提供者和消费者只在启动时与注册中心交互，注册中心不转发请求，压力较小。

zookeeper是Apacahe Hadoop的子项目，是一个树型的目录服务，支持变更推送，适合作为Dubbo服务的注册中心，工业强度较高，可用于生产环境。

zooKeeper用来做dubbo的注册中心，即哪一个服务由哪一台机器来提供必需让调用者知道，简单来说就是 ip 地址和服务名称的对应关系。

zookeeper安装

1.Docker安装zookeeper

Docker安装zookeeper

2.源码安装zookeeper

1.下载zookeeper

zookeeper官网：https://zookeeper.apache.org/

ZooKeeper服务器是用Java创建的，运行在JVM之上，所以需要安装JDK 。

2.上传 apache-zookeeper-3.6.3-bin.tar.gz

3.解压

tar -zxvf apache-zookeeper-3.6.3-bin.tar.gz

4.配置

进入到conf目录拷贝一个zoo_sample.cfg并完成配置

#进入到conf目录
cd /zooKeeper/apache-zookeeper-3.6.3-bin/conf/
#拷贝
cp  zoo_sample.cfg  zoo.cfg
# 修改zoo.cfg
vim /zooKeeper/apache-zookeeper-3.6.3-bin/conf/zoo.cfg

修改存储目录：dataDir=/zookeeper/zkdata

# The number of milliseconds of each tick
tickTime=2000
# The number of ticks that the initial 
# synchronization phase can take
initLimit=10
# The number of ticks that can pass between 
# sending a request and getting an acknowledgement
syncLimit=5
# the directory where the snapshot is stored.
# do not use /tmp for storage, /tmp here is just 
# example sakes.
dataDir=/zookeeper/zkdata
# the port at which the clients will connect
clientPort=2181
# the maximum number of client connections.
# increase this if you need to handle more clients
#maxClientCnxns=60
#
# Be sure to read the maintenance section of the 
# administrator guide before turning on autopurge.
#
# http://zookeeper.apache.org/doc/current/zookeeperAdmin.html#sc_maintenance
#
# The number of snapshots to retain in dataDir
#autopurge.snapRetainCount=3
# Purge task interval in hours
# Set to "0" to disable auto purge feature
#autopurge.purgeInterval=1

## Metrics Providers
#
# https://prometheus.io Metrics Exporter
#metricsProvider.className=org.apache.zookeeper.metrics.prometheus.PrometheusMetricsProvider
#metricsProvider.httpPort=7000
#metricsProvider.exportJvmInfo=true

5.启动

cd /zooKeeper/apache-zookeeper-3.6.3-bin/bin/
#启动
 ./zkServer.sh  start

6.查看状态

./zkServer.sh status

ZooKeeper客户端工具

1.Zoolnspector

在这里插入图片描述

在这里插入图片描述
2.PrettyZoo

PrettyZoo： https://github.com/vran-dev/PrettyZoo

在这里插入图片描述

三、Spring集成Dubbo

1.创建公共接口模块

创建dubbo-interface公共接口模块，并添加一个接口。

public interface IDemoTestService {

    public String demoTest();
}

2.服务提供者

创建dubbo-service工程模块，打包方式是war包。

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>cn.ybzy</groupId>
    <artifactId>dubbo-service</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <spring.version>5.2.8.RELEASE</spring.version>
    </properties>

    <dependencies>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>   
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- dubbo相关,版本2.7之后统一为org.apache.dubb-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.6.9</version>
        </dependency>
        <!--ZooKeeper相关 -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.6.2</version>
        </dependency>
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.11</version>
        </dependency>
         <!--dubbo使用相关 -->
        <dependency>
            <groupId>javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.9.0.GA</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>4.0.1</version>
        </dependency>
         <!--公共接口模块-->
        <dependency>
            <groupId>cn.ybzy</groupId>
            <artifactId>dubbo-interface</artifactId>
            <version>1.0-SNAPSHOT</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>

  <!-- 加载spring容器 -->
  <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>

创建接口实现类

对公共接口模块中的接口进行实现

注意：Service注解是com.alibaba包下的


import cn.ybzy.demo.service.IDemoTestService;
import com.alibaba.dubbo.config.annotation.Service;

/**
 * @Service作用：
 * 
 * 1.这该类提供的方法（服务）对外发布
 * 
 * 2.将访问的地址 ip，端口，路径注册到注册中心中
 */
@Service
public class DemoTestServiceImpl implements IDemoTestService {

    @Override
    public String demoTest() {
        return "Hello Dubbo！";
    }
}

配置applicationContext.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应用的名称,唯一-->
	<dubbo:application name="dubbo-service"/>
	 <!--配置注册中心的地址-->
	<dubbo:registry address="zookeeper://ip:2181"/>
	<!--配置dubbo包扫描，dubbo:annotation用于扫描@Service注解-->
	<dubbo:annotation package="cn.ybzy.demo.service" />
</beans>

3.服务消费者

创建Maven工程，dubbo-web，打包方式为War包。

同dubbo-service工程，引入依赖，修改tomcat插件访问端口。

配置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:springmvc.xml</param-value>
    </init-param>
  </servlet>

  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>


  <!-- 解决中文乱码 -->
  <filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>utf-8</param-value>
    </init-param>
    <init-param>
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>

创建控制器

注意：Reference注解是com.alibaba包下的

@RestController
@RequestMapping("/demo")
public class DemoTestController {

	/**
     * 1. 从zookeeper注册中心获取demoTestService的访问url
     * 2. 进行远程调用RPC
     * 3. 将结果封装为一个代理对象。给变量赋值
     */
    @Reference
    private IDemoTestService demoTestService;


    @RequestMapping("/test")
    public String demoTest(){
        return demoTestService.demoTest();
    }
}

配置spring-mvc.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" xmlns:mvc="http://www.springframework.org/schema/mvc"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
	<context:component-scan base-package="cn.ybzy.demo.controller"></context:component-scan>


	<mvc:annotation-driven></mvc:annotation-driven>

	<dubbo:application name="dubbo-web"/>
	<dubbo:registry address="zookeeper://ip:2181"/>
	<dubbo:annotation package="cn.ybzy.dmeo.controller" />

</beans>

4.执行测试

tomcat7:run 分别运行两个项目，浏览器访问http://localhost:8082/demo/test

在这里插入图片描述

5.查看zookeeper

在这里插入图片描述

四、部署管理中心

dubbo-admin是一个Dubbo的管理平台，是图形化的服务管理页面，它从注册中心中获取到所有的提供者 / 消费者进行配置管理，如：路由规则、动态配置、服务降级、访问控制、权重调整、负载均衡等管理功能

Docker安装dubbo-admin

Docker安装dubbo-admin

在这里插入图片描述

源码安装dubbo-admin

1.下载Dubbo-Admin

https://github.com/apache/dubbo-admin.git

2.解压及修改配置文件

进入dubbo-admin-server\src\main\resources目录，修改 **application.properties** 配置文件

修改zookeeper地址

# centers in dubbo2.7, if you want to add parameters, please add them to the url
admin.registry.address=zookeeper://127.0.0.1:2181
admin.config-center=zookeeper://127.0.0.1:2181
admin.metadata-report.address=zookeeper://127.0.0.1:2181

admin.registry.address 注册中心
admin.config-center  配置中心
admin.metadata-report.address 元数据中心

3.打包项目

在dubbo-admin-develop目录执行打包命令 ：mvn  clean package

4.启动后端项目

进入dubbo-Admin-develop\dubbo-admin-distribution\target>目录

启动 dubbo-admi	：	java -jar .\dubbo-admin-0.1.jar

5.安装node.js

下载 ：https://nodejs.org/en/

6.启动前端项目
dubbo-admin-ui 目录下执行命令：

npm run dev

7.浏览器访问

默认用户名密码都是root

admin.root.user.name=root
admin.root.user.password=root

五、Spring Boot集成Dubbo

构建父模块

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.ybzy</groupId>
    <artifactId>dubbo</artifactId>
    <packaging>pom</packaging>
    <version>0.0.1-SNAPSHOT</version>

    <name>dubbo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.8.RELEASE</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- dubbo -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.10</version>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-dependencies-zookeeper</artifactId>
            <version>2.7.10</version>
            <type>pom</type>
        </dependency>

        <!-- zookeeper -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.6.3</version>
        </dependency>
    </dependencies>
    
</project>

Common-api

统一定义接口，供其其他模块引用

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

服务提供者

服务提供者，实现common-api模块中的接口，然后暴露到Zookeeper中，供服务消费者使用

在Spring Boot启动类中加入@EnableDubbo注解，表示要开启dubbo功能

@EnableDubbo能够找到Dubbo注解所注解的任何内容。

import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@EnableDubbo
@SpringBootApplication
public class ProviderApplicaiton {
    public static void main(String[] args) {
        SpringApplication.run(ProviderApplicaiton.class, args);
    }
}

提供者配置

server:
  port: 8080

dubbo:
  application:
    # 服务名称，保持唯一
    name: server-provider
    # zookeeper地址，用于向其注册服务
  registry:
    address: zookeeper://127.0.0.1:2181
  #暴露服务方式
  protocol:
    # dubbo协议，固定写法
    name: dubbo
    # 暴露服务端口 （默认是20880，不同的服务提供者端口不能重复）
    port: 20880

接口实现类必须注解@DubboService

import cn.ybzy.common.api.HelloService;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.stereotype.Component;

@DubboService
@Component
public class HelloServiceImpl implements HelloService {
    
    @Override
    public String sayHello(String message) {
        return "hello," + message;
    }
}

服务消费者

服务消费者，通过Dubbo从Zookeeper中获取服务并消费

在Spring Boot启动类中加入@EnableDubbo注解，表示要开启dubbo功能

@EnableDubbo能够找到Dubbo注解所注解的任何内容

import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@EnableDubbo
@SpringBootApplication
public class ConsumerApplicaiton {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplicaiton.class, args);
    }
}

消费者配置

server:
  port: 8081

dubbo:
  application:
    # 服务名称，保持唯一
    name: server-consumer
    # zookeeper地址，用于从中获取注册的服务
  registry:
    address: zookeeper://127.0.0.1:2181
  protocol:
    # dubbo协议，固定写法
    name: dubbo

使用@DubboReference注解将提供者自动装配到消费者中

@RestController
public class HelloController {

    @DubboReference
    private HelloService helloService;

    @GetMapping("/hello/{message}")
    public String sayHello(@PathVariable String message) {
        return this.helloService.sayHello(message);
    }
}

执行测试

启动服务,访问http://localhost:8081/hello/dubbo
在这里插入图片描述
通过客户端连接zookeeper
在这里插入图片描述

六、Dubbo的特性

地址缓存

当zookeeper注册中心挂了，服务任然可以正常访问，原因如下：

1.dubbo服务消费者在第一次调用时，会将服务提供方地址缓存到本地，以后调用不会访问注册中心。

2.当服务提供者地址发生变化时，注册中心会通知服务消费者。

超时机制

服务消费者在调用服务提供者的时候如果发生了阻塞、等待的情况，会造成服务消费者一直等待下去。如果在某个峰值时刻，大量请求都在同时请求服务消费者，会造成线程的大量堆积，势必会造成雪崩。

dubbo利用超时机制来解决该问题：设置一个超时时间，在这个时间段内，无法完成服务访问，则自动断开连接。

使用timeout属性配置超时时间，默认值1000，单位毫秒。

@Service(timeout = 3000)
public class DemoTestServiceImpl implements IDemoTestService {

    @Override
    public String demoTest() {
        return "Hello Dubbo！";
    }
}

重试机制

Dubbo服务在尝试调用一次之后，如出现非业务异常(服务突然不可用、超时等)，Dubbo 默认会进行额外的最多2次重试

通过 retries 属性设置重试次数。默认为 2 次。

@Service(retries = 3)
public class DemoTestServiceImpl implements IDemoTestService {

    @Override
    public String demoTest() {
        return "Hello Dubbo！";
    }
}

集群容错

在集群调用失败时，Dubbo 提供了多种容错方案，缺省为 failover 重试。
在这里插入图片描述
各节点关系：

这里的 Invoker 是 Provider 的一个可调用 Service 的抽象，Invoker 封装了 Provider 地址及 Service 接口信息

Directory 代表多个 Invoker，可以把它看成 List<Invoker> ，但与 List 不同的是，它的值可能是动态变化的，比如注册中心推送变更

Cluster 将 Directory 中的多个 Invoker 伪装成一个 Invoker，对上层透明，伪装过程包含了容错逻辑，调用失败后，重试另一个

Router 负责从多个 Invoker 中按路由规则选出子集，比如读写分离，应用隔离等

LoadBalance 负责从多个 Invoker 中选出具体的一个用于本次调用，选的过程包含了负载均衡算法，调用失败后，需要重选

集群容错模式：
在这里插入图片描述

Failover Cluster：

失败自动切换，当出现失败，重试其它服务器。通常用于读操作，但重试会带来更长延迟。可通过 retries="2" 来设置重试次数(不含第一次)。

Failfast Cluster ：

快速失败，只发起一次调用，失败立即报错。通常用于非幂等性的写操作，比如新增记录。

Failsafe Cluster ：

失败安全，出现异常时，直接忽略。通常用于写入审计日志等操作。

Failback Cluster ：

失败自动恢复，后台记录失败请求，定时重发。通常用于消息通知操作。

Forking Cluster ：

并行调用多个服务器，只要一个成功即返回。通常用于实时性要求较高的读操作，但需要浪费更多服务资源。可通过 forks="2" 来设置最大并行数。

Broadcast Cluster ：

广播调用所有提供者，逐个调用，任意一台报错则报错。通常用于通知所有提供者更新缓存或日志等本地资源信息。

@RestController
@RequestMapping("/demo")
public class DemoTestController {

    @Reference(cluster = "failover")
    private IDemoTestService demoTestService;
    @RequestMapping("/test")
    public String demoTest(){
        return demoTestService.demoTest();
    }
}

负载均衡

在集群负载均衡时，Dubbo 提供了多种均衡策略，缺省为 random 随机调用。

Dubbo提供了4种负载均衡策略：Random 、RoundRobin 、LeastActive、ConsistentHash

在这里插入图片描述

Random ：

随机，按权重设置随机概率。

在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。

@Service(weight = 100)
public class DemoTestServiceImpl2 implements IDemoTestService {

    @Override
    public String demoTest() {
        return "Hello Dubbo！";
    }
}

RoundRobin ：

轮询，按公约后的权重设置轮询比率。

存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。

@Service(weight = 100,loadbalance="roundrobin")
public class DemoTestServiceImpl2 implements IDemoTestService {

    @Override
    public String demoTest() {
        return "Hello Dubbo！";
    }
}

LeastActive：

最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。

使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。

@Service(weight = 100,loadbalance="leastactive")
public class DemoTestServiceImpl2 implements IDemoTestService {

    @Override
    public String demoTest() {
        return "Hello Dubbo！";
    }
}

ConsistentHash：

一致性 Hash，相同参数的请求总是发到同一提供者。

当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动。

算法参见：http://en.wikipedia.org/wiki/Consistent_hashing

缺省只对第一个参数 Hash，如果要修改，请配置 <dubbo:parameter key="hash.arguments" value="0,1" />

缺省用 160 份虚拟节点，如果要修改，请配置 <dubbo:parameter key="hash.nodes" value="320" />

@Service(weight = 100,loadbalance="consistenthash")
public class DemoTestServiceImpl2 implements IDemoTestService {

    @Override
    public String demoTest() {
        return "Hello Dubbo！";
    }
}

多版本

在 Dubbo 中为同一个服务配置多个版本。当一个接口实现，出现不兼容升级时，可以用版本号过渡，版本号不同的服务相互间不引用。

版本迁移步骤：

1.在低压力时间段，先升级一半提供者为新版本

2.再将所有消费者升级为新版本

3.然后将剩下的一半提供者升级为新版本

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

创建如下2个服务提供者：

@Service(version = "v0.0.1")
public class DemoTestServiceImpl implements IDemoTestService {

    @Override
    public String demoTest() {
        return "Hello Dubbo！";
    }
}

@Service(version = "v0.0.2")
public class DemoTestServiceImpl2 implements IDemoTestService {

    @Override
    public String demoTest() {
        return "Hello Dubbo！";
    }
}

服务消费者

@RestController
@RequestMapping("/demo")
public class DemoTestController {

    @Reference(version = "v0.0.2")
    private IDemoTestService demoTestService;
    @RequestMapping("/test")
    public String demoTest(){
        return demoTestService.demoTest();
    }
}

服务降级

可以通过服务降级功能临时屏蔽某个出错的非关键服务，并定义降级后的返回策略。

mock=force:return null

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

mock=fail:return null

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

@RestController
@RequestMapping("/demo")
public class DemoTestController {

    @Reference(mock = "mock=force:return null")
    private IDemoTestService demoTestService;
    @RequestMapping("/test")
    public String demoTest(){
        return demoTestService.demoTest();
    }
}

七、Dubbo总结概述

什么是Dubbo？

Duubbo是一个RPC远程调用框架， 分布式服务治理框架

什么是Dubbo服务治理？

服务与服务之间会有很多个Url、依赖关系、负载均衡、容错、自动注册服务，Dubbo服务治理便是治理这些关系。

Dubbo有哪些协议？

默认使用的是dubbo协议，还有Http、RMI、Hessian协议

Dubbo的整个架构流程？

四大模块：

生产者：提供服务
消费者: 调用服务
注册中心:注册信息(redis、zk)
监控中心:调用次数、关系依赖等。

过程：

首先生产者将服务注册到注册中心（zk），使用zk持久节点进行存储

消费者订阅zk节点，一旦有节点变更，zk通过事件通知传递给消费者

消费者可以调用生产者服务，服务与服务之间进行调用，都会在监控中心中，存储一个记录

SpringCloud与Dubbo区别？

都可以实现RPC远程调用
都可以使用分布式、微服务场景下

dubbo使用zk或redis作为作为注册中心，而springcloud使用eureka作为注册中心
dubbo支持多种协议，默认使用dubbo协议而Springcloud只能支持http协议。
CodeDevMaster
关注
专栏目录
分布式开发框架Dubbo
努力学习ing
08-29 983
分布式开发框架Dubbo
分布式框架 ---dubbo
guoguo0717的博客
03-31 541
分布式框架-Dubbox 1 什么是SOA架构 SOA是Service-Oriented Architecture的首字母简称，它是一种支持面向服务的架构样式。从服务、基于服务开发和服务的结果来看，面向服务是一种思考方式。其实SOA架构更多应用于互联网项目开发。 为什么互联网项目会采用SOA架构呢？随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，迫切需一个治理系统确保架构有条不紊的演进。 战争论–《战争论》是普鲁士军事理论家卡尔·冯·克劳塞维
dubbo 分布式框架
qq_44195558的博客
10-05 260
一、介绍： 只适合局域网开发，与cloud同级都是分布式，比cloud简单，适合中小型企业开发，整体上是把nacos注册中心作为大型的ioc,将service方法、controller注册上去，这样通过nacos实现跨项目通信（controller(调用者) 通过接口（interface） 调用service（提供者）中的方法），本质上仍然是uri的请求通信，只是外表看的是调用关系。 controller就类似于cloud的gateway。，是个中台的作用。 二、流程： 1、父项目导包：（父包） sp
分布式框架-dubbo
林帆的博客
07-06 344
1.分布式框架的演变 2.入门demo
分布式框架-Dubbo
ZZCY520的博客
07-31 172
分布式框架-Dubbo 1.什么是SOA架构？ SOA是Service-Oriented Architecture的首字母简称，它是一种支持面向服务的架构样式。从服务、基于服务开发和服务的结果来看，面向服务是一种思考方式。其实SOA架构更多应用于互联网项目开发。 为什么互联网项目会采用SOA架构呢？随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，迫切需一个治理系统确保架构有条不紊的演进。 2.什么是Dubbo？ Dubbo 是一个分布式服务框
Spring Boot Dubbo 构建分布式服务的方法
08-25
Spring Boot 提供了一种快速配置 Spring 框架的方式，简化了项目的初始化和配置过程，而 Dubbo 是一个高性能、轻量级的 Java RPC（远程过程调用）框架，专门用于构建分布式服务。 在Spring Boot Dubbo的架构中，有...
基于Spring Boot框架的分布式微服务系统.zip
最新发布
09-08
本项目是一个基于Spring Boot框架的分布式微服务系统，集成了Dubbo、MyBatis、RocketMQ、Redis等多种技术栈，旨在构建一个高性能、可扩展的微服务架构。项目涵盖了从数据访问层到服务层、再到网关层的完整技术栈，...
Spring Boot 集成Dubbo框架实例
08-30
在本文中，我们将探讨如何将流行的微服务框架Dubbo与Spring Boot进行集成，以便构建高效、可扩展的应用程序。Spring Boot以其简洁的配置和自动配置功能简化了Spring应用的开发，而Dubbo则是一个高性能、轻量级的服务...
dubbo-spring-boot-mybatis-redis：通过dubbo + spring boot + mybatis + redis等主流技术构建成一套分布式服务框架
01-30
通过dubbo + spring boot + mybatis + redis等主流技术建造成一套分布式服务框架 项目介绍： 1，首先安装zookeeper + redis； 2，dearbinge-data-provider服务提供者项目的资源文件dubbo-spring-mybatis.xml下配置...
分布式框架dubbo实现
11-24
分布式框架dubbo实现生产者提供服务通过zoopkeeper服务实现注册将服务暴露出来供消费者使用的demo
Dubbox分布式框架
fenghuanxia66的博客
11-11 501
Dubbox的由来： Dubbox 是一个分布式服务框架，其前身是阿里巴巴开源项目Dubbo ， 被国内电商及互联网项目中使用，后期阿里巴巴停止了该项目的维护， 当当网便在Dubbo基础上进行优化，并继续维护，为了与原有的Dubbo区分，故将其命名为Dubbox。 Dubbox的作用： Dubbox 致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。 简单的说，dubbo...
Dubbo分布式服务框架
qq_43171656的博客
09-09 158
Dubbo分布式服务框架 1 Dubbo 介绍 Dubbo 是阿里巴巴公司开源的一个高性能优秀的分布式服务框架，使得应用可通过高性能的 RPC 实现服务的输出和输入功能，可以和 Spring 框架无缝集成。Dubbo 框架，是基于Spring容器运行的 。 Dubbo是一款高性能、轻量级的开源Java RPC(Java远程过程调用协议)框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。 官方网站 : http://du...
Dubbo解析及原理浅析
热门推荐
chao_19的博客
06-26 12万+
一、Duboo基本概念解释Dubbo是一种分布式服务框架。 Webservice也是一种服务框架，但是webservice并不是分布式的服务框架，他需要结合F5实现负载均衡。因此，dubbo除了可以提供服务之外，还可以实现软负载均衡。它还提供了两个功能Monitor 监控中心和调用中心。这两个是可选的，需要单独配置。
分布式服务框架——Dobbo
qq_53226437的博客
02-13 2127
Dubbo Dubbo 最早是 Alibaba 开源的分布式服务框架，它最大的特点是按照分层的方式来架构， 使用这种方式可以使各个层之间解耦合（或者最大限度地松耦合）。从服务模型的角度来看， Dubbo 采用的是一种非常简单的模型，要么是提供方提供服务，要么是消费方消费服务，所 以基于这一点可以抽象出服务提供方（Provider）和服务消费方（Consumer）两个角色。 服务架构角色 Container：服务运行框架，dubbo完全基于spring实现 Provider：提供远程调用服务 Registr
Dubbo 分布式系统架构入门
qq_40286307的博客
10-10 478
Dubbo 概述 什么是分布式系统 分布式系统是若干独立计算机的集合，这些计算机对于用户来说就像单个相关系统。 分布式系统（distributed system）是建立在网络之上的软件系统。 简单来说：多个（不同职责）人共同来完成一件事。 任何一台服务器都无法满足淘宝的双十一的数据吞吐量，一定是很多台服务器公共来完成的。 单一应用架构 当网站流量很小时，只需要一个应用，将所有的功能部署到一起（所有业务都放在一个 tomcat 里），从而减少部署节点和成本； 此时，用于简化增删改查工作量的数据访问框架 （OR
使用Spring Boot与Dubbo构建分布式服务教程
"本文主要介绍如何使用Spring Boot和Dubbo构建分布式服务，通过实例解析各个节点的角色和调用关系，并提供了项目的构建环境和基础代码示例。" 在分布式系统中，Spring Boot结合Dubbo是一个常见的架构选择，它可以...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CodeDevMaster

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值