5分钟实现SpringBoot整合Dubbo构建分布式服务

开发 架构 分布式
Dubbo是Alibaba开源的分布式服务框架,它最大的特点是按照分层的方式来架构,使用这种方式可以使各个层之间解耦合。

概述:

Dubbo是Alibaba开源的分布式服务框架,它最大的特点是按照分层的方式来架构,使用这种方式可以使各个层之间解耦合(或者最大限度地松耦合)。从服务模型的角度来看,Dubbo采用的是一种非常简单的模型,要么是提供方提供服务,要么是消费方消费服务,所以基于这一点可以抽象出服务提供方(Provider)和服务消费方(Consumer)两个角色。

我们来看一下Dubbo 的RPC 调用流程,这里主要涉及到4个模块:

  •  Registry:服务注册,我们一般会采取Zookeeper 作为我们的注册中心
  •  Provider:服务提供者(生产者),提供具体的服务实现
  •  Consumer:消费者,从注册中心中订阅服务
  •  Monitor:监控中心,RPC调用次数和调用时间监控

从上图中我们可以了解到整个RPC 服务调用的过程主要为:

  •  生产者发布服务到服务注册中心中
  •  消费者在服务注册中心中订阅服务
  •  消费者调用已经注册的服务

一、项目构建

开发环境主要涉及以下几个方面:

  •  Spring-boot
  •  JDK 8
  •  Dubbo
  •  Zookeeper

项目构建通过: http://start.spring.io/ 快速构建web 项目,具体操作可以参考

http://www.cnblogs.com/jaycekon/p/7562688.html

由于Dubbo 中需要使用到服务注册中心,我们这里将使用Zookeeper 作为服务注册中心,具体安装配置,可以参考

http://www.cnblogs.com/jaycekon/p/7553909.html

在基础环境确定好了之后,我们项目的目录结构如下:

上图所示,我们项目主要分为了两个模块,一部分是生产者:spring-boot-dubbo ,一部分是:spring-boot-consumer。

整个项目的结构非常简单,这很符合Spring-Boot 的特性,简单便捷,下面我们开始一步步的剖析整个项目的结构

二、Productor

2.1、Pom.xml

项目依赖这一块主要使用到了基本的Spring-Boot-Web 依赖,然后我们需要额外引入Dubbo 与Zookeeper的依赖(详细依赖可参考源码,博文底部会有项目Github 地址): 

  1. <dependency>  
  2.             <groupId>io.dubbo.springboot</groupId>  
  3.             <artifactId>spring-boot-starter-dubbo</artifactId>  
  4.             <version>1.0.0</version>  
  5.         </dependency>  
  6.         <dependency>  
  7.             <groupId>org.apache.zookeeper</groupId>  
  8.             <artifactId>zookeeper</artifactId>  
  9.             <version>3.4.6</version>  
  10.             <exclusions>  
  11.                 <exclusion>  
  12.                     <groupId>org.slf4j</groupId>  
  13.                     <artifactId>slf4j-log4j12</artifactId>  
  14.                 </exclusion>  
  15.                 <exclusion>  
  16.                     <groupId>log4j</groupId>  
  17.                     <artifactId>log4j</artifactId>  
  18.                 </exclusion>  
  19.             </exclusions>  
  20.         </dependency> 

2.2、配置文件

由于我们底层使用的是Spring-Boot 进行开发,那么我们就应该善于利用Spring-Boot 给我们带来的优势,因此我们可以直接在Application.properties 文件中配置Dubbo 服务: 

  1. ## Dubbo 服务提供者配置  
  2. spring.dubbo.application.name=provider    --服务名称  
  3. spring.dubbo.registry.address=zookeeper://127.0.0.1:2181   -- 注册中心地址  
  4. spring.dubbo.protocol.name=dubbo     -- dubbo 协议  
  5. spring.dubbo.protocol.port=20880  
  6. spring.dubbo.scan=com.jaycekon.dubbo.service     --声明需要暴露的服务接口 

如果不采用Spring-Boot 进行自动配置,大家可以参考一下的配置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://code.alibabatech.com/schema/dubbo"  
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
  6.        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">  
  7.     <!-- 提供方应用信息 -->  
  8.     <dubbo:application name="provider"  />  
  9.     <!-- 注册中心服务地址 -->  
  10.     <dubbo:registry  protocol="zookeeper" address="127.0.0.1"  check="false" />  
  11.     <!-- 用dubbo协议-->  
  12.     <dubbo:protocol name="dubbo" port="-1" dispather="all" check="false" />  
  13.     <dubbo:provider timeout="10000"  threads="10" threadpool="fixed"   loadbalance="roundrobin"/>  
  14.     <!-- 声明需要暴露的服务接口 -->  
  15.     <dubbo:service interface="com.jaycekon.dubbo.service" ref="userService"/> </beans> 

2.3、服务提供

