Dubbo

已于 2024-06-06 10:57:16 修改
阅读量137 收藏
点赞数
分类专栏： java 文章标签： rpc java 分布式
于 2022-06-15 16:00:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34124252/article/details/125298833
版权

⼀、背景

随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，亟需一个治理系统确保架构有条不紊的演进。

image

1、单体架构

当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。

2、垂直应用架构

当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，提升效率的方法之一是将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关键。

3、分布式应用架构阶段

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式服务框架(RPC)是关键。

二、RPC及Dubbo

1、什么是RPC

dubbo是⼀款⾼性能的rpc框架。什么是rpc呢？
rpc是⼀种协议：是⼀种远程过程调⽤（remote procudure call）协议

2、什么是dubbo

Apache Dubbo 是⼀款⾼性能、轻量级的开源服务框架。
Apache Dubbo |ˈdʌbəʊ| 提供了六⼤核⼼能⼒：⾯向接口代理的⾼性能RPC调⽤，智能容错和负载均衡，服务自动注册和发现，高度可扩展能⼒，运⾏期流量调度，可视化的服务治理与运维。

3、dubbo怎么实现远程通信

服务消费者去注册中⼼订阅到服务提供者的信息。然后通过dubbo进⾏远程调⽤。

4、快速开始

  1. 创建接口层项⽬

直接创建了⼀个项⽬。项⽬⾥有⼀个接口。接口中定义了⼀个服务的内容。

public interface SiteService {
    String getName(String name);
}
  1. 创建服务提供者
  • 创建⼀个服务提供者项⽬。引入依赖
<?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>spring-dubbo-demo</artifactId>
    <groupId>com.dx</groupId>
    <version>1.0-SNAPSHOT</version>
  </parent>
  <modelVersion>4.0.0</modelVersion>
  <artifactId>dubbo-demo-site-provider</artifactId>
  <properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.8.0-alpha2</version>
    </dependency>
    <!--dubbo-->
    <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo</artifactId>
      <version>2.7.3</version>
    </dependency>
    <!--zk-->
    <dependency>
      <groupId>org.apache.curator</groupId>
      <artifactId>curator-framework</artifactId>
      <version>4.1.0</version>
    </dependency>
    <dependency>
      <groupId>org.apache.curator</groupId>
      <artifactId>curator-client</artifactId>
      <version>4.1.0</version>
    </dependency>
    <dependency>
      <groupId>org.apache.curator</groupId>
      <artifactId>curator-recipes</artifactId>
      <version>4.1.0</version>
    </dependency>
    <dependency>
      <groupId>org.apache.zookeeper</groupId>
      <artifactId>zookeeper</artifactId>
      <version>3.4.13</version>
    </dependency>
    <!--接⼝层-->
    <dependency>
      <groupId>com.dx</groupId>
      <artifactId>dubbo-demo-site-api</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>
</project>
  • 编写具体的提供服务的实现类
import com.dx.api.SiteService;

public class SiteServiceImpl implements SiteService {
    @Override
    public String getName(String name) {
        return "name:"+name;
    }
}
  • 编写bean配置⽂件，将dubbo和spring ioc整合，把服务提供到dubbo中
<?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="site-service"/>
  <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
  <dubbo:protocol name="dubbo" port="20881"/>
  <bean id="siteService" class="com.dx.provider.service.impl.SiteServiceImpl"/>
  <dubbo:service interface="com.dx.api.SiteService" ref="siteService"/>
</beans>
  • 启动ioc容器，关联bean配置⽂件
public class Provider {
    public static void main(String[] args) throws IOException {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"provider.xml"});
        context.start();
        System.in.read(); 
    }
}
  1. 创建服务消费者
  • 引⼊依赖
