Dubbo

官方文档：

Java SDK 手册 | Apache Dubbo

一  RPC及Dubbo 

1  什么是RPC 

dubbo是⼀款⾼性能的rpc框架。什么是rpc呢？ 
rpc是⼀种协议：是⼀种远程过程调⽤（remote procudure call）协议 
rpc协议是在应⽤层之上的协议，规定了通信双⽅进⾏通信的数据格式是什么样的，及数据如何传输：
指明调⽤的类或接口
指明调⽤的⽅法及参数

两个服务之间通信，需要指定好消息的传输格式，像http请求，他规定了信息传输要指定请求头，请求行，请求体等。这就是rpc需要做的事

2  什么是dubbo

Apache Dubbo 是⼀款⾼性能、轻量级的开源服务框架。Apache Dubbo |ˈdʌbəʊ| 提供了六⼤核⼼能力：

⾯向接⼝代理的⾼性能RPC调⽤，

智能容错

和负载均衡，

服务⾃动注册和发现，

⾼度可扩展能⼒，

运⾏期流量调度，

可视化的服务治理与运维。

我们主要学rpc和lb

3  dubbo怎么实现远程通信？

这个图展示了一个基于Dubbo框架的服务调用流程，Dubbo是一个高性能的Java RPC（远程过程调用）框架。下面是根据图中的流程描述的Dubbo工作流程：

1. **服务提供者（服务提供者）**：
   - 服务提供者需要实现服务接口，并注册到注册中心。
   - 服务提供者启动时，会暴露服务（启动Tomcat、Jetty等服务器），并将其服务接口、实现类、服务地址及端口等注册信息发送到注册中心。

2. **注册中心（注册中心）**：
   - 注册中心负责保存服务名与服务地址的映射关系。
   - 当服务提供者注册服务后，注册中心会存储这些信息，并在服务提供者地址变更时主动通知消费者。

3. **服务消费者（服务消费者）**：
   - 服务消费者在启动时，会从注册中心获取服务地址列表。
   - 服务消费者将这些地址信息缓存在本地，以便进行远程调用。
   - 服务消费者通过负载均衡策略选择一个服务提供者进行调用。

4. **远程调用**：
   - 服务消费者使用指定的参数（接口名、方法名、方法参数类型列表、参数值列表）进行远程调用。
   - 这个调用过程对服务消费者来说是透明的，就像调用本地方法一样。

5. **监控中心（监控中心）**：
   - 监控中心负责对服务的监控及治理。
   - 服务提供者和消费者都会向监控中心发送监控数据，监控中心可以对这些数据进行分析，以便于服务的维护和管理。

整个流程中，注册中心起到了服务发现的作用，使得服务消费者能够动态地发现服务提供者。服务消费者通过负载均衡策略选择服务提供者，可以提高系统的可用性和扩展性。监控中心则提供了服务的监控和治理功能，帮助维护服务的稳定性。

4  具体代码实现远程通信

从上面图的逻辑，远程通信主要有三部分组成：服务消费者，服务提供者，服务本身。

服务

简单地模拟了一个服务，创建了一个结构和他的实现类。里面接受一个字符串参数a，然后返回一个  “hello” + a  的字符串

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

服务提供者

服务提供者实现了：

1  服务提供者需要实现服务接口，并注册到注册中心。
2  服务提供者启动时，会暴露服务（启动Tomcat、Jetty等服务器）

3  并将其服务接口、实现类、服务地址及端口等注册信息发送到注册中心。

我们下面逐一分析

public class Provider {public static void main(String[] args) {//封装服务提供者地址URL url = new URL("localhost",8080);//模拟远程注册中心//将服务和地址关联起来RemoteMapRegister.regist(HelloService.class.getName(), url);//指明服务的实现类LocalRegister.regist(HelloService.class.getName(), HelloServiceImpl.class);//指定远程调用协议, 这里是http请求Protocol protocol = ProtocolFactory.getProtocol();// 开启接收请求protocol.start(url);}
}

需求1  服务提供者需要实现服务接口，并注册到注册中心  并将注册信息发送到注册中心

首先提供者封装了服务的url，然后，将服务和地址注册到注册中心

