SpringBoot整合Dubbo

亦凉 2022-02-23 09:16 213阅读 0赞

前言

Dubbo 是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。

简单来说，Dubbo 用于分布式的场景。

源码

GitHub地址：https://github.com/intomylife/SpringBoot

环境

  • JDK 1.8.0 +
  • Maven 3.0 +
  • MySQL 5.6.17
  • SpringBoot 2.0.3
  • ZooKeeper-3.4.5
  • dubbo-admin-2.6.0

开发工具

  • IntelliJ IDEA
  • Tomcat 8.0

SQL脚本

注：这是两个库：base_db 和 user_db

  1. USE base_db;
  2. DROP TABLE IF EXISTS `springboot_base` ;
  3. CREATE TABLE `springboot_base` (
  4.   `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  5.   `parent_id` bigint(20) unsigned DEFAULT '0' COMMENT '父 id',
  6.     `region_name` varchar(20) DEFAULT NULL COMMENT '地区名',
  7.   PRIMARY KEY (`id`) USING BTREE
  8. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=COMPACT COMMENT='地区表';
  10. INSERT INTO springboot_base ( parent_id , region_name )
  11. VALUES ('0','上海市'),('1','嘉定区'),('1','松江区'),('1','黄浦区');
  13. USE user_db;
  14. DROP TABLE IF EXISTS `springboot_user` ;
  15. CREATE TABLE `springboot_user` (
  16.   `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  17.   `regoin_id` bigint(20) unsigned DEFAULT '0' COMMENT '地区 id',
  18.     `name` varchar(20) DEFAULT NULL COMMENT '姓名',
  19.   PRIMARY KEY (`id`) USING BTREE
  20. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=COMPACT COMMENT='用户表';
  22. INSERT INTO springboot_user ( regoin_id , name )
  23. VALUES (3,'cdy'),(4,'zwc'),(2,'ergouzi');

正文

commons 工程 - POM 文件

  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>
  6.     <!-- 三坐标 -->
  7.     <groupId>com.zwc</groupId>
  8.     <artifactId>springboot-dubbo-commons</artifactId>
  9.     <version>0.0.1-SNAPSHOT</version>
  11.     <!-- 工程名称和描述 -->
  12.     <name>springboot-dubbo-commons</name>
  13.     <description>公用工程</description>
  15.     <!-- 打包方式 -->
  16.     <packaging>jar</packaging>
  18.     <!-- 在properties下声明相应的版本信息，然后在dependency下引用的时候用${spring-version}就可以引入该版本jar包了 -->
  19.     <properties>
  20.         <!-- 编码 -->
  21.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  22.         <!-- jdk -->
  23.         <java.version>1.8</java.version>
  25.         <!-- springboot -->
  26.         <platform-bom.version>Cairo-SR3</platform-bom.version>
  28.         <!-- ali 连接池 -->
  29.         <druid.version>1.1.9</druid.version>
  30.         <!-- ali json -->
  31.         <fastjson.version>1.2.47</fastjson.version>
  32.         <jackson.mapper.asl.version>1.9.9</jackson.mapper.asl.version>
  34.         <!-- mybatis -->
  35.         <mybatis-plus-boot-starter.version>3.0-RELEASE</mybatis-plus-boot-starter.version>
  36.         <mybatis-spring-boot-starter.version>1.3.2</mybatis-spring-boot-starter.version>
  37.         <mybatis.ehcache.version>1.1.0</mybatis.ehcache.version>
  39.         <!-- dubbo -->
  40.         <dubbo-spring-boot-starter.version>0.2.0</dubbo-spring-boot-starter.version>
  41.     </properties>
  43.     <!-- 加入依赖 -->
  44.     <dependencies>
  45.         <!-- ali 连接池依赖 -->
  46.         <dependency>
  47.             <groupId>com.alibaba</groupId>
  48.             <artifactId>druid-spring-boot-starter</artifactId>
  49.             <version>${druid.version}</version>
  50.         </dependency>
  52.         <!-- mysql 依赖 -->
  53.         <dependency>
  54.             <groupId>mysql</groupId>
  55.             <artifactId>mysql-connector-java</artifactId>
  56.         </dependency>
  58.         <!-- ali json依赖 -->
  59.         <dependency>
  60.             <groupId>com.alibaba</groupId>
  61.             <artifactId>fastjson</artifactId>
  62.             <version>${fastjson.version}</version>
  63.         </dependency>
  64.         <dependency>
  65.             <groupId>org.codehaus.jackson</groupId>
  66.             <artifactId>jackson-mapper-asl</artifactId>
  67.             <version>${jackson.mapper.asl.version}</version>
  68.         </dependency>
  70.         <!-- mybatis 依赖 -->
  71.         <dependency>
  72.             <groupId>org.mybatis.spring.boot</groupId>
  73.             <artifactId>mybatis-spring-boot-starter</artifactId>
  74.             <version>${mybatis-spring-boot-starter.version}</version>
  75.         </dependency>
  76.         <dependency>
  77.             <groupId>com.baomidou</groupId>
  78.             <artifactId>mybatis-plus-boot-starter</artifactId>
  79.             <version>${mybatis-plus-boot-starter.version}</version>
  80.         </dependency>
  81.         <dependency>
  82.             <groupId>org.mybatis.caches</groupId>
  83.             <artifactId>mybatis-ehcache</artifactId>
  84.             <version>${mybatis.ehcache.version}</version>
  85.         </dependency>
  87.         <!-- dubbo 依赖 -->
  88.         <dependency>
  89.             <groupId>com.alibaba.boot</groupId>
  90.             <artifactId>dubbo-spring-boot-starter</artifactId>
  91.             <version>${dubbo-spring-boot-starter.version}</version>
  92.         </dependency>
  93.     </dependencies>
  95.     <!-- 依赖 jar 包版本管理的管理器 -->
  96.     <!-- 如果 dependencies 里的 dependency 自己没有声明 version 元素，那么 maven 就此处来找版本声明。 -->
  97.     <!-- 如果有，就会继承它；如果没有就会报错，告诉你没有版本信息 -->
  98.     <!-- 优先级：如果 dependencies 里的 dependency 已经声明了版本信息，就不会生效此处的版本信息了 -->
  99.     <dependencyManagement>
  100.         <dependencies>
  101.             <!-- SpringBoot -->
  102.             <dependency>
  103.                 <groupId>io.spring.platform</groupId>
  104.                 <artifactId>platform-bom</artifactId>
  105.                 <version>${platform-bom.version}</version>
  106.                 <type>pom</type>
  107.                 <scope>import</scope>
  108.             </dependency>
  109.         </dependencies>
  110.     </dependencyManagement>
  112.     <!-- 插件依赖 -->
  113.     <build>
  114.         <plugins>
  115.             <plugin>
  116.                 <groupId>org.springframework.boot</groupId>
  117.                 <artifactId>spring-boot-maven-plugin</artifactId>
  118.             </plugin>
  119.         </plugins>
  120.     </build>
  122. </project>
  • 配置一些共用依赖，其中包括 dubbo-spring-boot-starter 依赖来整合 Dubbo

commons 工程 - system.properties

  1. # mybatis-plus
  2. ## 扫描 mapper 文件
  3. mybatis-plus.mapper-locations=classpath*:com/zwc/*/mapper/xml/*.xml
  4. ## 扫描实体类
  5. mybatis-plus.type-aliases-package=com.zwc.*.domain
  • 需要连接数据库，所以依旧配置了 MyBatis-Plus
  • 一些共用配置，不经常修改的，或者是可以统一修改的
  • 这里扫描 Mapper 文件和实体类都用了通配符的方式
  • 比如还可以配置 OSS 的配置信息，Redis 的配置信息，MongoDB 的配置信息等等..

commons 工程 - 自定义配置

  1. package com.zwc.core.config;
  3. import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.context.annotation.PropertySource;
  8. /*
  9.  * @ClassName MyBatisPlusConfig
  10.  * @Desc TODO   mybatis-plus 配置
  11.  * @Date 2019/4/6 10:21
  12.  * @Version 1.0
  13.  */
  14. @Configuration
  15. @PropertySource("classpath:system.properties")
  16. public class MyBatisPlusConfig {
  18.     /*
  19.      * @ClassName MyBatisPlusConfig
  20.      * @Desc TODO   mybatis-plus 配置拦截
  21.      * @Date 2019/4/6 10:21
  22.      * @Version 1.0
  23.      */
  24.     @Bean
  25.     public PaginationInterceptor paginationInterceptor(){
  26.         PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
  27.         // 设置方言
  28.         paginationInterceptor.setDialectType("mysql");
  29.         return paginationInterceptor;
  30.     }
  32. }
  • 注意这里在注入类的时候，还要加载自定的配置文件，因为 SpringBoot 不会默认加载 system.properties
  • 配置了 MyBatis-Plus 的分页插件，方言为 MySQL

commons 工程 - 项目结构

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDAyMjAw_size_16_color_FFFFFF_t_70

#

service 工程

service 工程是一个父工程，里面包含 基础模块，用户模块，每个模块中又会分为 core 和 api

Dubbo 核心角色有：Provider（提供者），Consumer（消费者），Registry（注册中心）

Monitor（监控中心）和 Container（运行容器）

此工程中 base-service 作为 Provider（提供者），user-service 作为 Consumer（消费者）

每个模块的 api（**base-service-api / user-service-api**）工程中写对外暴露的接口

每个模块的 core （**base-service-core / user-service-core**）工程中有自己的服务和实现 api 接口的服务

Provider（提供者）

service 工程 - base-service - base-service-core - application.properties 配置文件

  1. # 端口
  2. server.port=8081
  4. # 数据源
  5. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  6. spring.datasource.url=jdbc:mysql://127.0.0.1:3306/base_db?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&serverTimezone=PRC&useSSL=false
  7. spring.datasource.username=root
  8. spring.datasource.password=123456
  10. # 打印 sql 日志
  11. logging.level.com.zwc.base.mapper=debug
  13. # dubbo 配置
  14. ## 注册中心
  15. ### 注册中心的地址
  16. dubbo.registry.address=zookeeper://127.0.0.1:2181
  17. ## 提供方
  18. ### 提供方的项目名称
  19. dubbo.application.name=springboot-dubbo-base-service
  20. ## 超时时间
  21. dubbo.consumer.timeout=100000
  22. ## dubbo
  23. ### dubbo 的名称
  24. dubbo.protocol.name=dubbo
  25. ### dubbo 的端口（-1 表示随机端口号）
  26. dubbo.protocol.port=-1
  • base-service 工程连接的 base_db 数据库
  • 在 springboot-dubbo-base-service-core 工程的 resources 文件夹下有 application.properties 和 test_base.yml 文件
  • SpringBoot 会默认读取加载 resources 文件夹下的 application.properties 和 application.yml 文件里的配置信息
  • 源码中两种方式都有配置，效果一致；想使用哪种配置就把名称改成 application
  • 如果使用 .yml 文件，注意 .yml 文件需要去掉注释

service 工程 - base-service - base-service-api

api 接口

  1. package com.zwc.base.api;
  3. import com.zwc.base.dto.response.SpringbootBaseResponseDTO;
  5. import java.util.List;
  7. /**
  8.  * @ClassName SpringbootBaseApi
  9.  * @Desc TODO   地区表 服务类
  10.  * @Date 2019/4/6 14:19
  11.  * @Version 1.0
  12.  */
  13. public interface SpringbootBaseApi {
  15.     // 获取全部地区
  16.     List<SpringbootBaseResponseDTO> getAllBase();
  18. }
  • 对外暴露的接口

service 工程 - base-service - base-service-core

api 接口实现类

  1. package com.zwc.base.api.impl;
  3. import com.alibaba.dubbo.config.annotation.Service;
  4. import com.zwc.base.api.SpringbootBaseApi;
  5. import com.zwc.base.dto.response.SpringbootBaseResponseDTO;
  6. import com.zwc.base.service.SpringbootBaseService;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.stereotype.Component;
  10. import java.util.List;
  12. /**
  13.  * @ClassName SpringbootBaseApiImpl
  14.  * @Desc TODO   地区表 服务实现类
  15.  * @Date 2019/4/6 14:25
  16.  * @Version 1.0
  17.  */
  18. @Service(interfaceClass = SpringbootBaseApi.class)
  19. public class SpringbootBaseApiImpl implements SpringbootBaseApi {
  21.     @Autowired
  22.     private SpringbootBaseService springbootBaseService;
  24.     /*
  25.      * @ClassName SpringbootBaseApiImpl
  26.      * @Desc TODO   获取全部地区
  27.      * @Date 2019/4/6 14:28
  28.      * @Version 1.0
  29.      */
  30.     @Override
  31.     public List<SpringbootBaseResponseDTO> getAllBase() {
  32.         return springbootBaseService.getAllBase();
  33.     }
  35. }
  • 特别注意 @Service 注解的包是 com.alibaba.dubbo.config.annotation.Service
  • SpringbootBaseApi 类是 base-service-api 工程中的 api 接口
  • springbootBaseService 类是 base-service-core 工程中自己的服务

service （自己的服务 ）

  1. package com.zwc.base.service;
  3. import com.alibaba.dubbo.config.annotation.Reference;
  4. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  5. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  6. import com.zwc.base.domain.SpringbootBase;
  7. import com.zwc.base.dto.response.SpringbootBaseResponseDTO;
  8. import com.zwc.base.mapper.SpringbootBaseMapper;
  9. import com.zwc.user.api.SpringbootUserApi;
  10. import com.zwc.user.dto.response.SpringbootUserResponseDTO;
  11. import org.springframework.beans.BeanUtils;
  12. import org.springframework.stereotype.Service;
  14. import javax.annotation.Resource;
  15. import java.util.ArrayList;
  16. import java.util.List;
  18. /**
  19.  * @ClassName SpringbootBaseService
  20.  * @Desc TODO   地区表 实现服务类
  21.  * @Date 2019/4/6 14:04
  22.  * @Version 1.0
  23.  */
  24. @Service
  25. public class SpringbootBaseService extends ServiceImpl<SpringbootBaseMapper,SpringbootBase> {
  27.     @Resource
  28.     private SpringbootBaseMapper springbootBaseMapper;
  30.     /*
  31.      * @ClassName SpringbootBaseService
  32.      * @Desc TODO   获取全部地区
  33.      * @Date 2019/4/6 14:31
  34.      * @Version 1.0
  35.      */
  36.     public List<SpringbootBaseResponseDTO> getAllBase(){
  37.         // 返回
  38.         List<SpringbootBaseResponseDTO> result = new ArrayList<>();
  39.         // 调用查询
  40.         List<SpringbootBase> list = super.list(new QueryWrapper<>());
  41.         // 遍历结果
  42.         list.forEach(base -> {
  43.             SpringbootBaseResponseDTO springbootBaseResponseDTO = new SpringbootBaseResponseDTO();
  44.             // 复值
  45.             BeanUtils.copyProperties(base,springbootBaseResponseDTO);
  46.             // 添加到返回集合中
  47.             result.add(springbootBaseResponseDTO);
  48.         });
  50.         // 返回
  51.         return result;
  52.     }
  54. }
  • 特别注意 @Service 注解的包是 org.springframework.stereotype.Service
  • 调用 MyBatis-Plus 的查询方法

controller（前端控制器）

  1. package com.zwc.base.controller;
  3. import com.zwc.base.dto.response.SpringbootBaseResponseDTO;
  4. import com.zwc.base.service.SpringbootBaseService;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import org.springframework.web.bind.annotation.ResponseBody;
  8. import org.springframework.web.bind.annotation.RestController;
  10. import java.util.List;
  12. /**
  13.  * @ClassName SpringbootBaseController
  14.  * @Desc TODO   地区表 前端控制器
  15.  * @Date 2019/4/6 14:41
  16.  * @Version 1.0
  17.  */
  18. @RestController
  19. @RequestMapping("base")
  20. public class SpringbootBaseController {
  22.     @Autowired
  23.     private SpringbootBaseService springbootBaseService;
  25.     /*
  26.      * @ClassName SpringbootBaseController
  27.      * @Desc TODO   获取全部地区
  28.      * @Date 2019/4/6 14:43
  29.      * @Version 1.0
  30.      */
  31.     @RequestMapping("/getAllBase")
  32.     @ResponseBody
  33.     public List<SpringbootBaseResponseDTO> getAllBase(){
  34.         return springbootBaseService.getAllBase();
  35.     }
  37. }
  • 使用 @Autowired 注解自动装配自己的服务

SpringBoot 启动类 

  1. package com.zwc;
  3. import com.alibaba.dubbo.config.spring.context.annotation.EnableDubbo;
  4. import org.mybatis.spring.annotation.MapperScan;
  5. import org.springframework.boot.SpringApplication;
  6. import org.springframework.boot.autoconfigure.SpringBootApplication;
  8. /*
  9.  * @ClassName SpringbootDubboBaseServiceCoreApplication
  10.  * @Desc TODO   启动类
  11.  * @Date 2019/4/6 15:12
  12.  * @Version 1.0
  13.  */
  14. @SpringBootApplication(scanBasePackages = "com.zwc")
  15. @MapperScan("com.zwc.base.mapper")
  16. @EnableDubbo
  17. public class SpringbootDubboBaseServiceCoreApplication {
  19.     public static void main(String[] args) {
  20.         SpringApplication.run(SpringbootDubboBaseServiceCoreApplication.class, args);
  21.     }
  23. }
  • 使用 @MapperScan 注解扫描 Mapper 接口
  • @EnableDubbo 注解一定要加，用来开启 Dubbo 服务

service 工程 - base-service - 启动项目

注：1. 项目启动前需要启动 zookeeper

2. 这里简单的体现了 Dubbo 的优势之一，非入侵式 ，高度解耦，不管消费者有没有启动，

提供者也可以启动起来，调用自己的服务

  1. 端口：8081（具体可以根据自己的喜好，在 application.properties 配置文件中配置 server.port）
  2. 查询全部地区信息接口：http://localhost:8081/base/getAllBase

Consumer（消费者）

service 工程 - user-service - user-service-core - POM 文件

  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>
  6.     <!-- 继承父 -->
  7.     <parent>
  8.         <groupId>com.zwc</groupId>
  9.         <artifactId>springboot-dubbo-user-service</artifactId>
  10.         <version>0.0.1-SNAPSHOT</version>
  11.     </parent>
  13.     <!-- 三坐标 -->
  14.     <groupId>com.zwc</groupId>
  15.     <artifactId>springboot-dubbo-user-service-core</artifactId>
  16.     <version>0.0.1-SNAPSHOT</version>
  18.     <!-- 工程名称描述 -->
  19.     <name>springboot-dubbo-user-service-core</name>
  20.     <description>用户服务工程 - 核心</description>
  22.     <!-- 打包方式 -->
  23.     <packaging>jar</packaging>
  25.     <!-- 在properties下声明相应的版本信息，然后在dependency下引用的时候用${spring-version}就可以引入该版本jar包了 -->
  26.     <properties>
  27.         <module.name>${project.artifactId}</module.name>
  28.     </properties>
  30.     <!-- 加入依赖 -->
  31.     <dependencies>
  32.         <!-- commons工程 依赖 -->
  33.         <dependency>
  34.             <groupId>com.zwc</groupId>
  35.             <artifactId>springboot-dubbo-commons</artifactId>
  36.             <version>0.0.1-SNAPSHOT</version>
  37.         </dependency>
  39.         <!-- api工程 依赖 -->
  40.         <dependency>
  41.             <groupId>com.zwc</groupId>
  42.             <artifactId>springboot-dubbo-user-service-api</artifactId>
  43.             <version>0.0.1-SNAPSHOT</version>
  44.         </dependency>
  45.         <dependency>
  46.             <groupId>com.zwc</groupId>
  47.             <artifactId>springboot-dubbo-base-service-api</artifactId>
  48.             <version>0.0.1-SNAPSHOT</version>
  49.         </dependency>
  50.     </dependencies>
  52.     <!-- 插件依赖 -->
  53.     <build>
  54.         <plugins>
  55.             <plugin>
  56.                 <groupId>org.springframework.boot</groupId>
  57.                 <artifactId>spring-boot-maven-plugin</artifactId>
  58.             </plugin>
  59.         </plugins>
  60.     </build>
  62. </project>
  • 需要引入 base-service-api 接口工程

service 工程 - user-service - user-service-core - application.properties 配置文件

  1. # 端口
  2. server.port=8082
  4. # 数据源
  5. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  6. spring.datasource.url=jdbc:mysql://127.0.0.1:3306/user_db?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&serverTimezone=PRC&useSSL=false
  7. spring.datasource.username=root
  8. spring.datasource.password=123456
  10. # 打印 sql 日志
  11. logging.level.com.zwc.user.mapper=debug
  13. # dubbo 配置
  14. ## 注册中心
  15. ### 注册中心的地址
  16. dubbo.registry.address=zookeeper://127.0.0.1:2181
  17. ## 提供方
  18. ### 提供方的项目名称
  19. dubbo.application.name=springboot-dubbo-user-service
  20. ## 超时时间
  21. dubbo.consumer.timeout=100000
  22. ## dubbo
  23. ### dubbo 的名称
  24. dubbo.protocol.name=dubbo
  25. ### dubbo 的端口（-1 表示随机端口号）
  26. dubbo.protocol.port=-1
  • user-service 工程连接的 user_db 数据库
  • 在 springboot-dubbo-user-service-core 工程的 resources 文件夹下有 application.properties 和 test_base.yml 文件
  • SpringBoot 会默认读取加载 resources 文件夹下的 application.properties 和 application.yml 文件里的配置信息
  • 源码中两种方式都有配置，效果一致；想使用哪种配置就把名称改成 application
  • 如果使用 .yml 文件，注意 .yml 文件需要去掉注释

service 工程 - user-service - user-service-core

service （自己的服务 ）

  1. package com.zwc.user.service;
  3. import com.alibaba.dubbo.config.annotation.Reference;
  4. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  5. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  6. import com.zwc.base.api.SpringbootBaseApi;
  7. import com.zwc.base.dto.response.SpringbootBaseResponseDTO;
  8. import com.zwc.user.domain.SpringbootUser;
  9. import com.zwc.user.dto.response.SpringbootUserResponseDTO;
  10. import com.zwc.user.mapper.SpringbootUserMapper;
  11. import org.springframework.beans.BeanUtils;
  12. import org.springframework.stereotype.Service;
  14. import javax.annotation.Resource;
  15. import java.util.ArrayList;
  16. import java.util.HashMap;
  17. import java.util.List;
  18. import java.util.Map;
  20. /**
  21.  * @ClassName SpringbootUserService
  22.  * @Desc TODO   用户表 实现服务类
  23.  * @Date 2019/4/6 15:16
  24.  * @Version 1.0
  25.  */
  26. @Service
  27. public class SpringbootUserService extends ServiceImpl<SpringbootUserMapper,SpringbootUser> {
  29.     @Resource
  30.     private SpringbootUserMapper springbootUserMapper;
  32.     // 引入 base - service 工程的接口
  33.     @Reference
  34.     private SpringbootBaseApi springbootBaseApi;
  36.     /*
  37.      * @ClassName SpringbootUserService
  38.      * @Desc TODO   获取全部用户
  39.      * @Date 2019/4/6 15:18
  40.      * @Version 1.0
  41.      */
  42.     public List<SpringbootUserResponseDTO> getAllUser(){
  43.         // 返回
  44.         List<SpringbootUserResponseDTO> result = new ArrayList<>();
  45.         // 调用查询
  46.         List<SpringbootUser> list = super.list(new QueryWrapper<>());
  47.         // 遍历结果
  48.         list.forEach(user -> {
  49.             SpringbootUserResponseDTO springbootUserResponseDTO = new SpringbootUserResponseDTO();
  50.             // 复值
  51.             BeanUtils.copyProperties(user,springbootUserResponseDTO);
  52.             // 添加到返回集合中
  53.             result.add(springbootUserResponseDTO);
  54.         });
  56.         // 返回
  57.         return result;
  58.     }
  61.     /*
  62.      * @ClassName SpringbootUserService
  63.      * @Desc TODO   获取全部地区（调用 base - service 接口）
  64.      * @Date 2019/4/6 15:36
  65.      * @Version 1.0
  66.      */
  67.     public List<SpringbootBaseResponseDTO> getAllBase(){
  68.         // 调用 base - service 工程的接口
  69.         List<SpringbootBaseResponseDTO> result = springbootBaseApi.getAllBase();
  70.         // 返回
  71.         return result;
  72.     }
  74.     /*
  75.      * @ClassName SpringbootUserService
  76.      * @Desc TODO   获取全部用户详情信息
  77.      * @Date 2019/4/6 23:11
  78.      * @Version 1.0
  79.      */
  80.     public List<Map<String,Object>> getDetailInfo(){
  81.         // 返回对象
  82.         List<Map<String,Object>> result = new ArrayList<>();
  83.         // 调用查询 获取全部用户信息
  84.         List<SpringbootUser> userList = super.list(new QueryWrapper<>());
  85.         // 调用接口 获取全部地区信息
  86.         List<SpringbootBaseResponseDTO> baseList = springbootBaseApi.getAllBase();
  88.         // 遍历所有用户
  89.         userList.forEach(user -> {
  90.             // 一个用户存一个 map
  91.             Map<String,Object> map = new HashMap<>();
  92.             map.put("id",user.getId());
  93.             map.put("name",user.getName());
  94.             // 遍历所有地区
  95.             baseList.forEach(base -> {
  96.                 if(user.getRegoinId() == base.getId()){
  97.                     map.put("area",base.getRegionName());
  98.                 }
  99.             });
  100.             // 放入返回集合对象中
  101.             result.add(map);
  102.         });
  104.         // 返回结果
  105.         return result;
  106.     }
  108. }
  • 特别注意 @Service 注解的包是 org.springframework.stereotype.Service
  • 特别注意 @Reference 注解的包是 com.alibaba.dubbo.config.annotation.Reference;

  • 使用 @Reference 注解到 Dubbo 中引入需要的服务

    controller（前端控制器）

    package com.zwc.user.controller;

    import com.zwc.base.dto.response.SpringbootBaseResponseDTO;
    import com.zwc.user.dto.response.SpringbootUserResponseDTO;
    import com.zwc.user.service.SpringbootUserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.RestController;

    import java.util.List;
    import java.util.Map;

    /**

    • @ClassName SpringbootUserController
    • @Desc TODO 用户表 前端控制器
    • @Date 2019/4/6 15:22

    • @Version 1.0
      */
      @RestController
      @RequestMapping(“user”)
      public class SpringbootUserController {

      @Autowired
      private SpringbootUserService springbootUserService;

      /*

      • @ClassName SpringbootUserController
      • @Desc TODO 获取全部用户
      • @Date 2019/4/6 15:24

      • @Version 1.0
        */
        @RequestMapping(“/getAllUser”)
        @ResponseBody
        public List getAllUser(){
        return springbootUserService.getAllUser();
        }

        /*

      • @ClassName SpringbootUserController
      • @Desc TODO 获取全部地区（调用 base - service 接口）
      • @Date 2019/4/6 15:37

      • @Version 1.0
        */
        @RequestMapping(“/getAllBaseInUser”)
        @ResponseBody
        public List getAllBase(){
        return springbootUserService.getAllBase();
        }

        /*

      • @ClassName SpringbootUserController
      • @Desc TODO 获取全部用户详情信息
      • @Date 2019/4/6 23:18
      • @Version 1.0
        */
        @RequestMapping(“/getDetailInfo”)
        @ResponseBody
        public List> getDetailInfo(){
        return springbootUserService.getDetailInfo();
        }

    }

  • 使用 @Autowired 注解自动装配自己的服务

    SpringBoot 启动类

    package com.zwc;

    import com.alibaba.dubbo.config.spring.context.annotation.EnableDubbo;
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;

    /*

    • @ClassName SpringbootDubboUserServiceCoreApplication
    • @Desc TODO 启动类
    • @Date 2019/4/6 15:12

    • @Version 1.0
      */
      @SpringBootApplication(scanBasePackages = “com.zwc”)
      @MapperScan(“com.zwc.user.mapper”)
      @EnableDubbo
      public class SpringbootDubboUserServiceCoreApplication {

      public static void main(String[] args) {

      1.  SpringApplication.run(SpringbootDubboUserServiceCoreApplication.class, args);

      }

    }

  • 使用 @MapperScan 注解扫描 Mapper 接口

  • @EnableDubbo 注解一定要加，用来开启 Dubbo 服务

service 工程 - user-service - 启动项目

注：1. 项目启动前需要启动 zookeeper

2. 这里简单的体现了 Dubbo 的优势之一，非入侵式 ，高度解耦，不管提供者有没有启动，

消费者也可以启动起来，调用自己的服务

  1. 端口：8082（具体可以根据自己的喜好，在 application.properties 配置文件中配置 server.port）
  2. 查询全部用户信息接口：http://localhost:8082/user/getAllUser

service 工程 - 启动提供者和消费者

注：项目启动前需要启动 zookeeper

  1. 启动 SpringbootDubboBaseServiceCoreApplication

端口：8081

接口：http://localhost:8081/base/getAllBase （查询全部地区信息接口，可单独调用）

  1. 启动 SpringbootDubboUserServiceCoreApplication

端口：8082

接口：http://localhost:8082/user/getAllUser（查询全部用户信息接口，可单独调用）

  1. 接口：http://localhost:8082/user/getAllBaseInUser（获取全部地区信息，注意端口为 8082，

在 user-service 工程中调用了 base-service 工程的接口，体现了 Dubbo 的作用）

dubbo-admin：查看服务调用情况（本文文末处有扩展介绍如何在本地启动 dubbo-admin）

当启动了 base-service 后可在 Dubbo Admin 服务中看到一个服务接口，状态为：没有消费者

20190408092513933.png

当再启动 user-service 后可在 Dubbo Admin 服务中看到上面的服务接口被调用了，状态为：正常

20190408092843116.png

service 工程 - 项目结构

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDAyMjAw_size_16_color_FFFFFF_t_70 1

  • 在 service 总工程中创建了 base-service （基础模块）和 user-service（用户模块）
  • 每一个模块中都包含 api 和 core

把多工程项目使用 IntelliJ IDEA 打开

  1. 把项目从 GitHub 中下载到你的本地
  2. 打开 IntelliJ IDEA
  3. 点击 File -> Open
  4. 打开你下载到本地的项目目录
  5. springboot-dubbo -> springboot-dubbo-service（选择打开此工程）
  6. 打开 service 工程后
  7. 再次点击 File -> Project Structrue
  8. 选择 Modules，点击 ‘+’ 符号
  9. 点击 Import Module
  10. 还是打开你下载到本地的项目目录
  11. springboot-dubbo -> springboot-dubbo-commons -> pom.xml
  12. 点击 OK
  13. 点击 Next，Finish
  14. 点击 Apply，OK

扩展

如何在本地启动 dubbo-admin

dubbo-admin 可把注册到 Zookeeper 中的服务更友好的展示出来，可以清楚的观察服务接口的使用情况和状态

  1. 前往 GitHub 中获取源码：https://github.com/apache/incubator-dubbo

  2. 版本有很多，这里选择 2.6.0 版本的（点击 Branch:master -> Tags -> dubbo-2.6.0）

    watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDAyMjAw_size_16_color_FFFFFF_t_70 2

  3. 点击 Clone or download -> Download ZIP，保存到本地

    watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDAyMjAw_size_16_color_FFFFFF_t_70 3

  4. 解压刚刚下载压缩包（incubator-dubbo-dubbo-2.6.0.zip）

  5. 下载 maven 并配置环境变量

  6. 打开 cmd，进入到解压文件 dubbo-admin 目录

假如把文件解压到了 D 盘更目录，步骤为

a) 输入指令 D: ，回车