<?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>spring-dubbo-demo</artifactId>
    <groupId>com.dx</groupId>
    <version>1.0-SNAPSHOT</version>
  </parent>
  <modelVersion>4.0.0</modelVersion>
  <artifactId>dubbo-demo-site-consumer</artifactId>
  <properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.8.0-alpha2</version>
    </dependency>
    <dependency>
      <groupId>com.dx</groupId>
      <artifactId>dubbo-demo-site-api</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
    <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo</artifactId>
      <version>2.7.3</version>
    </dependency>
    <!--zk-->
    <dependency>
      <groupId>org.apache.curator</groupId>
      <artifactId>curator-framework</artifactId>
      <version>4.1.0</version>
    </dependency>
    <dependency>
      <groupId>org.apache.curator</groupId>
      <artifactId>curator-client</artifactId>
      <version>4.1.0</version>
    </dependency>
    <dependency>
      <groupId>org.apache.curator</groupId>
      <artifactId>curator-recipes</artifactId>
      <version>4.1.0</version>
    </dependency>
    <dependency>
      <groupId>org.apache.zookeeper</groupId>
      <artifactId>zookeeper</artifactId>
      <version>3.4.13</version>
    </dependency>
  </dependencies>
</project>
  • 编写bean的配置⽂件
<?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="site-consumer"/>
  <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
  <dubbo:reference interface="com.dx.api.SiteService" id="siteService"/>
</beans>
  • 启动消费者，调⽤服务提供者
package com.dx.site.consumer;
import com.dx.api.SiteService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Consumer {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"consumer.xml"});
        context.start();
        SiteService service = (SiteService)context.getBean("siteService");
        String result = service.getName("hellodubbo");
        System.out.println(result);
    }
}

5、注解版

  1. 服务提供者
<dubbo:application name="site-service"/>
<dubbo:registry address="zookeeper://127.0.0.1:2181"/>
<dubbo:protocol name="dubbo" port="20881"/>
<dubbo:annotation package="com.dx.provider.service.impl"/>

import com.dx.api.SiteService;
import com.alibaba.dubbo.config.annotation.Service;

@Service //使用dubbo提供的service注解，注册暴露服务
public class SiteServiceImpl implements SiteService {
    @Override
    public String getName(String name) {
        return "name:"+name;
    }
}
  1. 服务消费者
<dubbo:application name="site-consumer"/>
<dubbo:registry address="zookeeper://127.0.0.1:2181"/>
<dubbo:annotation package="com.dx.dubbo.site.consumer.controller"/>

package com.dx.dubbo.site.consumer.controller;
import com.dx.api.SiteService;
import com.dx.entity.Site;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RequestMapping("/site")
public class SiteController {
    @Reference
    private SiteService service;
    @GetMapping("/get/{id}")
    public Site getSiteById(@PathVariable Long id){
        return service.getSiteById(id);
    }
}

6、dubbo内部结构

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

Dubbo 架构具有以下几个特点，分别是连通性、健壮性、伸缩性、以及向未来架构的升级性。

三、dubbo用法示例

1、version版本号

版本号⽤处是对于同⼀个接口，具有不同的服务实现。

  • 服务提供者1
@Service(version = "default")
public class DefaultSiteServiceImpl implements SiteService {
    @Override
    public String siteName(String name) {
        return "default:"+name;
    }
}
  • 服务提供者2
@Service(version = "async")
public class AsyncSiteServiceImpl implements SiteService {
    @Override
    public String siteName(String name) {
        return "async:" + name;
    }
}
  • 服务消费者
@Reference(id = "siteService",version = "async")
private SiteService siteService;

2、指定protocol协议

dubbo框架可以对协议进⾏扩展，⽐如使⽤：

  • rest
  • http
  • dubbo
  • ⾃定义协议

在配置⽂件中配置协议：

