两小时学会使用dubbo(直接API、spring、注解、springboot)

最近上新的项目中需要用到dubbo，于是我决定温故知新，决定分享一下Dubbo在各种情况下的使用方式，本篇文章让你两小时就能学会使用dubbo
什么是Dubbo

Dubbo是一个分布式、高性能、透明化的RPC服务框架，提供服务主动注册、主动发现等高效服务治理方案，可以和Spring框架无缝集成。Dubbo最常用的应用就是远程调用。
Dubbo中服务端最焦点的对象有四个：

• ApplicationConfig：配置当前应用信息
  
• ProtocolConfig：配置提供服务的协议信息
  
• RegistryConfig：配置注册相干信息
  
• ServiceConfig：配置暴露的服务信息
  

Dubbo客户端中焦点的对象有两个：

• ApplicationConfig：配置当前应用信息
  
• ReferenceConfig：配置引用的服务信息
  

Dubbo的主要应用场景

透明化的远程方法调用，就像调用本地方法一样调用远程方法，只需简单配置，没有任何API侵入。
软负载均衡及容错机制，可在内网替换F5等硬件负载均衡器，降低成本，减少单点。（F5负载均衡器我也是百度来的）。
服务主动注册与发现，不再需要写死服务提供方地址，注册中央基于接口名查询服务提供者的IP地址，并且可以或许平滑添加或删除服务提供者。
Dubbo的使用

接下来通过四种方式入门Dubbo。首先会通过原生API直接展示dubbo的直连和注册中央实现方式，接着使用Spring、注解和SpringBoot的方式分别展示如何使用Dubbo。
案例源码点击这里
在写dubbo相干代码前，首先要界说一个公共的api服务，这个服务里存放的是service接口。服务提供者引入这个工程，写实现类，提供dubbo接口；服务消费者引入这个工程，通过这个工程的service接口调用。
User类：

1. @Data //RPC调用一般不建议使用lombok注解，容易出很多bug，这里使用是为了方便
2. public class User implements Serializable {
3.     private static final long serialVersionUID = -9206514891359830486L;
4.     private Long id;
5.     private String name;
6.     private String sex;
7. }

复制代码

UserService：

1. public interface UserService {
2.     User getUser(Long id);
3. }

复制代码

原生API

通过原生API的方式生成一个dubbo服务，并且用另外一个类去调用这个dubbo服务：

• 引入依赖
  

焦点依赖就两个，一个dubbo的依赖，另外一个上面的公共接口方法，服务提供方和消费者都需要引入这两个依赖

1. <dependencies>
2.     <dependency>
3.         <groupId>org.apache.dubbo</groupId>
4.         <artifactId>dubbo</artifactId>
5.         <version>2.7.4.1</version>
6.     </dependency>
7.         <dependency>  
8.             <artifactId>dubbo-api</artifactId>  
9.             <groupId>com.seven.direct-dubbo-demo.api</groupId>  
10.             <version>1.0-SNAPSHOT</version>  
11.         </dependency>
12. </dependencies>

复制代码

• 服务提供者
  

服务提供者主要配置以下几个属性：

• application：设置应用的名称等信息
  
• protocol ：设置服务的协议
  
• register：设置服务的连接方式
  
• service：将需要暴露的服务注册出来
  

1. public class DubboProvider {
2.     public static void main(String[] args) throws IOException {
3.         //暴露UserService服务
4.         //1、application
5.         ApplicationConfig applicationConfig = new ApplicationConfig("sample-provider");
6.         //2、protocol -dubbo协议
7.         ProtocolConfig protocolConfig = new ProtocolConfig();
8.         protocolConfig.setName("dubbo");
9.         protocolConfig.setPort(20880);
10.         //3、register
11.         //直连的方式，不暴露到注册中心
12.         RegistryConfig registryConfig = new RegistryConfig(RegistryConfig.NO_AVAILABLE);
13.         //4、service
14.         ServiceConfig serviceConfig = new ServiceConfig();
15.         serviceConfig.setInterface(UserService.class);
16.         serviceConfig.setRef(new UserServiceImpl());
17.         //5、将application、protocol、register注册到service
18.         serviceConfig.setRegistry(registryConfig);
19.         serviceConfig.setProtocol(protocolConfig);
20.         serviceConfig.setApplication(applicationConfig);
21.         serviceConfig.export();
23.         System.out.println("服务已经暴露");
24.         System.in.read();
25.     }
26. }

复制代码

• 服务消费者
  

消费者的实现主要就三步：

• 配置application：设置应用的名称等信息
  