b) 输入指令 cd incubator-dubbo-dubbo-2.6.0\dubbo-admin，回车

  1. 输入指令 mvn package，如果出现 BUILD SUCCESS 就证明打包成功

  2. 本地打开 此电脑 -> D 盘 -> incubator-dubbo-dubbo-2.6.0 -> dubbo-admin，会看到一个 target 文件夹

  3. 打开 target 文件夹，会看到一个 dubbo-admin-2.6.0.war 文件

    1. 下载或者解压一个新的 Tomcat8，重命名为 tomcat-dubbo

    2. 把步骤 9 中的 dubbo-admin-2.6.0.war 文件复制到步骤 10 中的 tomcat-dubbo/webapps 文件夹中

    3. 打开步骤 10 中的 tomcat-dubbo/bin，双击 startup.bat 文件启动 tomcat（执行此步骤时最好启动 zookeeper）

    4. tomcat 启动成功后，访问地址：http://localhost:8080/dubbo-admin-2.6.0/

    5. 进入时需要输入用户名密码，默认都为 root

    6. 成功进入 Dubbo Admin 的界面如下

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDAyMjAw_size_16_color_FFFFFF_t_70 4

结语

到此 SpringBoot 整合 Dubbo 就结束了，注意几个关键的点，多多尝试，一定会成功的！