# 应⽤名称
spring.application.name=my-dubbo-provider
# 应⽤服务 WEB 访问端⼝
server.port=8080
# Base packages to scan Dubbo Component:
@org.apache.dubbo.config.annotation.Service==>@EnableDubbo
dubbo.scan.base-packages=com.dx.my.dubbo.provider
dubbo.application.name=${spring.application.name}
## Dubbo Registry
dubbo.registry.address=zookeeper://127.0.0.1:2181
# Dubbo Protocol
#dubbo.protocol.name=dubbo
#dubbo.protocol.port=20880
# @Path
#dubbo.protocol.name=rest
#dubbo.protocol.port=8083
dubbo.protocols.protocol1.id=rest
dubbo.protocols.protocol1.name=rest
dubbo.protocols.protocol1.port=8090
dubbo.protocols.protocol1.host=0.0.0.0
dubbo.protocols.protocol2.id=dubbo1
dubbo.protocols.protocol2.name=dubbo
dubbo.protocols.protocol2.port=20882
dubbo.protocols.protocol2.host=0.0.0.0
dubbo.protocols.protocol3.id=dubbo2
dubbo.protocols.protocol3.name=dubbo
dubbo.protocols.protocol3.port=20883
dubbo.protocols.protocol3.host=0.0.0.0

在暴露服务时指明要使⽤的协议：

@Service(version = "default",protocol = "protocol2")
public class DefaultSiteServiceImpl implements SiteService {
    @Override
    public String siteName(String name) {
        return "default:"+name;
    }
}

3、使用rest访问dubbo的服务

  • 服务提供者暴露⽤rest协议制定的服务
import com.dx.site.SiteService;
import org.apache.dubbo.config.annotation.Service;
import org.apache.dubbo.rpc.protocol.rest.support.ContentType;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;

@Service(version = "rest", protocol = "protocol1")
@Path("site")
public class RestSiteService implements SiteService {
    @Override
    @GET
    @Path("name")
    @Produces({ContentType.APPLICATION_JSON_UTF_8, ContentType.TEXT_PLAIN_UTF_8})
    public String siteName(@QueryParam("name") String name) {
        return "rest:" + name;
    }
}
  • 在浏览器中使⽤restful调⽤服务
http://localhost:8090/site/name?name=abc

4、消费者通过url直连指定的服务提供者

  • 配置⽂件中声明三个dubbo协议
dubbo.protocols.protocol1.id=dubbo1
dubbo.protocols.protocol1.name=dubbo
dubbo.protocols.protocol1.port=20881
dubbo.protocols.protocol1.host=0.0.0.0
dubbo.protocols.protocol2.id=dubbo2
dubbo.protocols.protocol2.name=dubbo
dubbo.protocols.protocol2.port=20882
dubbo.protocols.protocol2.host=0.0.0.0
dubbo.protocols.protocol3.id=dubbo3
dubbo.protocols.protocol3.name=dubbo
dubbo.protocols.protocol3.port=20883
dubbo.protocols.protocol3.host=0.0.0.0
  • 服务提供者暴露服务，未指定协议，则会暴露三个服务，每个协议对应⼀个服务
@Service(version = "default")
public class DefaultSiteServiceImpl implements SiteService {
    @Override
    public String siteName(String name) {
        return "default:"+name;
    }
}
  • 消费者端通过url指定某⼀个服务
@Reference(id = "siteService",version = "default",url = "dubbo://127.0.0.1:20881/com.dx.site.SiteService:default")
private SiteService siteService;

5、服务超时

服务提供者和服务消费者都可以配置服务超时时间（默认时间为1秒）：

  • 服务提供者的超时时间：执行该服务的超时时间。如果超时，则会打印超时⽇志（warn），但服务会正常执行完。
@Service(version = "timeout", timeout = 4000)
public class TimeoutSiteServiceImpl implements SiteService {
    @Override
    public String siteName(String name) {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("serving...");
        return "timeout site service:"+name;
    }
}
  • 服务消费者的超时时间：从发起服务调用到收到服务响应的整个过程的时间。如果超时，则进⾏重试，重试失败抛异常
@EnableAutoConfiguration
public class TimeoutDubboConsumer {
    @Reference(version = "timeout", timeout = 3000)
    private SiteService siteService;
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(TimeoutDubboConsumer.class);
        SiteService siteService = (SiteService)context.getBean(SiteService.class);
        String name = siteService.siteName("face");
        System.out.println(name);
    }
}

6、集群容错

dubbo为集群调⽤提供了容错⽅案：

  • failover：（默认，推荐）当出现失败时，会进⾏重试，默认重试2次(不含第一次)，⼀共三次调⽤。

  • failfast：只发起一次调用，失败立即报错。

  • failsafe：出现异常时，直接忽略。通常用于写入审计日志等操作。

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

  • forking：并行调用多个服务器，只要一个成功即返回。

