Dubbo概述及实战

最新推荐文章于 2024-05-04 02:26:39 发布

淡画

最新推荐文章于 2024-05-04 02:26:39 发布

阅读量162

点赞数

分类专栏： rpc Java 文章标签： dubbo

本文链接：https://blog.csdn.net/wy491525030/article/details/119617907

版权

Java 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

rpc

1 篇文章 0 订阅

订阅专栏

1. Dubbo 架构概述

1.1 什么是Dubbo

Apache Dubbo是一款高性能的Java RPC框架。其前身是阿里巴巴公司开源的一个高性能、轻量级的开源Java RPC框架，可以和Spring框架无缝集成。

1.2 Dubbo 处理流程

在这里插入图片描述

调用关系说明:

虚线
代表异步调用
实线
代表同步访问
蓝色虚线
是在启动时完成的功能
红色虚线
是程序运行中执行的功能

调用流程:

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

1.3. 服务注册中心Zookeeper

通过前面的Dubbo架构图可以看到，Registry（服务注册中心）在其中起着至关重要的作用。Dubbo官方推荐使用Zookeeper作为服务注册中心.Zookeeper 是 Apache Hadoop 的子项目，作为 Dubbo 服务的注册中心，工业强度较高，可用于生产环境，并推荐使用。

1.4. Dubbo开发实战

1.4.1 实战案例介绍

在Dubbo中所有的的服务调用都是基于接口去进行双方交互的。双方协定好Dubbo调用中的接口，提供者来提供实现类并且注册到注册中心上。
调用方则只需要引入该接口，并且同样注册到相同的注册中心上(消费者)。即可利用注册中心来实现集群感知功能，之后消费者即可对提供者进行调用。

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

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

1.4.2 开发过程

接口协定

创建api模块。定义接口，这里为了方便，只是写一个基本的方法。

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

创建接口提供者

引入上述api模块。

<dependency> 
	 <groupId>com.lagou</groupId>
	 <artifactId>service-api</artifactId> 
	 <version>${project.version}</version>
  </dependency>

引入Dubbo相关依赖

<dependency> 
	 <groupId>org.apache.dubbo</groupId>
	 <artifactId>dubbo</artifactId> 
 </dependency>
 <dependency> 
	  <groupId>org.apache.dubbo</groupId>
	 <artifactId>dubbo-registry-zookeeper</artifactId> 
 </dependency>

编写实现类。注意这里也使用了Dubbo中的 @Service 注解来声明他是一个服务的提供者。

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

编写配置文件，用于配置dubbo。比如这里我就叫 dubbo-provider.properties ，放入到resources 目录下。

#当前提供者的名称
dubbo.application.name=dubbo-demo-annotation-provider 
#对外提供的时候使用的协议
dubbo.protocol.name=dubbo 
#对外暴露的端口
dubbo.protocol.port=20880

编写启动的 main 函数。这里面做的比较简单，主要要注意注解方式中的注册中心这里是使用的本机2181端口来作为注册中心。

public class DubboPureMain { 
	public static void main(String[] args) throws Exception { 			
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProviderConfiguration.class); context.start(); 			
		System.in.read(); 
	}
	@Configuration
	@EnableDubbo(scanBasePackages = "com.lagou.service.impl")
	@PropertySource("classpath:/dubbo-provider.properties") 
	static class ProviderConfiguration { 
		@Bean 
		public RegistryConfig registryConfig() { 
			RegistryConfig registryConfig = new RegistryConfig();
			registryConfig.setAddress("zookeeper://127.0.0.1:2181");
			return registryConfig; 
		}
	} 
}

创建消费者

引入API模块

<dependency> 
	<groupId>com.lagou</groupId> 
	<artifactId>service-api</artifactId> 
	<version>${project.version}</version>
 </dependency>

引入Dubbo依赖 ,同服务提供者
编写服务，用于真实的引用dubbo接口并使用。因为这里是示例，所以比较简单一些。这里面@Reference 中所指向的就是真实的第三方服务接口。