• 配置reference：主要配置要引用的信息
  
• 获取到接口，调用服务。
  

1. public class DubboConsumer {
2.     public static void main(String[] args) {
3.         //1、application
4.         ApplicationConfig applicationConfig =new ApplicationConfig("sample-consumer");
5.         //2、配置reference
6.         ReferenceConfig referenceConfig = new ReferenceConfig();
7.         referenceConfig.setApplication(applicationConfig);
8.         referenceConfig.setInterface(UserService.class);
9.         referenceConfig.setUrl("dubbo://127.0.0.1:20880/com.seven.directdubbodemo.api.service.UserService?anyhost=true&application=sample&bind.ip=127.0.0.1&bind.port=20880&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&interface=com.seven.directdubbodemo.api.service.UserService&methods=getUser&pid=5936&release=2.7.4.1&side=provider&timestamp=1728390413736");
10.         UserService userService = (UserService) referenceConfig.get();
11.         User user = userService.getUser(1L);
12.         System.out.println(user);
13.     }
14. }

复制代码

先启动提供者，再启动消费者，如果user信息打印出来了就阐明调用成功。

• 使用zookeeper作为注册中央
  

上面的Register使用的是直连的方式，也可以使用注册中央，这里以zookeeper为例。首先在项目中引入zookeeper相干依赖：

1. <dependency>
2.     <groupId>org.apache.curator</groupId>
3.     <artifactId>curator-recipes</artifactId>
4.     <version>2.13.0</version>
5. </dependency>
6. <dependency>
7.     <groupId>org.apache.curator</groupId>
8.     <artifactId>curator-framework</artifactId>
9.     <version>2.13.0</version>
10. </dependency>

复制代码

服务提供者修改一处地方，将RegistryConfig修改为zookeeper的连接方式

1. //register
2. //直连的方式，不暴露到注册中心
3. //RegistryConfig registryConfig=new RegistryConfig(RegistryConfig.NO_AVAILABLE);
4. //通过注册中心暴露dubbo
5. RegistryConfig registryConfig = new RegistryConfig("zookeeper://127.0.0.1:2181");

复制代码

消费者同样修改一处位置，将referenceConfig中的setUrl方法更换为zookeeper：

1. RegistryConfig registryConfig = new RegistryConfig("zookeeper://127.0.0.1:2181");
2. ReferenceConfig referenceConfig = new ReferenceConfig();
3. referenceConfig.setRegistry(registryConfig);
4. referenceConfig.setApplication(applicationConfig);
5. referenceConfig.setInterface(UserService.class);
6. //referenceConfig.setUrl("dubbo://127.0.0.1:20880/com.seven.directdubbodemo.api.service.UserService?anyhost=true&application=sample&bind.ip=127.0.0.1&bind.port=20880&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&interface=com.seven.directdubbodemo.api.service.UserService&methods=getUser&pid=5936&release=2.7.4.1&side=provider&timestamp=1728390413736");

复制代码

Spring集成dubbo

通过Spring的方式只不过是把上面写在Java中的代码拿到配置文件中去，并把接口注入到Bean容器中

• 引入spring相干依赖
  

在provider和consumer的模块下额外引入spring相干依赖

1. <dependency>  
2.     <groupId>org.springframework</groupId>  
3.     <artifactId>spring-context</artifactId>  
4.     <version>5.3.37</version>  
5. </dependency>  
6. <dependency>  
7.     <groupId>org.springframework</groupId>  
8.     <artifactId>spring-core</artifactId>  
9.     <version>5.3.37</version>  
10. </dependency>  
11. <dependency>  
12.     <groupId>org.springframework</groupId>  
13.     <artifactId>spring-beans</artifactId>  
14.     <version>5.3.37</version>  
15. </dependency>

复制代码

• 在resource文件夹下新建两个配置文件
  

provider.xml

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.        xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"  
5.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
6.        http://www.springframework.org/schema/beans/spring-beans.xsd       http://dubbo.apache.org/schema/dubbo       http://dubbo.apache.org/schema/dubbo/dubbo.xsd">  
7.   
8.       
9.     <dubbo:application name="spring-provider"/>  
10.   
11.       
12.     <dubbo:registry address="zookeeper://127.0.0.1:2181"/>  
13.   
14.       
15.     <dubbo:protocol name="dubbo" port="20880"/>  
16.   
17.       
18.     <dubbo:service interface="com.seven.springdubbodemo.springdubboapi.service.UserService" ref="userService" loadbalance="roundrobin"/>  
19.   
20.       
21.     <bean id="userService" />  
22. </beans>