    //封装服务提供者地址URL url = new URL("localhost",8080);//模拟远程注册中心//将服务和地址关联起来RemoteMapRegister.regist(HelloService.class.getName(), url);

服务中心的具体代码,由于我们为了讲解功能的实现，就不使用框架，也就是先不使用zookepper来实现注册中心

这里面的map----REGISTER，是储存服务名字和服务地址的映射。 

还有注册方法regist，就是将服务名字和服务地址映射起来

得到注册信息get，得到将服务名字和服务地址的映射

注册到文件中，实现持久化saveFile

得到注册信息getFile

public class RemoteMapRegister {private static Map<String, List<URL>> REGISTER = new HashMap<>();public static void regist(String interfaceName, URL url){List<URL> list = REGISTER.get(interfaceName);if (list == null) {list = new ArrayList<>();}list.add(url);REGISTER.put(interfaceName, list);//saveFile实现REGISTER在provider和consumer之间共享saveFile();}public static List<URL> get(String interfaceName) {REGISTER = getFile();List<URL> list = REGISTER.get(interfaceName);return list;}private static void saveFile() {try {FileOutputStream fileOutputStream = new FileOutputStream("classpath:register.txt");ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);objectOutputStream.writeObject(REGISTER);} catch (IOException e) {e.printStackTrace();}}private static Map<String, List<URL>> getFile() {try {FileInputStream fileInputStream = new FileInputStream("classpath:register.txt");ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);return (Map<String, List<URL>>) objectInputStream.readObject();} catch (IOException | ClassNotFoundException e) {e.printStackTrace();}return null;}
}

需求2  创建服务接口、实现类的关联

    //指明服务的实现类LocalRegister.regist(HelloService.class.getName(), HelloServiceImpl.class);

创建一个类封装服务接口、实现类的关联。

有存储关联的Map-----map 

有创建关联的regist

有得到关联的get

public class LocalRegister {private static Map<String, Class> map = new HashMap<>();public static void regist(String interfaceName, Class implClass) {map.put(interfaceName, implClass);}public static Class get(String interfaceName) {return map.get(interfaceName);}
}

需求3  服务提供者启动时，会暴露服务（启动Tomcat、Jetty等服务器）