@Component 
public class ConsumerComponent { 
	@Reference 
	private HelloService helloService; 
	public String sayHello(String name) { 
		return helloService.sayHello(name); 
	} 
}

编写消费者的配置文件。这里比较简单，主要就是指定了当前消费者的名称和注册中心的位置。通过这个注册中心地址，消费者就会注册到这里并且也可以根据这个注册中心找到真正的提供者列表。

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

编写启动类，这其中就会当用户在控制台输入了一次换行后，则会发起一次请求。

	public class AnnotationConsumerMain { 
		public static void main(String[] args) throws IOException, InterruptedException { 
			AnnotationConfigApplicationContext context = new
			AnnotationConfigApplicationContext(ConsumerConfiguration.class); 
			context.start(); 
			ConsumerComponent service = context.getBean(ConsumerComponent.class); 
			while (true) { 
			System.in.read(); 
			try {
					String hello = service.sayHello("world"); 
					System.out.println("result :" + hello); 
				} catch (Exception e) {
					 e.printStackTrace();
			 		}
				} 
			}
		@Configuration 
		@EnableDubbo(scanBasePackages = "com.lagou.service") 
		@PropertySource("classpath:/dubbo-consumer.properties") 
		@ComponentScan(value = {"com.lagou.bean.consumer"}) 
		static class ConsumerConfiguration {
		 } 
	 }

1.4.3 配置方式介绍

注解: 基于注解可以快速的将程序配置，无需多余的配置信息，包含提供者和消费者。但是这种方式有一个弊端，有些时候配置信息并不是特别好找，无法快速定位。
XML: 一般这种方式我们会和Spring做结合，相关的Service和Reference均使用Spring集成后的。通过这样的方式可以很方便的通过几个文件进行管理整个集群配置。可以快速定位也可以快速更改。
基于代码方式: 基于代码方式的对上述配置进行配置。这个使用的比较少，这种方式更适用于自己公司对其框架与Dubbo做深度集成时才会使用。

1.4.4 XML方式

我们一般XML会结合Spring应用去进行使用，将Service的注册和引用方式都交给Spring去管理。下面我们还是针对于上面的demo进行实现。

api模块

使用原先的接口。

provider模块

引入api依赖

<dependency> 
	<groupId>com.lagou</groupId> 
	<artifactId>service-api</artifactId> 
	<version>${project.version}</version> 
</dependency>

引入dubbo依赖。与原先的不同点在于，最后多了spring的依赖引入

<dependency> 
	 <groupId>org.apache.dubbo</groupId>
	 <artifactId>dubbo</artifactId> 
 </dependency> 
 <dependency> 
	 <groupId>org.apache.dubbo</groupId> 
	 <artifactId>dubbo-registry-zookeeper</artifactId>
 </dependency>
 <dependency> 
   <groupId>org.apache.dubbo</groupId> 
   <artifactId>dubbo-registry-nacos</artifactId>
</dependency> 
<dependency> 
	<groupId>org.apache.dubbo</groupId> 
	<artifactId>dubbo-rpc-dubbo</artifactId> 
</dependency> 
<dependency> 
	<groupId>org.apache.dubbo</groupId> 
	<artifactId>dubbo-remoting-netty4</artifactId> 
</dependency> 
<dependency> 
	<groupId>org.apache.dubbo</groupId>
	 <artifactId>dubbo-serialization-hessian2</artifactId> 
 </dependency> 
 <dependency> 
	 <groupId>org.apache.dubbo</groupId> 
	 <artifactId>dubbo-config-spring</artifactId> 
 </dependency>

编写实现类，不需要引入任何的注解配置

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

编写 dubbo-provider.xml 文件，用于对dubbo进行文件统一配置。并且对刚才的配置进行引入。