复制代码

consumer.xml

1. <beans xmlns="http://www.springframework.org/schema/beans"  
2.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
3.        xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"  
4.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
5.        http://www.springframework.org/schema/beans/spring-beans.xsd      
6.        http://dubbo.apache.org/schema/dubbo      
7.        http://dubbo.apache.org/schema/dubbo/dubbo.xsd">  
8.   
9.     <dubbo:application name="spring-consumer"  />  
10.     <dubbo:registry address="zookeeper://127.0.0.1:2181" />  
11.     <dubbo:reference id="userService" interface="com.seven.springdubbodemo.springdubboapi.service.UserService" loadbalance="roundrobin"/>  
12. </beans>

复制代码

• 启动类
  

这里的配置文件和上方的代码均一一对应。服务的提供者和消费者：
SpringDubboProvider：

1. public class SpringDubboProvider {
2.     public static void main(String[] args) throws IOException {
3.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("provider.xml");
4.         System.out.println("服务已经暴露");
5.         System.in.read();
6.     }
7. }

复制代码

SpringDubboConsumer

1. public class SpringDubboConsumer {
2.     public static void main(String[] args) {
3.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("consumer.xml");
4.         UserService bean = context.getBean(UserService.class);
5.         System.out.println(bean.getUser(1L));
6.     }
7. }

复制代码

纯注解版

注解的方式就是不在xml文件中注入bean，xml文件中只需要写包名即可

• provider修改
  provider.xml
  

1. <beans xmlns="http://www.springframework.org/schema/beans"  
2.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
3.        xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"  
4.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
5.        http://www.springframework.org/schema/beans/spring-beans.xsd      
6.        http://dubbo.apache.org/schema/dubbo      
7.        http://dubbo.apache.org/schema/dubbo/dubbo.xsd">  
8.   
9.     <dubbo:application name="spring-consumer"  />  
10.     <dubbo:registry address="zookeeper://127.0.0.1:2181" />  
11.     <dubbo:reference id="userService" interface="com.seven.springdubbodemo.springdubboapi.service.UserService" loadbalance="roundrobin"/>  
12. </beans><beans xmlns="http://www.springframework.org/schema/beans"  
13.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
14.        xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"  
15.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
16.        http://www.springframework.org/schema/beans/spring-beans.xsd      
17.        http://dubbo.apache.org/schema/dubbo      
18.        http://dubbo.apache.org/schema/dubbo/dubbo.xsd">  
19.   
20.     <dubbo:application name="spring-consumer"  />  
21.     <dubbo:registry address="zookeeper://127.0.0.1:2181" />  
22.     <dubbo:reference id="userService" interface="com.seven.springdubbodemo.springdubboapi.service.UserService" loadbalance="roundrobin"/>  
23. </beans>               

复制代码

UserService实现类

1. import org.apache.dubbo.config.annotation.Service;
2. @Service  //dubbo的@Service注解
3. public class UserServiceImpl implements UserService {  
4.     @Override  
5.     public User getUser(Long id) {  
6.         User user = new User();  
7.         user.setId(id);  
8.         user.setName("Seven");  
9.         user.setSex("男");  
10.         return user;  
11.     }  
12. }

复制代码

• consumer修改
  consumer.xml
  

1. <beans xmlns="http://www.springframework.org/schema/beans"  
2.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
3.        xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"  
4.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
5.        http://www.springframework.org/schema/beans/spring-beans.xsd      
6.        http://dubbo.apache.org/schema/dubbo      
7.        http://dubbo.apache.org/schema/dubbo/dubbo.xsd">  
8.   
9.     <dubbo:application name="spring-consumer"  />  
10.     <dubbo:registry address="zookeeper://127.0.0.1:2181" />  
11.     <dubbo:reference id="userService" interface="com.seven.springdubbodemo.springdubboapi.service.UserService" loadbalance="roundrobin"/>  
12. </beans>               

复制代码

controller类

1. @Controller  
2. public class UserController {  
4.     @Reference //import org.apache.dubbo.config.annotation.Reference;  
5.     private UserService userService;  
6.   
7.     public User getUser(long id){  
8.         return userService.getUser(id);  
9.     }  
10.   
11. }

复制代码

SpringBoot集成dubo

引入dubbo和springboot的焦点依赖

1.   
2. <dependency>  
3.     <groupId>org.apache.dubbo</groupId>  
4.     <artifactId>dubbo-spring-boot-starter</artifactId>  
5.     <version>2.7.5</version>  
6. </dependency>  
7.   
8. <dependency>  
9.     <groupId>org.springframework.boot</groupId>  
10.     <artifactId>spring-boot-starter</artifactId>  
11.     <version>2.7.5</version>  
12. </dependency>