希望能够帮助到你

over

发表评论

表情：
评论列表 （有 0 条评论，213人围观）

还没有评论，来说两句吧...

相关阅读

    相关 SpringBoot整合Dubbo

    Dubbo简介 Dubbo是Alibaba开源的分布式服务框架，它最大的特点是按照分业务的架构，使用这种方式可以使各个业务之间解耦合（或者最大限度地松耦合）。 简单来说

    叁歲伎倆叁歲伎倆/ 0 赞/ 293 阅读

    相关 SpringBoot整合dubbo

    SpringBoot整合dubbo Dubbo是阿里巴巴公司开源的一个高性能优秀的服务框架，使得应用可通过高性能的 RPC 实现服务的输出和输入功能，可以和Spring框

    墨蓝墨蓝/ 0 赞/ 356 阅读

    相关 springboot整合dubbo

    本文主要通过代码示例来说明springboot和dubbo的整合方式 以下是核心代码示例，其他的资源整合配置和spring+Dubbo相同 声明下：dubbo网址在下面配

    心已赠人心已赠人/ 0 赞/ 376 阅读

    相关 SpringBoot整合Dubbo

    前言   Dubbo 是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。   简单来说，Dubbo 用于分布式的场景。

    亦凉亦凉/ 0 赞/ 214 阅读

    相关 SpringBoot整合dubbo

    1.什么是Dubbo Dubbo是Alibaba开源的分布式服务框架，它最大的特点是按照分层的方式来架构，使用这种方式可以使各个层之间解耦合（或者最大限度地松耦合）。从服

    女爷i女爷i/ 0 赞/ 1124 阅读