7、服务降级

服务消费者通过Mock指定服务超时后执行的策略：

@EnableAutoConfiguration
public class MockDubboConsumer {
    @Reference(version = "timeout", timeout = 1000, mock = "fail:return timeout")
    private SiteService siteService;
    public static void main(String[] args) {
        ConfigurableApplicationContext context =
            SpringApplication.run(MockDubboConsumer.class);
        SiteService siteService = (SiteService)context.getBean(SiteService.class);
        String name = siteService.siteName("q-face");
        System.out.println(name);
    }
}
  • mock=force:return+null 表示消费方对该服务的方法调用都直接返回 null 值，不发起远程调用。用来屏蔽不重要服务不可用时对调用方的影响。
  • 还可以改为 mock=fail:return+null 表示消费方对该服务的方法调用在失败后，再返回 null 值，不抛异常。用来容忍不重要服务不稳定时对调用方的影响。

8、本地存根

远程服务后，客户端通常只剩下接口，而实现全在服务器端，但提供方有些时候想在客户端也执行部分逻辑，比如：做 ThreadLocal 缓存，提前验证参数，调用失败后伪造容错数据等等，此时就需要在 API 中带上 Stub，客户端生成 Proxy 实例，会把 Proxy 通过构造函数传给 Stub，然后把 Stub 暴露给用户，Stub 可以决定要不要去调 Proxy。

  • 服务提供者的接口包下创建：
import com.dx.site.SiteService;

public class SiteServiceStub implements SiteService {
    private final SiteService siteService;
    public SiteServiceStub(SiteService siteService) {
        this.siteService = siteService;
    }
    @Override
    public String siteName(String name) {
        try {
            return siteService.siteName(name);
        } catch (Exception e) {
            return "stub:"+name;
        }
    }
}
  • 服务消费者调⽤服务，开启本地存根
import com.dx.site.SiteService;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.ConfigurableApplicationContext;

@EnableAutoConfiguration
public class StubDubboConsumer {
    @Reference(version = "timeout", timeout = 1000, stub = "true")
    private SiteService siteService;
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(StubDubboConsumer.class);
        SiteService siteService = (SiteService)context.getBean(SiteService.class);
        String name = siteService.siteName("q-face");
        System.out.println(name);
    }
}

9、参数回调

参数回调方式与调用本地 callback 或 listener 相同，只需要在 Spring 的配置文件中声明哪个参数是 callback 类型即可。Dubbo 将基于长连接生成反向代理，这样就可以从服务器端调用客户端逻辑。
简而⾔之，就是服务端可以调用客户端的逻辑。

  • 接口层
public interface SiteService {
    //同步调⽤⽅法
    String siteName(String name);
    //回调⽅法
    default String siteName(String name, String key, SiteServiceListener siteServiceListener){
        return null;
    }
}
  • 服务提供者
import com.dx.site.SiteService;
import com.dx.site.SiteServiceListener;
import org.apache.dubbo.config.annotation.Argument;
import org.apache.dubbo.config.annotation.Method;
import org.apache.dubbo.config.annotation.Service;

@Service(version = "callback", methods = {@Method(name = "siteName", arguments = {@Argument(index = 2, callback = true)})}, callbacks = 3)
public class CallbackSiteServiceImpl implements SiteService {
    @Override
    public String siteName(String name) {
        return null;
    }
    @Override
    public String siteName(String name, String key, SiteServiceListener siteServiceListener) {
        siteServiceListener.changed("provider data");
        return "callback:"+name;
    }
}
  • 创建回调接口
public interface SiteServiceListener {
    void changed(String data);
}
  • 创建回调接口的实现类
import com.dx.site.SiteServiceListener;
import java.io.Serializable;

public class SiteServiceListenerImpl implements SiteServiceListener,
Serializable {
    @Override
    public void changed(String data) {
        System.out.println("changed:" + data);
    }
}
  • 创建服务消费者
