SpringBoot整合Dubbo

最新推荐文章于 2024-08-01 22:42:00 发布
最新推荐文章于 2024-08-01 22:42:00 发布
阅读量1.3w 收藏 57
点赞数 14
分类专栏： SpringBoot 文章标签： SpringBoot Dubbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41402200/article/details/89072962
版权

前言

  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

USE base_db;
DROP TABLE IF EXISTS `springboot_base` ;
CREATE TABLE `springboot_base` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `parent_id` bigint(20) unsigned DEFAULT '0' COMMENT '父 id',
	`region_name` varchar(20) DEFAULT NULL COMMENT '地区名',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=COMPACT COMMENT='地区表';

INSERT INTO springboot_base ( parent_id , region_name )
VALUES ('0','上海市'),('1','嘉定区'),('1','松江区'),('1','黄浦区');
USE user_db;
DROP TABLE IF EXISTS `springboot_user` ;
CREATE TABLE `springboot_user` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `regoin_id` bigint(20) unsigned DEFAULT '0' COMMENT '地区 id',
	`name` varchar(20) DEFAULT NULL COMMENT '姓名',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=COMPACT COMMENT='用户表';

INSERT INTO springboot_user ( regoin_id , name )
VALUES (3,'cdy'),(4,'zwc'),(2,'ergouzi');

正文