在服务提供主要包括两部分,一个是暴露服务,一个是服务实现

暴露服务:即我们平常开发中所使用的的接口,这里我们创建一个 UserService 的接口,主要包括一个保存用户的方法。 

  1. import com.jaycekon.dubbo.domain.User;  
  2. /**  
  3.  * Created by Jaycekon on 2017/9/19.  
  4.  */  
  5. public interface UserService {  
  6.     User saveUser(User user);  

服务实现:服务实现,与我们平常的服务一样,对接口进行实现,比较特别的是,我们这里需要使用到Dubbo 的 @Service 注解。更多springboot实战内容,Java知音公众号内回复“springboot聚合” 

  1. import com.alibaba.dubbo.config.annotation.Service;  
  2. import com.jaycekon.dubbo.domain.User;  
  3. import com.jaycekon.dubbo.service.UserService;  
  4. /**  
  5.  * Created by Jaycekon on 2017/9/19.  
  6.  */  
  7. @Service  
  8. public class UserServiceImpl implements UserService {  
  9.     @Override  
  10.     public User saveUser(User user) {  
  11.         user.setId(1);  
  12.         System.out.println(user.toString());  
  13.         return user;  
  14.     }  

2.4、总体结构

Dubbo 的服务提供端,已经总体开发完成,非常简单,总体的目录结构如下:

三、Consumer

3.1、pom.xml

消费者的相关依赖,与生产者的依赖一致。 

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  4.     <modelVersion>4.0.0</modelVersion>  
  5.     <groupId>com.jaycekon</groupId>  
  6.     <artifactId>spring-boot-consumer</artifactId>  
  7.     <version>0.0.1-SNAPSHOT</version>  
  8.     <packaging>jar</packaging>  
  9.     <name>spring-boot-consumer</name>  
  10.     <description>Demo project for Spring Boot</description>  
  11.     <parent>  
  12.         <groupId>org.springframework.boot</groupId>  
  13.         <artifactId>spring-boot-starter-parent</artifactId>  
  14.         <version>1.5.7.RELEASE</version>  
  15.         <relativePath/> <!-- lookup parent from repository -->  
  16.     </parent>  
  17.     <properties>  
  18.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
  19.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>  
  20.         <java.version>1.8</java.version>  
  21.     </properties>  
  22.     <dependencies>  
  23.         <dependency>  
  24.             <groupId>org.springframework.boot</groupId>  
  25.             <artifactId>spring-boot-starter-web</artifactId>  
  26.         </dependency>  
  27.         <dependency>  
  28.             <groupId>org.springframework.boot</groupId>  
  29.             <artifactId>spring-boot-starter-test</artifactId>  
  30.             <scope>test</scope>  
  31.         </dependency>  
  32.         <!-- Spring Boot Dubbo 依赖 -->  
  33.         <dependency>  
  34.             <groupId>io.dubbo.springboot</groupId>  
  35.             <artifactId>spring-boot-starter-dubbo</artifactId>  
  36.             <version>1.0.0</version>  
  37.         </dependency>  
  38.         <dependency>  
  39.             <groupId>org.apache.zookeeper</groupId>  
  40.             <artifactId>zookeeper</artifactId>  
  41.             <version>3.4.6</version>  
  42.             <exclusions>  
  43.                 <exclusion>  
  44.                     <groupId>org.slf4j</groupId>  
  45.                     <artifactId>slf4j-log4j12</artifactId>  
  46.                 </exclusion>  
  47.                 <exclusion>  
  48.                     <groupId>log4j</groupId>  
  49.                     <artifactId>log4j</artifactId>  
  50.                 </exclusion>  
  51.             </exclusions>  
  52.         </dependency>  
  53.         <!-- mvn spring-boot:run 热部署启动 -->  
  54.         <dependency>  
  55.             <groupId>org.springframework</groupId>  
  56.             <artifactId>springloaded</artifactId>  
  57.             <version>1.2.3.RELEASE</version>  
  58.         </dependency>  
  59.         <dependency>  
  60.             <groupId>org.projectlombok</groupId>  
  61.             <artifactId>lombok</artifactId>  
  62.             <version>1.16.18</version>  
  63.             <scope>provided</scope>  
  64.         </dependency>  
  65.     </dependencies>  
  66.     <build>  
  67.         <plugins>  
  68.             <plugin>  
  69.                 <groupId>org.springframework.boot</groupId>  
  70.                 <artifactId>spring-boot-maven-plugin</artifactId>  
  71.             </plugin>  
  72.         </plugins>  
  73.     </build>  
  74. </project> 

3.2、配置文件

配置文件与生产者稍有区别: 

  1. ## 避免和 server 工程端口冲突  
  2. server.port=8081 
  3. ## Dubbo 服务消费者配置  
  4. spring.dubbo.application.name=consumer  
  5. spring.dubbo.registry.address=zookeeper://127.0.0.1:2181  
  6. spring.dubbo.scan=com.jaycekon.dubbo.service 

基于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://code.alibabatech.com/schema/dubbo"  
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
  6.        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">  
  7.     <!-- 提供方应用信息 -->  
  8.     <dubbo:application name="provider"  />  
  9.     <!-- 注册中心服务地址 -->  
  10.     <dubbo:registry  protocol="zookeeper" address="${dubbo.registry.address}"  check="false" />  
  11.     <!-- 用dubbo协议-->  
  12.     <dubbo:protocol name="dubbo" port="-1" dispather="all" check="false" />  
  13.     <dubbo:provider timeout="10000"  threads="10" threadpool="fixed"   loadbalance="roundrobin"/>  
  14.     <!-- 声明需要暴露的服务接口 -->  
  15.     <dubbo:service interface="com.jaycekon.dubbo.service" ref="userService"/>  
  16. </beans> 

3.3、服务实现

在这里,如果我们需要调用注册服务中的相关服务,则需要实现相关的接口。 

  1. import com.jaycekon.dubbo.domain.User;  
  2. /**  
  3.  * Created by Jaycekon on 2017/9/19.  
  4.  */  
  5. public interface UserService {  
  6.     User saveUser(User user);  

例如,在这里我们需要使用到生产者中的 saveUser(User user) 方法,则需要创建一个接口,然后再调用时,使用 @Reference 注解进行引用: 

  1. import com.alibaba.dubbo.config.annotation.Reference;  
  2. import com.jaycekon.dubbo.domain.City;  
  3. import com.jaycekon.dubbo.domain.User; 
  4. import org.springframework.stereotype.Component;  
  5. /**  
  6.  * 城市 Dubbo 服务消费者  
  7.  * <p>  
  8.  * Created by Jaycekon on 20/09/2017.  
  9.  */  
  10. @Component  
  11. public class CityDubboConsumerService {  
  12.     @Reference  
  13.     CityDubboService cityDubboService;  
  14.     @Reference  
  15.     UserService userService;  
  16.     public void printCity() {  
  17.         String cityName = "广州" 
  18.         City city = cityDubboService.findCityByName(cityName);  
  19.         System.out.println(city.toString());  
  20.     }  
  21.     public User saveUser() {  
  22.         User user = new User();  
  23.         user.setUsername("jaycekon")  
  24.                 .setPassword("jaycekong824");  
  25.         return userService.saveUser(user);  
  26.     }  

3.4、服务调用

最后,我们需要实现一个RESTful 接口,提供给用户调用: 

  1. import com.jaycekon.dubbo.service.CityDubboConsumerService;  
  2. import org.springframework.beans.factory.annotation.Autowired;  
  3. import org.springframework.web.bind.annotation.RequestMapping;  
  4. import org.springframework.web.bind.annotation.RestController;  
  5. /**  
  6.  * Created by Jaycekon on 2017/9/19.  
  7.  */  
  8. @RestController  
  9. public class UserController {  
  10.     @Autowired  
  11.     private CityDubboConsumerService service;  
  12.     @RequestMapping("/save")  
  13.     public Object saveUser() { 
  14.         return service.saveUser();  
  15.     }  

3.5、目录结构

四、总结

本篇博客主要是博主在学习Spring-boot 的时候,总结下来的。在经过一些列的对比后,感觉Dubbo 与Spring-Cloud 还是有点差距的,不管是从服务提供,还是社区活跃来说,Spring-Cloud 还是会强一点。但是由于公司内部使用的是Dubbo,因此还是需要学习一下,后续的话,会对Spring-Cloud 进行学习以及分项。

GitHub地址

https://github.com/jaycekon/SpringBoot 

 

责任编辑:庞桂玉 来源: Java知音
相关推荐

2016-12-16 11:05:00

分布式互斥线程

2017-11-08 09:57:00

分布式微服务集群

2024-04-29 07:57:46

分布式流控算法

2022-05-23 09:10:00

分布式工具算法

2023-01-13 07:39:07

2018-06-28 14:00:01

分布式集群架构

2019-06-21 10:00:42

微服务分布式架构

2022-01-10 11:58:51

SpringBootPulsar分布式

2022-06-27 08:21:05

Seata分布式事务微服务

2018-04-09 13:56:13

微服务架构分布式

2018-04-02 15:01:31

微服务架构分布式服务

2020-02-24 16:04:55

架构运维技术

2019-11-25 09:32:26

软件程序员数据结构

2021-08-16 15:40:04

分布式架构系统

2021-03-18 09:18:39

分布式事务Saga

2020-05-19 08:15:16

互联网分布式微服务

2022-08-24 08:42:59

Minio存储Golang

2024-10-31 13:51:58

2009-11-26 11:19:52

NIS服务器
点赞
收藏

51CTO技术栈公众号