import com.dx.site.SiteService;
import com.dx.site.SiteServiceListenerImpl;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.ConfigurableApplicationContext;

@EnableAutoConfiguration
public class CallbackDubboConsumer {
    @Reference(version = "callback")
    private SiteService siteService;
    public static void main(String[] args) {
        ConfigurableApplicationContext context =
            SpringApplication.run(CallbackDubboConsumer.class);
        SiteService siteService = (SiteService)context.getBean(SiteService.class);
        // key ⽬的是指明实现类在服务提供者和消费者之间保证是同⼀个
        System.out.println(siteService.siteName("q-face", "c1", new SiteServiceListenerImpl()));
        System.out.println(siteService.siteName("q-face", "c2", new SiteServiceListenerImpl()));
        System.out.println(siteService.siteName("q-face", "c3", new SiteServiceListenerImpl()));
    }
}

10、异步调用

从 2.7.0 开始，Dubbo 的所有异步编程接口开始以 CompletableFuture 为基础基于 NIO 的非阻塞实现并⾏调⽤，客户端不需要启动多线程即可完成并行调⽤多个远程服务，相对多线程开销较⼩。
简而⾔之，消费者通过异步调⽤，不⽤等待服务提供者返回结果就立即完成任务，待有结果后再执行之前设定好的监听逻辑。

  • 接口层
import java.util.concurrent.CompletableFuture;

public interface SiteService {
    //同步调⽤⽅法
    String siteName(String name);
    //回调⽅法
    default String siteName(String name, String key,SiteServiceListener siteServiceListener){
        return null;
    }
    //异步调⽤⽅法
    default CompletableFuture<String> siteNameAsync(String name){
        return null;
    }
}
  • 服务提供者
import com.dx.site.SiteService;
import org.apache.dubbo.config.annotation.Service;
import java.util.concurrent.CompletableFuture;

@Service(version = "async")
public class AsyncSiteServiceImpl implements SiteService {
    @Override
    public String siteName(String name) {
        return "async:" + name;
    }
    @Override
    public CompletableFuture<String> siteNameAsync(String name) {
        System.out.println("异步调⽤：" + name);
        return CompletableFuture.supplyAsync(() -> {
            return siteName(name);
        });
    }
}
  • 服务消费者
import com.dx.site.SiteService;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.ConfigurableApplicationContext;
import java.util.concurrent.CompletableFuture;

@EnableAutoConfiguration
public class AsyncDubboConsumer {
    @Reference(version = "async")
    private SiteService siteService;
    public static void main(String[] args) {
        ConfigurableApplicationContext context =
            SpringApplication.run(AsyncDubboConsumer.class);
        SiteService siteService = (SiteService)context.getBean(SiteService.class);
        //调⽤异步⽅法
        CompletableFuture<String> future =
            siteService.siteNameAsync("q-face");
        //设置监听，非阻塞
        future.whenComplete((v, e) -> {
            if (e != null) {
                e.printStackTrace();
            } else {
                System.out.println("result:" + v);
            }
        });
        System.out.println("异步调⽤结束");
    }
}

四、dubbo的负载均衡策略

1、负载均衡策略

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

  • 随机（默认的策略）:random
  • 轮询: roundrobin
  • 最小活跃调用数：leastactive
  • ⼀致性hash: consistenthash

2、dubbo中如何配置负载均衡策略

  • 服务提供者：
@Service(version = "default",loadbalance = "roundrobin")
public class DefaultSiteServiceImpl implements SiteService {
    @Override
    public String siteName(String name) {
        return "default:"+name;
    }
}
  • 服务消费者：如果两边都配置了负载均衡策略，则以消费者端为准。
@EnableAutoConfiguration
public class DefaultDubboConsumer {
    @Reference(version = "default", loadbalance = "roundrobin")
    private SiteService siteService;
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(DefaultDubboConsumer.class);
        SiteService siteService = (SiteService)context.getBean(SiteService.class);
        String name = siteService.siteName("q-face");
        System.out.println(name);
    }
}

五、安装Dubbo admin监管平台

1、zookeeper安装