commons 工程 - 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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- 三坐标 -->
    <groupId>com.zwc</groupId>
    <artifactId>springboot-dubbo-commons</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <!-- 工程名称和描述 -->
    <name>springboot-dubbo-commons</name>
    <description>公用工程</description>

    <!-- 打包方式 -->
    <packaging>jar</packaging>

    <!-- 在properties下声明相应的版本信息，然后在dependency下引用的时候用${spring-version}就可以引入该版本jar包了 -->
    <properties>
        <!-- 编码 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- jdk -->
        <java.version>1.8</java.version>

        <!-- springboot -->
        <platform-bom.version>Cairo-SR3</platform-bom.version>

        <!-- ali 连接池 -->
        <druid.version>1.1.9</druid.version>
        <!-- ali json -->
        <fastjson.version>1.2.47</fastjson.version>
        <jackson.mapper.asl.version>1.9.9</jackson.mapper.asl.version>

        <!-- mybatis -->
        <mybatis-plus-boot-starter.version>3.0-RELEASE</mybatis-plus-boot-starter.version>
        <mybatis-spring-boot-starter.version>1.3.2</mybatis-spring-boot-starter.version>
        <mybatis.ehcache.version>1.1.0</mybatis.ehcache.version>

        <!-- dubbo -->
        <dubbo-spring-boot-starter.version>0.2.0</dubbo-spring-boot-starter.version>
    </properties>

    <!-- 加入依赖 -->
    <dependencies>
        <!-- ali 连接池依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid.version}</version>
        </dependency>

        <!-- mysql 依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!-- ali json依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>${jackson.mapper.asl.version}</version>
        </dependency>

        <!-- mybatis 依赖 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis-spring-boot-starter.version}</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus-boot-starter.version}</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.caches</groupId>
            <artifactId>mybatis-ehcache</artifactId>
            <version>${mybatis.ehcache.version}</version>
        </dependency>

        <!-- dubbo 依赖 -->
        <dependency>
            <groupId>com.alibaba.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>${dubbo-spring-boot-starter.version}</version>
        </dependency>
    </dependencies>

    <!-- 依赖 jar 包版本管理的管理器 -->
    <!-- 如果 dependencies 里的 dependency 自己没有声明 version 元素，那么 maven 就此处来找版本声明。 -->
    <!-- 如果有，就会继承它；如果没有就会报错，告诉你没有版本信息 -->
    <!-- 优先级：如果 dependencies 里的 dependency 已经声明了版本信息，就不会生效此处的版本信息了 -->
    <dependencyManagement>
        <dependencies>
            <!-- SpringBoot -->
            <dependency>
                <groupId>io.spring.platform</groupId>
                <artifactId>platform-bom</artifactId>
                <version>${platform-bom.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 插件依赖 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
  • 配置一些共用依赖，其中包括 dubbo-spring-boot-starter 依赖来整合 Dubbo

commons 工程 - system.properties

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

commons 工程 - 自定义配置

package com.zwc.core.config;

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

/*
 * @ClassName MyBatisPlusConfig
 * @Desc TODO   mybatis-plus 配置
 * @Date 2019/4/6 10:21
 * @Version 1.0
 */
@Configuration
@PropertySource("classpath:system.properties")
public class MyBatisPlusConfig {

    /*
     * @ClassName MyBatisPlusConfig
     * @Desc TODO   mybatis-plus 配置拦截
     * @Date 2019/4/6 10:21
     * @Version 1.0
     */
    @Bean
    public PaginationInterceptor paginationInterceptor(){
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置方言
        paginationInterceptor.setDialectType("mysql");
        return paginationInterceptor;
    }

}
  • 注意这里在注入类的时候，还要加载自定的配置文件，因为 SpringBoot 不会默认加载 system.properties
  • 配置了 MyBatis-Plus 的分页插件，方言为 MySQL

commons 工程 - 项目结构 

 

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 配置文件

# 端口
server.port=8081

# 数据源
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/base_db?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&serverTimezone=PRC&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456

# 打印 sql 日志
logging.level.com.zwc.base.mapper=debug

# dubbo 配置
## 注册中心
### 注册中心的地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
## 提供方
### 提供方的项目名称
dubbo.application.name=springboot-dubbo-base-service
## 超时时间
dubbo.consumer.timeout=100000
## dubbo
### dubbo 的名称
dubbo.protocol.name=dubbo
### dubbo 的端口（-1 表示随机端口号）
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 接口

package com.zwc.base.api;

import com.zwc.base.dto.response.SpringbootBaseResponseDTO;

import java.util.List;

/**
 * @ClassName SpringbootBaseApi
 * @Desc TODO   地区表 服务类
 * @Date 2019/4/6 14:19
 * @Version 1.0
 */
public interface SpringbootBaseApi {

    // 获取全部地区
    List<SpringbootBaseResponseDTO> getAllBase();

}
  •  对外暴露的接口

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

  api 接口实现类

package com.zwc.base.api.impl;

import com.alibaba.dubbo.config.annotation.Service;
import com.zwc.base.api.SpringbootBaseApi;
import com.zwc.base.dto.response.SpringbootBaseResponseDTO;
import com.zwc.base.service.SpringbootBaseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @ClassName SpringbootBaseApiImpl
 * @Desc TODO   地区表 服务实现类
 * @Date 2019/4/6 14:25
 * @Version 1.0
 */
@Service(interfaceClass = SpringbootBaseApi.class)
public class SpringbootBaseApiImpl implements SpringbootBaseApi {

    @Autowired
    private SpringbootBaseService springbootBaseService;

    /*
     * @ClassName SpringbootBaseApiImpl
     * @Desc TODO   获取全部地区
     * @Date 2019/4/6 14:28
     * @Version 1.0
     */
    @Override
    public List<SpringbootBaseResponseDTO> getAllBase() {
        return springbootBaseService.getAllBase();
    }

}
  • 特别注意 @Service 注解的包是 com.alibaba.dubbo.config.annotation.Service
  • SpringbootBaseApi 类是 base-service-api 工程中的 api 接口
  • springbootBaseService 类是 base-service-core 工程中自己的服务

  service （自己的服务 ）

package com.zwc.base.service;

import com.alibaba.dubbo.config.annotation.Reference;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zwc.base.domain.SpringbootBase;
import com.zwc.base.dto.response.SpringbootBaseResponseDTO;
import com.zwc.base.mapper.SpringbootBaseMapper;
import com.zwc.user.api.SpringbootUserApi;
import com.zwc.user.dto.response.SpringbootUserResponseDTO;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName SpringbootBaseService
 * @Desc TODO   地区表 实现服务类
 * @Date 2019/4/6 14:04
 * @Version 1.0
 */
@Service
public class SpringbootBaseService extends ServiceImpl<SpringbootBaseMapper,SpringbootBase> {

    @Resource
    private SpringbootBaseMapper springbootBaseMapper;

    /*
     * @ClassName SpringbootBaseService
     * @Desc TODO   获取全部地区
     * @Date 2019/4/6 14:31
     * @Version 1.0
     */
    public List<SpringbootBaseResponseDTO> getAllBase(){
        // 返回
        List<SpringbootBaseResponseDTO> result = new ArrayList<>();
        // 调用查询
        List<SpringbootBase> list = super.list(new QueryWrapper<>());
        // 遍历结果
        list.forEach(base -> {
            SpringbootBaseResponseDTO springbootBaseResponseDTO = new SpringbootBaseResponseDTO();
            // 复值
            BeanUtils.copyProperties(base,springbootBaseResponseDTO);
            // 添加到返回集合中
            result.add(springbootBaseResponseDTO);
        });

        // 返回
        return result;
    }

}
  • 特别注意 @Service 注解的包是 org.springframework.stereotype.Service
  • 调用 MyBatis-Plus 的查询方法

   controller（前端控制器）

package com.zwc.base.controller;

import com.zwc.base.dto.response.SpringbootBaseResponseDTO;
import com.zwc.base.service.SpringbootBaseService;
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;

/**
 * @ClassName SpringbootBaseController
 * @Desc TODO   地区表 前端控制器
 * @Date 2019/4/6 14:41
 * @Version 1.0
 */
@RestController
@RequestMapping("base")
public class SpringbootBaseController {

    @Autowired
    private SpringbootBaseService springbootBaseService;

    /*
     * @ClassName SpringbootBaseController
     * @Desc TODO   获取全部地区
     * @Date 2019/4/6 14:43
     * @Version 1.0
     */
    @RequestMapping("/getAllBase")
    @ResponseBody
    public List<SpringbootBaseResponseDTO> getAllBase(){
        return springbootBaseService.getAllBase();
    }

}
  • 使用 @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 SpringbootDubboBaseServiceCoreApplication
 * @Desc TODO   启动类
 * @Date 2019/4/6 15:12
 * @Version 1.0
 */
@SpringBootApplication(scanBasePackages = "com.zwc")
@MapperScan("com.zwc.base.mapper")
@EnableDubbo
public class SpringbootDubboBaseServiceCoreApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootDubboBaseServiceCoreApplication.class, args);
    }

}
  • 使用 @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 文件

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- 继承父 -->
    <parent>
        <groupId>com.zwc</groupId>
        <artifactId>springboot-dubbo-user-service</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <!-- 三坐标 -->
    <groupId>com.zwc</groupId>
    <artifactId>springboot-dubbo-user-service-core</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <!-- 工程名称描述 -->
    <name>springboot-dubbo-user-service-core</name>
    <description>用户服务工程 - 核心</description>

    <!-- 打包方式 -->
    <packaging>jar</packaging>

    <!-- 在properties下声明相应的版本信息，然后在dependency下引用的时候用${spring-version}就可以引入该版本jar包了 -->
    <properties>
        <module.name>${project.artifactId}</module.name>
    </properties>

    <!-- 加入依赖 -->
    <dependencies>
        <!-- commons工程 依赖 -->
        <dependency>
            <groupId>com.zwc</groupId>
            <artifactId>springboot-dubbo-commons</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <!-- api工程 依赖 -->
        <dependency>
            <groupId>com.zwc</groupId>
            <artifactId>springboot-dubbo-user-service-api</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.zwc</groupId>
            <artifactId>springboot-dubbo-base-service-api</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <!-- 插件依赖 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
  • 需要引入 base-service-api 接口工程

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