<?xml version="1.0" encoding="UTF-8"?> <beans 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:dubbo="http://dubbo.apache.org/schema/dubbo" 
xmlns="http://www.springframework.org/schema/beans" 
xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd 
http://dubbo.apache.org/schema/dubbo 
http://dubbo.apache.org/schema/dubbo/dubbo.xsd"> 
	<dubbo:application name="dubbo-demo-annotation-provider"/> 
	<dubbo:registry address="zookeeper://127.0.0.1:2181"/> 
	<dubbo:protocol name="dubbo"/> 
	<bean id="helloService" class="com.lagou.service.impl.HelloServiceImpl"/>
 	<dubbo:service interface="com.lagou.service.HelloService" ref="helloService"/> </beans>

编写模块启动类。

public class ProviderApplication { 
public static void main(String[] args) throws Exception { 
		ClassPathXmlApplicationContext context = new
			ClassPathXmlApplicationContext("spring-*.xml"); 
		context.start(); 
		System.in.read(); 
	} 
}

consumer模块

引入api模块。

<dependency> 
	<groupId>com.lagou</groupId> 
	<artifactId>service-api</artifactId> 
	<version>${project.version}</version> 
</dependency>

引入dubbo相关。

<dependency> 
	 <groupId>org.apache.dubbo</groupId>
	 <artifactId>dubbo</artifactId> 
 </dependency> 
 <dependency> 
	 <groupId>org.apache.dubbo</groupId> 
	 <artifactId>dubbo-registry-zookeeper</artifactId>
 </dependency>
 <dependency> 
   <groupId>org.apache.dubbo</groupId> 
   <artifactId>dubbo-registry-nacos</artifactId>
</dependency> 
<dependency> 
	<groupId>org.apache.dubbo</groupId> 
	<artifactId>dubbo-rpc-dubbo</artifactId> 
</dependency> 
<dependency> 
	<groupId>org.apache.dubbo</groupId> 
	<artifactId>dubbo-remoting-netty4</artifactId> 
</dependency> 
<dependency> 
	<groupId>org.apache.dubbo</groupId>
	 <artifactId>dubbo-serialization-hessian2</artifactId> 
 </dependency> 
 <dependency> 
	 <groupId>org.apache.dubbo</groupId> 
	 <artifactId>dubbo-config-spring</artifactId> 
 </dependency>

定义spring的配置xml

<?xml version="1.0" encoding="UTF-8"?> <beans 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:dubbo="http://dubbo.apache.org/schema/dubbo" 
xmlns="http://www.springframework.org/schema/beans" 
xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd 
http://dubbo.apache.org/schema/dubbo 
http://dubbo.apache.org/schema/dubbo/dubbo.xsd"> 
	<dubbo:application name="demo-consumer"/> 
	<dubbo:registry address="zookeeper://127.0.0.1:2181"/> 
	<dubbo:reference id="helloService" interface="com.lagou.service.HelloService"> 
	</dubbo:reference>
</beans>

引入启动模块。因为引用了Spring框架，所以再上一步的helloService会被当做一个bean注入到真实的环境中。在我们生产级别使用的时候，我们可以通过Spring中的包扫描机制，通过@Autowired 这种机制来进行依赖注入

public class XMLConsumerMain { 
	public static void main(String[] args) throws Exception { 
		ClassPathXmlApplicationContext context = new
			ClassPathXmlApplicationContext("spring/dubbo-consumer.xml"); 
		context.start(); 
		HelloService demoService = context.getBean(HelloService.class); 
		System.out.println(demoService.sayHello("world")); 
	} 
}

1.5.Dubbo配置项说明

dubbo:application
对应 org.apache.dubbo.config.ApplicationConfig, 代表当前应用的信息

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

dubbo:registry
org.apache.dubbo.config.RegistryConfig, 代表该模块所使用的注册中心。一个模块中的服务可以将其注册到多个注册中心上，也可以注册到一个上。后面再service和reference也会引入这个注册中心。

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

dubbo:protocol
org.apache.dubbo.config.ProtocolConfig, 指定服务在进行数据传输所使用的协议。

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

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

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

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

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

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

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