下载解压，将conf下的zoo_sample.cfg复制一份改名为zoo.cfg，启动命令：./zkServer.sh start …/conf/zoo.cfg

2、dubbo安装

  1. 下载dubbo-admin
  2. 修改dubbo-admin配置：src\main\resources\application.properties 指定zookeeper地址
  3. 打包dubbo-admin：mvn clean package -Dmaven.test.skip=true
  4. 运行dubbo-admin：java -jar dubbo-admin-0.0.1-SNAPSHOT.jar

3、访问

http://127.0.0.1:7001

默认使用root/root 登陆

Agony_1314
关注
专栏目录
Dubbo详解，用心看这一篇文章就够了【重点】
sunnyday0426的博客
03-23 10万+
1.1 Dubbo概述 Dubbo是阿里巴巴开源的基于 Java 的高性能RPC（一种远程调用） 分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。 每天为2千多个服务提供大于30亿次访问量支持，并被广泛应用于阿里巴巴集团的各成员站点以及别的公司的业务中。 简单的说，Dubbo就是个服务框架，如果没有分布式的需求，其实是不需要用的，只有在分布式的时候，才有Dubbo这样的分布式服务框架的需求。 并且本质上是个远程服务调用的分布式框架（告别Web Service模式中的
dubbo示例代码dubbo-sample
08-05
【Dubbo 示例代码详解】 Dubbo 是阿里巴巴开源的一款高性能、轻量级的Java服务治理框架，它主要提供了RPC（远程过程调用）服务，并且包含了服务注册与发现、负载均衡、容错处理、监控等全面的服务治理功能。本示例...
Dubbo 技术学习指南：深度探索分布式服务框架的精髓
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
04-21 4万+
Dubbo技术栈深度广博，学习过程中应理论与实践相结合，通过动手搭建示例项目、参与真实项目开发，逐步将所学知识转化为实际生产力。随着对Dubbo理解的加深，您将能更好地驾驭这一强大的分布式服务框架，为构建高效、稳定、易维护的微服务体系打下坚实基础。
从理论到实践，必须了解的部分Dubbo配置
热门推荐
战斧的博客
07-21 8万+
前面我们学习了很多理论知识，但一切理论都是为了实践。Dubbo作为一个框架当然有很多配置点，其中有些配置不起眼，但却很重要。笔者曾经分享过一起内存溢出的问题，其中就有接口超时时间配置得太长的原因，因为数据量比较大，三方接口迟迟无法返回结果。而超时时间又很长，最终大量线程阻塞在调用上，资源无法释放，造成内存溢出。由此可见，合理的参数配置是多么的重要
dubbo：dubbo整合nacos实现服务注册中心、配置中心（二）
55555的博客
08-20 2030
之前我们讲解的是dubbo+zookeeper体系来实现微服务框架，但相对zookeeper很多企业在使用nacos, 并且nacos和dubbo都是阿里出品，所以具备一些天生的契合性，所以今天我们来讲解dubbo如何整合nacos实现服务注册、配置
Dubbo最核心功能——服务暴露的配置、使用及原理
战斧的博客
07-13 8640
今天开始，将正式的进入Dubbo 核心功能的掌握与学习，Dubbo的最核心功能是什么？自然是其RPC功能，而该功能其实分为三个方面：1.服务暴露2.服务引用3.服务调用三者分别专注于服务提供者、服务消费者、服务调用过程。服务暴露有几种？分别是怎么实现的？远程暴露支持什么？注册中心如果服务提供者宕机了，注册中心如何应对？
干翻Dubbo系列第三篇：Dubbo技术栈中核心术语与第一个Dubbo3应用程序
七叔的博客
07-10 1万+
本文是干翻Dubbo系列文章中的第三篇，在本篇中我们不仅仅对Dubbo技术栈中核心术语与做了详细的介绍，并编写了第一个基于Dubbo3应用程序！
Dubbo：常见的面试题和答案
木头
03-12 5553
Dubbo：常见的面试题和答案
Dubbo（从入门到掌握）看完这一篇就够了
西敏寺的乐章的博客
04-14 8521
Dubbo是阿里巴巴公司开源的一个高性能、轻量级的 Java RPC 框架。致力于提供高性能和透明化的 RPC 远程服务调用方案，以及 SOA 服务治理方案。
Dubbo目录
wang_luwei的博客
03-26 1568
一、[分布式基础理论]
dubbo捕获自定义异常_dubbo异常捕获_dubbo异常_自定义异常_捕捉异常_
10-01
在分布式服务框架 Dubbo 中，异常处理是必不可少的一部分。Dubbo 提供了强大的异常处理机制，使得服务提供者能够向消费者传递自定义异常，从而帮助消费者更好地理解和处理服务调用中的错误情况。本文将深入探讨如何...
swagger-dubbo：Dubbo的Swagger服务文档
02-03
随着dubbo的蓬勃发展，个人对这个项目又没有一点新的期待和想法（功能和架构上），目前开通了群聊频道，欢迎加入讨论： swagger-dubbo起一个解析Swagger和收集文档的作用 dubbo-swagger-doc是一个web应用，从注册...
Dubbo+Dubbo生产者，Dubbo消费者+Dubbo消费者调用生产者的服务的小demo
09-27
本项目需要安装Nacos,并启动Nacos,然后启动两个子项目，根据http:localhost/wife/clean,... @DubboService 这几个注解不能忘，否则会报错，或者达不到预计效果，对于此项目的部分ERROR如果不影响运行，则不需要要注意
dubbo开启TLS(ssl)源码
03-17
在分布式服务框架Dubbo中，TLS（Transport Layer Security）或SSL（Secure Sockets Layer）是用于保障网络通信安全的重要机制。本文将详细讲解如何在Dubbo中启用TLS，并结合Spring Boot和Nacos进行演示。 首先，...
Java中的远程方法调用——RPC详解
m0_53926113的博客
11-05 1058
Java中的远程方法调用（Remote Procedure Call，RPC）是一种允许一个程序调用另一台计算机上方法的技术，就像在本地一样。通过RPC，开发者不必关心网络传输、数据格式转换等细节，只需要按照调用本地方法的方式来调用远程方法。是一个轻量级的二进制协议，支持跨语言调用，适用于Java与其他语言间的通信。RMI是Java内置的RPC实现，它允许Java应用程序之间调用远程对象，类似于本地调用。使用RPC，客户端就可以像调用自己机器上的方法一样，远程调用服务器上提供的“获取用户信息”的方法。
游戏中Dubbo类的RPC设计时的注意要点
focus-unchanged-thing
11-05 207
1.需要使用到动态代理，代理指定的接口，这样子接口被调用时，就可以拿到："类名+ 方法名+参数+返回值" 这些类型。2.既然是rpc，那么接口被调用时，肯定在动态代理中会进行网络消息的发送，由于是远程调用，那么必然动态代理的proxy参数其实是用不到的，因为返回的话，是依赖于远程的服务提供者。3.阻塞，等待消息的返回，支持超时。
ThingsBoard规则链节点：RPC Call Reply节点详解
最新发布
国家专精特新小巨人、资深消防行业企业、国家高新技术企业、智慧消防技术实验室、准独角兽企业、浙江省电流AI技术研发中心
11-06 340
节点的主要作用是在规则链执行过程中回复远程过程调用（RPC）请求。通过节点，可以将处理结果发送回发起 RPC 请求的客户端或设备，实现双向通信和实时交互。这在设备控制、状态查询和命令执行中非常有用。节点在 ThingsBoard 规则链中是一个非常有用的工具，可以帮助回复远程过程调用（RPC）请求，实现实时交互和设备控制。通过合理地使用节点，可以更好地管理和自动化系统中的各种操作。无论是在智能家居、工业监控还是其他物联网应用中，节点都能发挥重要作用。
thrift rpc 四种类型的服务端的实现详细介绍
xl-9527 的博客
11-03 735
这里主要是使用 thrift 开发的时候服务器端的实现，以及 thrift 提供给我们多钟的服务的实现，以及每个实现的服务器的特点和 API 介绍，TServer主要包含以下几种实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值