# 端口
server.port=8082

# 数据源
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/user_db?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&serverTimezone=PRC&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456

# 打印 sql 日志
logging.level.com.zwc.user.mapper=debug

# dubbo 配置
## 注册中心
### 注册中心的地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
## 提供方
### 提供方的项目名称
dubbo.application.name=springboot-dubbo-user-service
## 超时时间
dubbo.consumer.timeout=100000
## dubbo
### dubbo 的名称
dubbo.protocol.name=dubbo
### dubbo 的端口（-1 表示随机端口号）
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 （自己的服务 ）

package com.zwc.user.service;

import com.alibaba.dubbo.config.annotation.Reference;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zwc.base.api.SpringbootBaseApi;
import com.zwc.base.dto.response.SpringbootBaseResponseDTO;
import com.zwc.user.domain.SpringbootUser;
import com.zwc.user.dto.response.SpringbootUserResponseDTO;
import com.zwc.user.mapper.SpringbootUserMapper;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @ClassName SpringbootUserService
 * @Desc TODO   用户表 实现服务类
 * @Date 2019/4/6 15:16
 * @Version 1.0
 */
@Service
public class SpringbootUserService extends ServiceImpl<SpringbootUserMapper,SpringbootUser> {

    @Resource
    private SpringbootUserMapper springbootUserMapper;