dubbo:service和dubbo:reference详解
这两个在dubbo中是我们最为常用的部分，其中有一些我们必然会接触到的属性。并且这里会讲到一些设置上的使用方案。

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

2. Dubbo高级实战

2.1 SPI

2.1.1 SPI简介

SPI 全称为 (Service Provider Interface) ，是JDK内置的一种服务提供发现机制。目前有不少框架用它来做服务的扩展发现，简单来说，它就是一种动态替换发现的机制。使用SPI机制的优势是实现解耦，使得第三方服务模块的装配控制逻辑与调用者的业务代码分离。

2.1.2 JDK中的SPI

在这里插入图片描述
Java中如果想要使用SPI功能，先提供标准服务接口，然后再提供相关接口实现和调用者。这样就可以通过SPI机制中约定好的信息进行查询相应的接口实现。
SPI遵循如下约定：
1、当服务提供者提供了接口的一种具体实现后，在META-INF/services目录下创建一个以“接口全
限定名”为命名的文件，内容为实现类的全限定名；
2、接口实现类所在的jar包放在主程序的classpath中；
3、主程序通过java.util.ServiceLoader动态装载实现模块，它通过扫描META-INF/services目录下的配置文件找到实现类的全限定名，把类加载到JVM； 4、SPI的实现类必须携带一个无参构造方法；

2.1.3 Dubbo中的SPI

dubbo中大量的使用了SPI来作为扩展点，通过实现同一接口的前提下，可以进行定制自己的实现类。
比如比较常见的协议，负载均衡，都可以通过SPI的方式进行定制化，自己扩展。Dubbo中已经存在的所有已经实现好的扩展点。

2.1.4 Dubbo中扩展点使用方式

我们使用三个项目来演示Dubbo中扩展点的使用方式，一个主项目main，一个服务接口项目api，一个服务实现项目impl。

api项目创建
（1）导入坐标 dubbo
（2）创建接口
在接口上使用@SPI

impl项目创建
（1）导入 api项目的依赖
（2）建立实现类，为了表达支持多个实现的目的，这里分别创建两个实现。分别为HumanHelloService 和 DogHelloService 。
（3）SPI进行声明操作，在 resources 目录下创建目录 META-INF/dubbo 目录，在目录下创建名称为com.lagou.dubbo.study.spi.demo.api.HelloService的文件，文件内部配置两个实现类名称和对应的全限定名：

human=com.lagou.service.impl.HumanHelloService 
dog=com.lagou.service.impl.DogHelloService

main项目创建
（1）导入坐标接口项目和实现类项目
（2）创建DubboSpiMain和原先调用的方式不太相同， dubbo 有对其进行自我重新实现需要借助ExtensionLoader，创建新的运行项目。这里demo中的示例和java中的功能相同，查询出所有的已知实现，并且调用
（3）dubbo自己做SPI的目的

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

2.1.5 Dubbo调用时拦截操作

与很多框架一样，Dubbo也存在拦截（过滤）机制，可以通过该机制在执行目标程序前后执行我们指定的代码。
Dubbo的Filter机制，是专门为服务提供方和服务消费方调用过程进行拦截设计的，每次远程方法执行，该拦截都会被执行。这样就为开发者提供了非常方便的扩展性，比如为dubbo接口实现ip白名单功能、监控功能、日志记录等。
步骤如下：
（1）实现 org.apache.dubbo.rpc.Filter 接口
（2）使用 org.apache.dubbo.common.extension.Activate 接口进行对类进行注册通过group 可以指定生产端消费端如:

@Activate(group = {CommonConstants.CONSUMER)

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

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

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

timerFilter=包名.过滤器的名字

注意：一般类似于这样的功能都是单独开发依赖的，所以再使用方的项目中只需要引入依赖，在调用接
口时，该方法便会自动拦截。

2.2 负载均衡策略

2.2.1 负载均衡基本配置

负载均衡（Load Balance）, 其实就是将请求分摊到多个操作单元上进行执行，从而共同完成工作任务。
负载均衡策略主要用于客户端存在多个提供者时进行选择某个提供者。
在集群负载均衡时，Dubbo 提供了多种均衡策略（包括随机、轮询、最少活跃调用数、一致性Hash），缺省为random随机调用。

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

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

2.3 异步调用

Dubbo不只提供了堵塞式的的同步调用，同时提供了异步调用的方式。这种方式主要应用于提供者接口响应耗时明显，消费者端可以利用调用接口的时间去做一些其他的接口调用,利用 Future 模式来异步等待和获取结果即可。这种方式可以大大的提升消费者端的利用率。目前这种方式可以通过XML的方式进行引入。
3.1 异步调用实现
（1）为了能够模拟等待，通过 int timeToWait参数，标明需要休眠多少毫秒后才会进行返回。

	String sayHello(String name, int timeToWait);

（2）接口实现为了模拟调用耗时可以让线程等待一段时间
（3）在消费者端，配置异步调用注意消费端默认超时时间1000毫秒如果提供端耗时大于1000毫秒会出现超时
可以通过改变消费端的超时时间通过timeout属性设置即可单位毫秒

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

（4）测试，我们休眠100毫秒，然后再去进行获取结果。方法在同步调用时的返回值是空，我们可以通过 RpcContext.getContext().getFuture() 来进行获取Future对象来进行后续的结果等待操作。

2.4 线程池

2.4.1 Dubbo已有线程池

dubbo在使用时，都是通过创建真实的业务线程池进行操作的。目前已知的线程池模型有两个和java中的相互对应:

fix: 表示创建固定大小的线程池。也是Dubbo默认的使用方式，默认创建的执行线程数为200，并且是没有任何等待队列的。所以再极端的情况下可能会存在问题，比如某个操作大量执行时，可能存在堵塞的情况。后面也会讲相关的处理办法。
cache: 创建非固定大小的线程池，当线程不足时，会自动创建新的线程。但是使用这种的时候需要注意，如果突然有高TPS的请求过来，方法没有及时完成，则会造成大量的线程创建，对系统的CPU和负载都是压力，执行越多反而会拖慢整个系统。

2.5 路由规则

2.5.1 路由规则示例

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

2.5.2 路由规则详解

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

2.6 服务动态降级

2.6.1 什么是服务降级

服务降级，当服务器压力剧增的情况下，根据当前业务情况及流量对一些服务有策略的降低服务级别，以释放服务器资源，保证核心任务的正常运行。

2.6.2 为什么要服务降级

为什么要使用服务降级，这是防止分布式服务发生雪崩效应，什么是雪崩？就是蝴蝶效应，当一个请求发生超时，一直等待着服务响应，那么在高并发情况下，很多请求都是因为这样一直等着响应，直到服务资源耗尽产生宕机，而宕机之后会导致分布式其他服务调用该宕机的服务也会出现资源耗尽宕机，这样下去将导致整个分布式服务都瘫痪，这就是雪崩。

2.6.3 dubbo 服务降级实现

xml形式

<dubbo:reference id="xxService" check="false" interface="com.xx.XxService" timeout="3000" mock="return null" /> 
<dubbo:reference id="xxService2" check="false" interface="com.xx.XxService2" timeout="3000" mock="return 1234" />

注解形式
@Reference(mock=“return null”)
@Reference(mock=“return 简单值”)
@Reference(mock=“force:return null”) 等。

淡画

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Dubbo概述及实战

1. Dubbo 架构概述1.1 什么是DubboApache Dubbo是一款高性能的Java RPC框架。其前身是阿里巴巴公司开源的一个高性能、轻量级的开源Java RPC框架，可以和Spring框架无缝集成。1.2 Dubbo 处理流程调用关系说明:虚线代表异步调用实线代表同步访问蓝色虚线是在启动时完成的功能红色虚线是程序运行中执行的功能调用流程:服务提供者在服务容器启动时向注册中心注册自己提供的服务服务消费者在启动时向注册中心订阅自己所需的服务
复制链接

扫一扫