    //指定远程调用协议, 这里是http请求Protocol protocol = ProtocolFactory.getProtocol();// 开启接收请求protocol.start(url);

首先我们会先设置请求是什么协议的

会创建一个类来提取协议名字然后创建对应的协议类。（都是自己封装的）

假如要http协议

public class ProtocolFactory {public static Protocol getProtocol() {//vm options：-DprotocolName=dubboString name = System.getProperty("protocolName");if (name == null || name.equals("")) name = "http";switch (name) {case "http":return new HttpProtocol();case "dubbo":return new DubboProtocol();default:break;}return new HttpProtocol();}
}

调用start方法，最终会start封装好的Tomcat，由于tomcat内配置了DispatcherServlet，他会拦截一切请求。也就是将服务暴露了之后交由DispatcherServlet处理相应逻辑

public class HttpServer {public void start(String hostname, Integer port) {Tomcat tomcat = new Tomcat();Server server = tomcat.getServer();Service service = server.findService("Tomcat");Connector connector = new Connector();connector.setPort(port);Engine engine = new StandardEngine();engine.setDefaultHost(hostname);Host host = new StandardHost();host.setName(hostname);String contextPath = "";Context context = new StandardContext();context.setPath(contextPath);context.addLifecycleListener(new Tomcat.FixContextListener());host.addChild(context);engine.addChild(host);service.setContainer(engine);service.addConnector(connector);tomcat.addServlet(contextPath, "dispatcher", new DispatcherServlet());context.addServletMappingDecoded("/*", "dispatcher");try {tomcat.start();tomcat.getServer().await();} catch (LifecycleException e) {e.printStackTrace();}}
}

DispatcherServlet拦截请求，并通过传进来的参数用反射调用服务的方法，最终实现远程调用服务

public class DispatcherServlet extends HttpServlet {@Overrideprotected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {new HttpServerHandler().handler(req, resp);}
}public class HttpServerHandler {public void handler(HttpServletRequest req, HttpServletResponse resp) {try {ObjectInputStream ois = new ObjectInputStream(req.getInputStream());Invocation invocation = (Invocation)ois.readObject();String interfaceName = invocation.getInterfaceName();//HelloServiceClass implClass = LocalRegister.get(interfaceName);//HelloServiceImpl.hello(String name)Method method = implClass.getMethod(invocation.getMethodName(), invocation.getParamTypes());String result = (String) method.invoke(implClass.newInstance(), invocation.getParams());//HelloServiceImpl.hello(String name)System.out.println("tomcat:" + result);IOUtils.write(result.getBytes(), resp.getOutputStream());//写回给服务的消费者} catch (Exception e) {e.printStackTrace();}}
}

服务消费者

主要代码：

通过代理实现相应逻辑

public class Consumer {public static void main(String[] args) {HelloService helloService = ProxyFactory.getProxy(HelloService.class);String name = helloService.hello("qf");System.out.println(name);}
}

需求1 ： 服务消费者在启动时，会从注册中心获取服务地址列表。服务消费者将这些地址信息缓存在本地，以便进行远程调用  服务消费者通过负载均衡策略选择一个服务提供者进行调用。

首先会得到服务名字，服务方法名字，参数。

然后通过服务名字在注册中心得到请求的url

之后用过负载均衡实现请求

public class ProxyFactory<T> {@SuppressWarnings("unchecked")public static <T> T getProxy(final Class interfaceClass) {return (T)Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class[]{interfaceClass}, new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//Invocation封装的是这一次远程过程调用所需要的所有的参数Invocation invocation = new Invocation(interfaceClass.getName(),method.getName(), method.getParameterTypes(), args);//去注册中心获得服务地址列表List<URL> urlList = RemoteMapRegister.get(interfaceClass.getName());//负载均衡URL url = LoadBalance.random(urlList);Protocol protocol = ProtocolFactory.getProtocol();String result = protocol.send(url, invocation);return result;}});}
}

需求2： 服务消费者使用指定的参数（接口名、方法名、方法参数类型列表、参数值列表）进行远程调用  这个调用过程对服务消费者来说是透明的，就像调用本地方法一样。

封装url和参数调用send方法，send方法通过io流，得到结果并返回

//调用send方法
String result = protocol.send(url, invocation);//send方法的实现
public class HttpClient {public String send(String hostname, Integer port, Invocation invocation) {try {URL url = new URL("http", hostname, port, "/");HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();httpURLConnection.setRequestMethod("POST");httpURLConnection.setDoOutput(true);OutputStream outputStream = httpURLConnection.getOutputStream();ObjectOutputStream oos = new ObjectOutputStream(outputStream);oos.writeObject(invocation);oos.flush();oos.close();InputStream inputStream = httpURLConnection.getInputStream();String result = IOUtils.toString(inputStream);return result;} catch (Exception e) {e.printStackTrace();}return null;}
}

5  dubbo内部结构

二  快速入门

使用springboot整合dubbo

1  服务

在父工程下创建一个maven，下面定义一个接口，作为服务

2  服务提供者

2.1  引入依赖

我们用的是jdk1.8  boot版本2.3.7

以及引入了dubbo-spring-boot-starter,  dubbo-registry-zookeeper

<?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>com.qf</groupId><artifactId>my-boot-service-provider</artifactId><version>0.0.1-SNAPSHOT</version><name>my-boot-service-provider</name><description>Demo project for Spring Boot</description><properties><java.version>1.8</java.version><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><spring-boot.version>2.3.7.RELEASE</spring-boot.version></properties><dependencies><dependency><groupId>com.qf</groupId><artifactId>my-boot-qf-interfaces</artifactId><version>1.0-SNAPSHOT</version></dependency><!-- Dubbo Spring Boot Starter --><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-spring-boot-starter</artifactId><version>2.7.3</version></dependency><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-registry-zookeeper</artifactId><version>2.7.3</version><exclusions><exclusion><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId></exclusion></exclusions></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope><exclusions><exclusion><groupId>org.junit.vintage</groupId><artifactId>junit-vintage-engine</artifactId></exclusion></exclusions></dependency></dependencies><dependencyManagement><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-dependencies</artifactId><version>${spring-boot.version}</version><type>pom</type><scope>import</scope></dependency></dependencies></dependencyManagement><build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.8.1</version><configuration><source>1.8</source><target>1.8</target><encoding>UTF-8</encoding></configuration></plugin><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><version>2.3.7.RELEASE</version><configuration><mainClass>com.qf.my.boot.service.provider.MyBootServiceProviderApplication</mainClass></configuration><executions><execution><id>repackage</id><goals><goal>repackage</goal></goals></execution></executions></plugin></plugins></build></project>

2.2  编写配置文件

server:port: 9001
dubbo:application:name: site-service-boot-providerregistry:address: zookeeper://ip:2181protocol:name: dubboport: 20882

2.3  开启@EnableDubbo注解

在启动类上添加，也可以自己编写配置类添加

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

2.4  提供服务实现类

注意这里的@Service是dubbo的，不是spring的，在2.7.7dubbo版本之后会改成@DubboService

来区分。我这里请注意版本

import com.qf.boot.api.SiteService;
import org.apache.dubbo.config.annotation.Service;/*** @author Thor* @公众号 Java架构栈*/
@Service
public class SiteServiceImpl implements SiteService {@Overridepublic String getName(String name) {return "hello boot:" + name;}
}

3  服务消费者

3.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 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.qf</groupId><artifactId>my-boot-service-consumer</artifactId><version>0.0.1-SNAPSHOT</version><name>my-boot-service-consumer</name><description>Demo project for Spring Boot</description><properties><java.version>1.8</java.version><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><spring-boot.version>2.3.7.RELEASE</spring-boot.version></properties><dependencies><dependency><groupId>com.qf</groupId><artifactId>my-boot-qf-interfaces</artifactId><version>1.0-SNAPSHOT</version></dependency><!-- Dubbo Spring Boot Starter --><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-spring-boot-starter</artifactId><version>2.7.3</version></dependency><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-registry-zookeeper</artifactId><version>2.7.3</version><exclusions><exclusion><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId></exclusion></exclusions></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope><exclusions><exclusion><groupId>org.junit.vintage</groupId><artifactId>junit-vintage-engine</artifactId></exclusion></exclusions></dependency></dependencies><dependencyManagement><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-dependencies</artifactId><version>${spring-boot.version}</version><type>pom</type><scope>import</scope></dependency></dependencies></dependencyManagement><build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.8.1</version><configuration><source>1.8</source><target>1.8</target><encoding>UTF-8</encoding></configuration></plugin><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><version>2.3.7.RELEASE</version><configuration><mainClass>com.qf.my.boot.service.consumer.MyBootServiceConsumerApplication</mainClass></configuration><executions><execution><id>repackage</id><goals><goal>repackage</goal></goals></execution></executions></plugin></plugins></build></project>

3.2  配置文件

server:port: 8001
dubbo:application:name: site-service-boot-consumer# 监听，订阅的地址registry:address: zookeeper://ip:2181

3.3  消费逻辑

编写一个controller

注意！！！

这里的@Reference也是dubbo包下的

@RestController
@RequestMapping("/site")
public class SiteController {//<dubbo:reference : 两件事情：1.服务启动时向注册中心订阅SiteService服务地址列表 2.生成SiteService服务的代理对象@Referenceprivate SiteService siteService;@GetMapping("/name")public String getName(String name){return siteService.getName(name);}}

3.4  加上@EnableDubbo注解

在启动类上

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

4  测试启动

成功

三  dubbo⽤法示例

0  先决条件

服务

首先要有服务，这里定义了一些类，具体逻辑不关心，重点在实现类

服务提供者

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 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.qf</groupId><artifactId>my-dubbo-provider</artifactId><version>0.0.1-SNAPSHOT</version><name>my-dubbo-provider</name><description>Demo project for Spring Boot</description><properties><java.version>1.8</java.version><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><spring-boot.version>2.3.7.RELEASE</spring-boot.version></properties><dependencies><!-- Dubbo Spring Boot Starter --><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-spring-boot-starter</artifactId><version>2.7.3</version></dependency><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-registry-zookeeper</artifactId><version>2.7.3</version><exclusions><exclusion><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId></exclusion></exclusions></dependency><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-rpc-http</artifactId><version>2.7.3</version></dependency><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-metadata-report-zookeeper</artifactId><version>2.7.3</version></dependency><!-- Dubbo rest protocol --><dependency><groupId>org.jboss.resteasy</groupId><artifactId>resteasy-jaxrs</artifactId><version>3.0.19.Final</version></dependency><dependency><groupId>javax.validation</groupId><artifactId>validation-api</artifactId><version>1.1.0.Final</version></dependency><dependency><groupId>com.qf.dubbo</groupId><artifactId>my-dubbo-interfaces</artifactId><version>1.0-SNAPSHOT</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope><exclusions><exclusion><groupId>org.junit.vintage</groupId><artifactId>junit-vintage-engine</artifactId></exclusion></exclusions></dependency></dependencies><dependencyManagement><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-dependencies</artifactId><version>${spring-boot.version}</version><type>pom</type><scope>import</scope></dependency></dependencies></dependencyManagement><build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.8.1</version><configuration><source>1.8</source><target>1.8</target><encoding>UTF-8</encoding></configuration></plugin><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><version>2.3.7.RELEASE</version><configuration><mainClass>com.qf.my.dubbo.provider.MyDubboProviderApplication</mainClass></configuration><executions><execution><id>repackage</id><goals><goal>repackage</goal></goals></execution></executions></plugin></plugins></build></project>

配置文件

注意   dubbo.scan.base-packages=com.qf.my.dubbo.provider

spring.application.name=my-dubbo-providerserver.port=8080# Base packages to scan Dubbo Component: @org.apache.dubbo.config.annotation.Service==>@EnableDubbo
# 我们没有配置@EnableDubbo，@EnableDubbo主要用来扫描服务和扫描配置文件，下面就用来扫描文件
dubbo.scan.base-packages=com.qf.my.dubbo.provider
dubbo.application.name=${spring.application.name}## Dubbo Registry
dubbo.registry.address=zookeeper://ip:2181# Dubbo Protocol
#dubbo.protocol.name=dubbo
#dubbo.protocol.port=20880# @Path
#dubbo.protocol.name=rest
#dubbo.protocol.port=8083dubbo.protocols.protocol1.id=dubbo1
dubbo.protocols.protocol1.name=dubbo
dubbo.protocols.protocol1.port=20881
dubbo.protocols.protocol1.host=0.0.0.0dubbo.protocols.protocol2.id=dubbo2
dubbo.protocols.protocol2.name=dubbo
dubbo.protocols.protocol2.port=20882
dubbo.protocols.protocol2.host=0.0.0.0dubbo.protocols.protocol3.id=dubbo3
dubbo.protocols.protocol3.name=dubbo
dubbo.protocols.protocol3.port=20883
dubbo.protocols.protocol3.host=0.0.0.0

服务消费者

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 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.qf</groupId><artifactId>my-dubbo-consumer</artifactId><version>0.0.1-SNAPSHOT</version><name>my-dubbo-consumer</name><description>Demo project for Spring Boot</description><properties><java.version>1.8</java.version><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><spring-boot.version>2.3.7.RELEASE</spring-boot.version></properties><dependencies><dependency><groupId>com.qf.dubbo</groupId><artifactId>my-dubbo-interfaces</artifactId><version>1.0-SNAPSHOT</version></dependency><!-- Dubbo Spring Boot Starter --><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-spring-boot-starter</artifactId><version>2.7.3</version></dependency><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-registry-zookeeper</artifactId><version>2.7.3</version><exclusions><exclusion><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId></exclusion></exclusions></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope><exclusions><exclusion><groupId>org.junit.vintage</groupId><artifactId>junit-vintage-engine</artifactId></exclusion></exclusions></dependency></dependencies><dependencyManagement><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-dependencies</artifactId><version>${spring-boot.version}</version><type>pom</type><scope>import</scope></dependency></dependencies></dependencyManagement><build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.8.1</version><configuration><source>1.8</source><target>1.8</target><encoding>UTF-8</encoding></configuration></plugin><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><version>2.3.7.RELEASE</version><configuration><mainClass>com.qf.my.dubbo.consumer.MyDubboConsumerApplication</mainClass></configuration><executions><execution><id>repackage</id><goals><goal>repackage</goal></goals></execution></executions></plugin></plugins></build></project>

配置文件

spring.application.name=my-dubbo-consumerserver.port=8009
# registry
dubbo.registry.address= zookeeper://ip:2181

1  version版本号

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

在@Service中加上参数   version  即  @Service(version = "xxx")

服务提供者

版本号为default的

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

版本号为async的。

@Service(version = "async")
public class AsyncSiteServiceImpl implements SiteService {@Overridepublic String siteName(String name) {return "async:" + name;}
}

服务消费者

由于我们没有使用启动类，没有加@EnableDubbo注解，所以用@EnableAutoConfiguration来读取配置

我们可以在@Reference中加上参数version 指定具体实现哪一个实现类

即  @Reference(version = "xxx")

@EnableAutoConfiguration
public class DefaultDubboConsumer {// @Reference(version = "async")@Reference(version = "default")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);}
}

2  指定protocol协议

服务提供者

配置文件

我们在配置文件中配置了3个协议，可以使用dubbo，rest协议，自己配就好

spring.application.name=my-dubbo-providerserver.port=8080# Base packages to scan Dubbo Component: @org.apache.dubbo.config.annotation.Service==>@EnableDubbo
dubbo.scan.base-packages=com.qf.my.dubbo.provider
dubbo.application.name=${spring.application.name}## Dubbo Registry
dubbo.registry.address=zookeeper://192.168.6.135:2181dubbo.protocols.protocol1.id=dubbo1
dubbo.protocols.protocol1.name=dubbo
dubbo.protocols.protocol1.port=20881
dubbo.protocols.protocol1.host=0.0.0.0dubbo.protocols.protocol2.id=dubbo2
dubbo.protocols.protocol2.name=dubbo
dubbo.protocols.protocol2.port=20882
dubbo.protocols.protocol2.host=0.0.0.0dubbo.protocols.protocol3.id=dubbo3
dubbo.protocols.protocol3.name=dubbo
dubbo.protocols.protocol3.port=20883
dubbo.protocols.protocol3.host=0.0.0.0

服务提供

@Service中添加参数  protocol 为  protocol1，指定我们的协议 

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

服务消费者

@EnableAutoConfiguration
public class DefaultDubboConsumer {@Reference(version = "default")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);}
}

特别的

当我们为提供者配置多个协议（注意不是多种！），并且服务提供者不指定特定的协议

即:

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

那么会为每一个协议提供一个服务，上面我们配置了三个协议，那么就是三个服务

3  使⽤rest访问dubbo的服务

服务提供者

配置文件

其中，我们配置了一个rest协议。

rest协议，可以简单地将他理解成RestFul风格，可以在下面网址中了解

REST详解_rest协议-CSDN博客

spring.application.name=my-dubbo-providerserver.port=8080# Base packages to scan Dubbo Component: @org.apache.dubbo.config.annotation.Service==>@EnableDubbo
dubbo.scan.base-packages=com.qf.my.dubbo.provider
dubbo.application.name=${spring.application.name}## Dubbo Registry
dubbo.registry.address=zookeeper://192.168.6.135:2181dubbo.protocols.protocol1.id=rest1
dubbo.protocols.protocol1.name=rest
dubbo.protocols.protocol1.port=8083
dubbo.protocols.protocol1.host=0.0.0.0dubbo.protocols.protocol2.id=dubbo2
dubbo.protocols.protocol2.name=dubbo
dubbo.protocols.protocol2.port=20882
dubbo.protocols.protocol2.host=0.0.0.0dubbo.protocols.protocol3.id=dubbo3
dubbo.protocols.protocol3.name=dubbo
dubbo.protocols.protocol3.port=20883
dubbo.protocols.protocol3.host=0.0.0.0

服务实现

注意里面使用的注解，path，get都体现着rest风格

import com.qf.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;/*** @author Thor* @公众号 Java架构栈*/
@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;}
}

服务消费者

我们可以直接请求路径

成功

4  服务超时

服务提供者

@Service(version = "timeout", timeout = 4000)
public class TimeoutSiteServiceImpl implements SiteService {@Overridepublic String siteName(String name) {try {//如果服务执行时间超过了指定的超时时间则会打印warn日志Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("serving...");return "timeout site service:"+name;}
}

警告日志

服务消费者

设置了3秒的超时时间

@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("q-face");System.out.println(name);}
}

报错异常：

5  集群容错

dubbo为集群调⽤提供了容错⽅案：
failover：（默认，推荐）
当出现失败时，会进⾏重试，默认重试2次，⼀共三次调⽤。但是会出现幂等性问题。
虽然会出现幂等性问题，但是依然推荐使⽤这种容错机制，在业务层⾯解决幂等性问题：
 - ⽅案⼀：把数据的业务id作为数据库的联合主键，此时业务id不能重复。
 - ⽅案⼆（推荐）：使⽤分布式锁来解决重复消费问题。
failfast：当出现失败时。⽴即报错，不进⾏重试。
failsafe：失败不报错，记⼊⽇志。
failback：失败就失败，开启定时任务 定时重发。
forking：并⾏访问多个服务器，获取某⼀个结果既视为成功。

结论：如果使⽤dubbo，不推荐把重试关掉，⽽是在⾮幂等性操作的场景下，服务提供者⽅
要做幂等性的解决⽅案（保证）。

6  服务降级

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

@EnableAutoConfiguration
public class MockDubboConsumer {
//    @Reference(version = "timeout", timeout = 1000, mock = "fail:return timeout")@Reference(version = "timeout", timeout = 1000, mock = "force:return hello")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);}
}

import com.qf.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;/*** @author Thor* @公众号 Java架构栈*/
@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);}}

public class SiteServiceStub implements SiteService {private final SiteService siteService;public SiteServiceStub(SiteService siteService) {this.siteService = siteService;}@Overridepublic String siteName(String name) {try {return siteService.siteName(name);} catch (Exception e) {return "stub:"+name;}}
}

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;}
}

@Service(version = "callback", methods = {@Method(name = "siteName", arguments = {@Argument(index = 2, callback = true)})}, callbacks = 3)
public class CallbackSiteServiceImpl implements SiteService {@Overridepublic String siteName(String name) {return null;}@Overridepublic String siteName(String name, String key, SiteServiceListener siteServiceListener) {siteServiceListener.changed("provider data");return "callback:"+name;}
}

public interface SiteServiceListener {void changed(String data);
}public class SiteServiceListenerImpl implements SiteServiceListener, Serializable {@Overridepublic void changed(String data) {System.out.println("changed:" + data);}
}

@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()));}
}