    // 引入 base - service 工程的接口
    @Reference
    private SpringbootBaseApi springbootBaseApi;

    /*
     * @ClassName SpringbootUserService
     * @Desc TODO   获取全部用户
     * @Date 2019/4/6 15:18
     * @Version 1.0
     */
    public List<SpringbootUserResponseDTO> getAllUser(){
        // 返回
        List<SpringbootUserResponseDTO> result = new ArrayList<>();
        // 调用查询
        List<SpringbootUser> list = super.list(new QueryWrapper<>());
        // 遍历结果
        list.forEach(user -> {
            SpringbootUserResponseDTO springbootUserResponseDTO = new SpringbootUserResponseDTO();
            // 复值
            BeanUtils.copyProperties(user,springbootUserResponseDTO);
            // 添加到返回集合中
            result.add(springbootUserResponseDTO);
        });

        // 返回
        return result;
    }


    /*
     * @ClassName SpringbootUserService
     * @Desc TODO   获取全部地区（调用 base - service 接口）
     * @Date 2019/4/6 15:36
     * @Version 1.0
     */
    public List<SpringbootBaseResponseDTO> getAllBase(){
        // 调用 base - service 工程的接口
        List<SpringbootBaseResponseDTO> result = springbootBaseApi.getAllBase();
        // 返回
        return result;
    }