复制代码

• 服务提供者provider
  这里的配置都写在application.properties中：
  

1. #当前服务/应用的名字  
2. dubbo:
3.         application:
4.                 name: springboot-provider  
5.   
6. #注册中心的协议和地址  
7.         registry:
8.                 protocol: zookeeper  
9.                 address: 127.0.0.1:2181  
10.   
11. #通信规则（通信协议和接口）  
12.         protocol:
13.                 name: dubbo  
14.                 port: 20880
15. # 负载均衡算法
16.         provider:
17.                 loadbalance: roundrobin

复制代码

服务提供者需要写服务的实现类，这里需要注意@Service注解采用的是dubbo包下：

1. import com.seven.springbootdubbodemo.api.entity.User;  
2. import com.seven.springbootdubbodemo.api.service.UserService;  
3. import org.apache.dubbo.config.annotation.Service;  
5. @Service  
6. public class UserServiceImpl implements UserService {  
7.     @Override  
8.     public User getUser(Long id) {  
9.         User user = new User();  
10.         user.setId(id);  
11.         user.setName("Seven");  
12.         user.setSex("男");  
13.         return user;  
14.     }  
15. }

复制代码

接着在启动类上添加一个@EnableDubbo注解即可。

1. @EnableDubbo  
2. @SpringBootApplication  
3. public class App{  
4.   
5.     public static void main(String[] args) {  
6.         SpringApplication.run(App.class, args);  
7.     }  
8. }

复制代码

• 服务的消费者consumer
  

配置文件：

1. #避免和provider端口冲突，设为8081端口访问  
2. server:
3.         port: 8081  
4.   
5. #当前服务/应用的名字  
6. dubbo:
7.         application:
8.                 name: springboot-consumer
9.   
10. #注册中心的协议和地址  
11.         registry:
12.                 protocol: zookeeper  
13.                 address: 127.0.0.1:2181  
14.   
15. #通信规则（通信协议和接口）  
16.         protocol:
17.                 name: dubbo  
18.                 port: 20880
19. # 负载均衡算法
20.         consumer:
21.                 loadbalance: roundrobin

复制代码

接着通过@Reference注解将service对象引进来

1. @SpringBootApplication  
2. public class App{  
3.   
4.     @Reference  
5.     UserService userService;  
6.   
7.     public static void main(String[] args) {  
8.         SpringApplication.run(App.class, args);  
9.     }  
10.   
11.     @Bean  
12.     public ApplicationRunner getBean(){  
13.         return args -> {  
14.             System.out.println(userService.getUser(1L));  
15.         };  
16.     }  
17. }

复制代码

dubbo的常用配置

• xml配置
  

1. <dubbo:application/> 用于配置当前应用信息
2. <dubbo:register/> 用于配置连接注册相关信息
3. <dubbo:protocol/> 用于配置提供服务的协议信息，提供者指定协议，消费者被动接受
5. <dubbo:service/> 用于暴露一个服务，一个服务可以用多个协议暴露，一个服务也可以注册到多个注册中心。provider端配置
7. <dubbo:reference/> 用于创建一个远程服务代理。consumer端配置

复制代码

• springboot配置
  

1. dubbo:
2.   application:
3.       name: dubbo-springboot-demo-provider
4.   protocol:
5.     name: dubbo
6.     port: 50052
7.   registry:
8.     address: zookeeper://127.0.0.1:2181

复制代码

更加详细的配置信息可以参考：配置项参考手册 | Apache Dubbo
企业中如何通过dubbo实现分布式调用

在企业中，如果消费者直接通过RPC去调用提供者，理论上需要把提供者的整个Jar包引入到项目中。但是如许的话服务提供这种的其他无关代码也会被引入此中，导致代码污染。
因此实际开发过程中，服务提供者和调用者之间会增长一层API模块。这个API中主要写的是Service的接口界说，接口的返回实例对象以及接口的请求实例对象。简单来讲，所有的界说都在API中完成。
使用时，服务提供者引入这个API，然后写实现方法，服务消费者引入这个API，然后通过dubbo直接调用即可。
另外企业开发中，可能会出现多个接口实现，这种情况下可以给Service设定group、version等进行区分。
关于作者

来自一线程序员Seven的探索与实践，持续学习迭代中~
本文已收录于我的个人博客：https://www.seven97.top
公众号：seven97，欢迎关注~

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。