    /*
     * @ClassName SpringbootUserService
     * @Desc TODO   获取全部用户详情信息
     * @Date 2019/4/6 23:11
     * @Version 1.0
     */
    public List<Map<String,Object>> getDetailInfo(){
        // 返回对象
        List<Map<String,Object>> result = new ArrayList<>();
        // 调用查询 获取全部用户信息
        List<SpringbootUser> userList = super.list(new QueryWrapper<>());
        // 调用接口 获取全部地区信息
        List<SpringbootBaseResponseDTO> baseList = springbootBaseApi.getAllBase();

        // 遍历所有用户
        userList.forEach(user -> {
            // 一个用户存一个 map
            Map<String,Object> map = new HashMap<>();
            map.put("id",user.getId());
            map.put("name",user.getName());
            // 遍历所有地区
            baseList.forEach(base -> {
                if(user.getRegoinId() == base.getId()){
                    map.put("area",base.getRegionName());
                }
            });
            // 放入返回集合对象中
            result.add(map);
        });

        // 返回结果
        return result;
    }

}
  • 特别注意 @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<SpringbootUserResponseDTO> getAllUser(){
        return springbootUserService.getAllUser();
    }

    /*
     * @ClassName SpringbootUserController
     * @Desc TODO   获取全部地区（调用 base - service 接口）
     * @Date 2019/4/6 15:37
     * @Version 1.0
     */
    @RequestMapping("/getAllBaseInUser")
    @ResponseBody
    public List<SpringbootBaseResponseDTO> getAllBase(){
        return springbootUserService.getAllBase();
    }

    /*
     * @ClassName SpringbootUserController
     * @Desc TODO   获取全部用户详情信息
     * @Date 2019/4/6 23:18
     * @Version 1.0
     */
    @RequestMapping("/getDetailInfo")
    @ResponseBody
    public List<Map<String,Object>> 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) {
        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 （查询全部地区信息接口，可单独调用）

   2. 启动 SpringbootDubboUserServiceCoreApplication

端口：8082

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

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

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

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

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

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

service 工程 - 项目结构

  • 在 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）

      

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

      

  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，回车

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

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

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

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

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

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

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

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

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

 

结语

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

 

希望能够帮助到你

over

 

 

 

intomylife
关注
专栏目录
springboot+dubbo完整项目案例
06-11
该项目代码，是我自己整理的一套springboot+dubbo开发的一个案例，基本的生产者消费者注册中心都已经开发好了，其中dubbo-admin需要自行打包运行
springboot整合dubbo
07-04
SpringBoot整合Dubbo是现代Java开发中常见的微服务架构实践，SpringBoot以其便捷的配置和快速启动特性，深受开发者喜爱，而Dubbo作为阿里巴巴开源的高性能服务框架，为分布式服务治理提供了强大的支持。本文将详细...
高效开发 Dubbo？用 Spring Boot 可得劲！
weixin_33806914的博客
01-10 308
不仅简化了 Dubbo 基于 xml 配置的方式，也提高了日常开发效率，甚至提升了工作幸福感。 为了节省亲爱的读者您的时间，请根据以下2点提示来阅读本文，以提高您的阅读收获效率哦。 如果您只有简单的 Java 基础和 Maven 经验，而不熟悉 Dubbo，本文档将帮助您从零开始使用 Spring Boot 开发 Dubbo 服务，并使用 EDAS 服务...
Spring Boot 整合 Dubbo3 + Nacos 2.4.0
最新发布
小天一直在路上
08-01 1004
Nacos 作为 Dubbo 生态系统中重要的注册中心实现，本文将会介绍如何进行 Dubbo 对接 Nacos 注册中心的工作。
Spring Boot 中使用 Dubbo 详解
2401_84010457的博客
04-18 3321
很多程序员，整天沉浸在业务代码的 CRUD 中，业务中没有大量数据做并发，缺少实战经验，对并发仅仅停留在了解，做不到精通，所以总是与大厂擦肩而过。我把私藏的这套并发体系的笔记和思维脑图分享出来，理论知识与项目实战的结合，我觉得只要你肯花时间用心学完这些，一定可以快速掌握并发编程。《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！（备注Java获取）**
Springboot+Dubbo
yrj520bd的博客
11-18 295
首先先介绍一下Dubbo,Dubbo是阿里巴巴公司开源的一个高性能优秀的服务治理框架，使得应用可通过高性能的 RPC 实现服务的输出和输入功能，可以和Spring框架无缝集成。其在github上的网址为https://github.com/alibaba/dubbo-spring-boot-starter。Dubbo的主要架构如下图所示： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下...
SpringBoot——SpringBoot集成Dubbo
★★光亭★★
05-29 8484
SpringBoot——SpringBoot集成Dubbo
SpringBoot整合Dubbo项目
06-12
SpringBoot整合Dubbo项目是一个将流行的微服务框架Dubbo与SpringBoot结合的示例工程，旨在简化服务的开发和部署过程。SpringBoot以其简洁的配置和自动配置特性，极大地提升了开发效率，而Dubbo作为阿里巴巴开源的...
SpringBoot整合Dubbo案例
06-14
首先，我们来看标题"SpringBoot整合Dubbo案例"，这暗示我们需要在SpringBoot项目中引入Dubbo的服务治理功能。SpringBoot的优势在于其自动配置和起步驱动开发的理念，使得开发者无需繁琐的XML配置，即可快速构建应用...
SpringBoot整合dubbo2.7.8+zookeeper3.4.14
01-27
本文将深入探讨如何将SpringBoot 2.4.2与Dubbo 2.7.8以及Zookeeper 3.4.14整合，帮助初学者快速入门。 首先，SpringBoot是由Pivotal团队开发的一个框架，它简化了Spring应用的初始搭建和配置过程。通过内置的Tomcat...
SpringBoot整合Dubbo和Zookeeper升级版
11-09
"SpringBoot整合Dubbo和Zookeeper升级版"的主题，意味着我们将探讨如何在一个更新的环境中，利用这些技术构建高效、可扩展的服务。 首先，SpringBoot是一个基于Spring框架的快速开发工具，它简化了配置并提供了自动...
Springboot集成dubbo
u011967767的博客
04-29 1835
Dubbo是Alibaba开源的分布式服务框架，它最大的特点是按照分层的方式来架构，使用这种方式可以使各个层之间解耦合（或者最大限度地松耦合）。从服务模型的角度来看，Dubbo采用的是一种非常简单的模型，要么是提供方提供服务，要么是消费方消费服务，所以基于这一点可以抽象出服务提供方（Provider）和服务消费方（Consumer）两个角色。 Dubbo 的RPC 调用流程主要涉及到4个模块： 1、Registry：服务注册，我们一般会采取Zookeeper 作为我们的注册中心 2、Provider：服务
SpringBoot+Dubbo简单整合
caoweifeng12的博客
05-15 336
SpringBoot+Dubbo整合 一、创建用户微服务 1、新建SpringBoot jar工程 创建SpringBoot项目。支持SSM+Thymeleaf模版页面。 实现功能： 根据用户ID查询用户信息 2、完整POM.xml <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</a
dubbo的springboot集成
M先生的博客
01-09 1347
Apache Dubbo 是一款 RPC 服务开发框架，用于解决微服务架构下的服务治理与通信问题，官方提供了 Java、Golang 等多语言 SDK 实现。使用 Dubbo 开发的微服务原生具备相互之间的远程地址发现与通信能力， 利用 Dubbo 提供的丰富服务治理特性，可以实现诸如服务发现、负载均衡、流量调度等服务治理诉求。Dubbo 被设计为高度可扩展，用户可以方便的实现流量拦截、选址的各种定制逻辑。
牛刀与小试-dubbo+spring-boot
IT小生
01-17 1775
前言篇上周末，也不无聊早在11月份学习过一点spring-boot微框架不过只是 a little 一点点了解而已一直以来都想用于实战，苦于没有机会刚好这周末兴起就熬夜自己瞎搞了一把使用基于dubbo+spring-boot+mybatis+redis+zookeeper搭了一套脚手架子可能会比较low但毕竟是玩玩，敢于尝试毕竟是件好事 项目结构 ···product-client-test
Springboot+Dubbo+zookeeper整合
daobaliangbanana2的博客
06-21 2666
软件版本：Springboot2.0Dubbo2.6zookeeper3.4.6废话少说，正式开始。Step1：创建项目：使用maven新建一个DubboExample的pom工程，然后在这个parent项目下面创建三个module项目，一个DubboProvider，一个DubboConsumer，一个DubboCommon。上图：创建DubboExample父项目上图：创建好后的项目。右键点击...
springBoot 打包 dubbo jar包
weixin_30485799的博客
09-24 264
参看链接：http://blog.csdn.net/cqdz_dj/article/details/51942681 http://blog.csdn.net/u014695188/article/details/53128006 转载于:https://www.cnblogs.com/chen-msg/p/7586811.html
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值