SpringBoot集成Dubbo

一、基本步骤

1. Dubbo服务接口

创建一个接口项目，12-springboot-dubbo-interface，该项目只定义接口和model类

1、创建普通的Maven项目，dubbo服务接口工程

2、创建 UserService 接口

创建service包，在这个包下写

package service;

/**
 * @author MD
 * @create 2020-08-22 6:31
 */
public interface StudentService {

    /**
     * 获取学生总人数
     * @return
     */
    Integer queryAllStudentCount();
}

2. Dubbo服务提供者

创建 SpringBoot 框架的 WEB 项目，13-springboot-dubbo-provider

2、依赖

加入 Dubbo 集成 SpringBoot 的起步依赖

由于使用 zookeeper 作为注册中心，需加入 zookeeper 的客户端

加入 Dubbo 接口依赖

<!--Dubbo 集成 SpringBoot 框架起步依赖-->
<dependency>
<groupId>com.alibaba.spring.boot</groupId>
<artifactId>dubbo-spring-boot-starter</artifactId>
<version>2.0.0</version>
</dependency>
<!--Zookeeper 客户端依赖-->
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.10</version>
        </dependency>
<!--dubbo接口依赖-->
        <dependency>
            <groupId>com.md.springboot</groupId>
            <artifactId>12-springboot-dubbo-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

3、在Springboot 的核心配置文件

application.properties中配置 dubbo

#设置内嵌Tomcat
server.port=8081
#设置上下文根
server.servlet.context-path=/


#配置 dubbo 的服务提供者信息
#服务提供者应用名称(必须写，且不能重复)
spring.application.name=springboot-dubbo-provider
#设置当前工程为服务提供者
spring.dubbo.server=true
#设置注册中心
spring.dubbo.registry=zookeeper://localhost:2181

注意：Dubbo 的 的注解都是自定义的注解，由我们添加的 Dubbo 依赖中的类 进行 处理 编写dubbo 配置是没有提示的

4、编写 Dubbo 的接口实现类，并暴露接口

在com.md.springboot.service.impl下面

package com.md.springboot.service.impl;

import com.alibaba.dubbo.config.annotation.Service;
import org.springframework.stereotype.Component;

import service.StudentService;


/**
 * @author MD
 * @create 2020-08-22 6:46
 */
@Component
// 也可以这样写，写接口的权限定类名
//@Service(interfaceName ="com.md.springboot.service.StudentService",version = "1.0.0",timeout= 15000)
//暴露出接口的类名.class，版本号，
@Service(interfaceClass = StudentService.class,version = "1.0.0",timeout = 15000)
public class StudentServiceImpl implements StudentService {

    @Override
    public Integer queryAllStudentCount() {

        //调用数据持久层，经过一系列操之后得到学生总人数

        return 200;
    }
}

注意使用service注解的时候：使用alibaba的这个

5、SpringBoot 入口 程序启 类上加开启 Dubbo 配置支持注解

package com.md.springboot;

import com.alibaba.dubbo.spring.boot.annotation.EnableDubboConfiguration;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableDubboConfiguration // 开启Dubbo配置
public class Application {

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

}

3. Dubbo服务消费者

创建 SpringBoot 框架的 WEB 项目，14-springboot-dubbo-comsumer

2、依赖pom.xml

加入 Dubbo 集成 SpringBoot 的起步依赖

由于使用 zookeeper 作为注册中心，需加入 zookeeper 的客户端

加入 Dubbo 接口依赖

<!--Dubbo 集成 SpringBoot 框架起步依赖-->
<dependency>
<groupId>com.alibaba.spring.boot</groupId>
<artifactId>dubbo-spring-boot-starter</artifactId>
<version>2.0.0</version>
</dependency>
<!--Zookeeper 客户端依赖-->
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.10</version>
        </dependency>
<!--dubbo接口依赖-->
        <dependency>
            <groupId>com.md.springboot</groupId>
            <artifactId>12-springboot-dubbo-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

3、在Springboot 的核心配置文件

application.properties中配置 dubbo

#设置内嵌Tomcat
server.port=8080
#设置上下文根
server.servlet.context-path=/


#配置 dubbo 的服务提供者信息
#服务提供者应用名称(必须写，且不能重复)
spring.application.name=springboot-dubbo-consumer
#设置注册中心
spring.dubbo.registry=zookeeper://localhost:2181

4、编写 Controller 类，调用远程的 Dubbo 服务

在com.md.springboot.web下面

package com.md.springboot.web;

import com.alibaba.dubbo.config.annotation.Reference;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import service.StudentService;

/**
 * @author MD
 * @create 2020-08-22 7:15
 */
@Controller
public class StudentController {

    // 调用暴露的接口
    @Reference(interfaceClass = StudentService.class,version = "1.0.0",check = false)
    private StudentService studentService;


    @GetMapping(value = "/student/count")
    @ResponseBody
    public Object studentCount(){
        Integer count = studentService.queryAllStudentCount();

        return "学生的总人数："+count;
    }
}

注意使用Reference注解的时候：使用alibaba的这个

5、SpringBoot 入口 程序启动类上加开启 Dubbo 配置支持注解

package com.md.springboot;

import com.alibaba.dubbo.spring.boot.annotation.EnableDubboConfiguration;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableDubboConfiguration // 开启Dubbo配置
public class Application {

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

}

4. 测试

5. 总结

接口工程：存放实体bean和业务接口

服务提供者：

• 业务接口的实现类并将服务暴露且注册到注册中心，调用数据持久层
• 添加依赖dubbo、zookeeper、接口工程
• 配置服务提供者的核心配置文件

服务消费者：

• 处理浏览器客户端发送的请求，从注册中心调用服务提供者所提供的服务
• 添加依赖dubbo、zookeeper、接口工程
• 配置服务消费者的核心配置文件

二、SpringBoot 集成 SSM+Dubbo

1. 创建 Maven Java 工程，Dubbo 接口工程

2. 创建 Dubbo 服务提供者项目

16-springboot-ssm-dubbo-provider

3. 配置 MyBatis 逆向工程

在16-springboot-ssm-dubbo-provider项目中

1、添加插件，pom.xml中

<!--mybatis 代码自动生成插件-->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.7</version>
                <configuration>
                    <!--配置文件的位置-->
                    <configurationFile>GeneratorMapper.xml</configurationFile>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                </configuration>
            </plugin>

2、将配置文件存放到项目根据目录

GeneratorMapper.xml 内容如下

注意：生成model类时，指定位置，生成到接口项目中

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration

        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!-- 指定连接数据库的 JDBC 驱动包所在位置，指定到你本机的完整路径 -->
    <classPathEntry location="E:Java	oolmaven_repositorymysqlmysql-connector-java5.1.9mysql-connector-java-5.1.9.jar"/>



    <!-- 配置 table 表信息内容体，targetRuntime 指定采用 MyBatis3 的版本 -->
    <context id="tables" targetRuntime="MyBatis3">
        <!-- 抑制生成注释，由于生成的注释都是英文的，可以不让它生成 -->
        <commentGenerator>
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>
        <!-- 配置数据库连接信息 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/springboot"
                        userId="root"
                        password="123456">
        </jdbcConnection>



<!--此时model生成在接口中，targetProject指定位置-->
        <!-- 生成 model 类，targetPackage 指定 model 类的包名， targetProject 指定
        生成的 model 放在 IDEA 的哪个工程下面-->
        <javaModelGenerator targetPackage="com.md.springboot.model"
                            targetProject="E:Javacodespringboot15-springboot-ssm-dubbo-interfacesrcmainjava">
            <property name="enableSubPackages" value="false"/>
            <property name="trimStrings" value="false"/>
        </javaModelGenerator>




        <!-- 生成 MyBatis 的 Mapper.xml 文件，targetPackage 指定 mapper.xml 文件的
        包名， targetProject 指定生成的 mapper.xml 放在 IDEA 的哪个工程下面 -->
        <sqlMapGenerator targetPackage="com.md.springboot.mapper"
                         targetProject="src/main/java">
            <property name="enableSubPackages" value="false"/>
        </sqlMapGenerator>





        <!-- 生成 MyBatis 的 Mapper 接口类文件,targetPackage 指定 Mapper 接口类的包
        名， targetProject 指定生成的 Mapper 接口放在 IDEA 的哪个工程下面 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.md.springboot.mapper" targetProject="src/main/java">
            <property name="enableSubPackages" value="false"/>
        </javaClientGenerator>





        <!-- 数据库表名及对应的 Java 模型类名，有几个表写几个table -->
        <table tableName="t_student" domainObjectName="Student"
               enableCountByExample="false"
               enableUpdateByExample="false"
               enableDeleteByExample="false"
               enableSelectByExample="false"
               selectByExampleQueryId="false"/>


    </context>
</generatorConfiguration>

数据表名：t_student

4. 双击生成

生成的如下：

5、实体 bean 必须实现序列化

public class Student implements Serializable {

4. 服务提供者添加依赖

在pom.xml中

注意：

先生成完逆向工程，在写接口依赖

 <!--Dubbo 集成 SpringBoot 框架起步依赖-->
        <dependency>
            <groupId>com.alibaba.spring.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>

        <!--Zookeeper 客户端依赖-->
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.10</version>
        </dependency>

        <!--MyBatis 集成 SpringBoot 框架起步依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>
        <!--MySQL 数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.9</version>
        </dependency>


        <!--生成完逆向工程再写这个-->
     <!--接口工程-->
        <dependency>
            <groupId>com.md.springboot</groupId>
            <artifactId>15-springboot-ssm-dubbo-interface</artifactId>
            <version>1.0.0</version>
        </dependency>

5. 手动指定资源配置文件路径

在 pom 文件中的 build 标签中添加

<!--手动指定资源配置文件路径-->
        <!--目的：将数据持久层映射文件编译到 classpath 中-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>

6. 配置提供者核心配置

application.properties

#配置内嵌 Tomcat 端口号
server.port=8081
#设置上下文根
server.servlet.context-path=/provider


#配置数据源
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot
spring.datasource.username=root
spring.datasource.password=123456


#配置 dubbo 服务提供者
spring.application.name=springboot-ssm-dubbo-provider
#表示是服务提供者
spring.dubbo.server=true
#注册中心地址
spring.dubbo.registry=zookeeper://localhost:2181

7. 配置提供者启动类

package com.md.springboot;

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

@SpringBootApplication
@EnableDubboConfiguration
@MapperScan(basePackages = "com.md.springboot.mapper")  // 扫描数据持久层映射文件
public class Application {

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

}

8. 创建 Dubbo 服务消费者项目

17-springboot-ssm-dubbo-consumer

9. 服务消费者添加依赖

完整的pom.xml文件

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.md.springboot</groupId>
    <artifactId>17-springboot-ssm-dubbo-consumer</artifactId>
    <version>1.0.0</version>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--Dubbbo 集成 SpringBoot 框架起步依赖-->
        <dependency>
            <groupId>com.alibaba.spring.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
        <!--zookeeper 注册中心-->
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.10</version>
        </dependency>


        <!--接口工程-->
        <dependency>
            <groupId>com.md.springboot</groupId>
            <artifactId>15-springboot-ssm-dubbo-interface</artifactId>
            <version>1.0.0</version>
        </dependency>




    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

10. 配置消费者核心配置

application.properties

#配置内嵌 Tomcat 端口号
server.port=8080
#配置项目上下文根
server.servlet.context-path=/consumer
#配置 zookeeper 注册中心
spring.application.name=springboot-ssm-dubbo-consumer
spring.dubbo.registry=zookeeper://localhost:2181

11. 配置消费者启动类

@SpringBootApplication
@EnableDubboConfiguration // 开启dubbo支持配置
public class Application {

12. 创建 StudentService 业务接口类

在15-springboot-ssm-dubbo-interface中

package com.md.springboot.service;

import com.md.springboot.model.Student;

/**
 * @author MD
 * @create 2020-08-22 9:35
 */
public interface StudentService {

    /**
     * 通过id查询学生信息
     * @param id
     * @return
     */
    Student queryStudentById(Integer id);

}

13. 创建StudentServiceImpl 业务接口实现类

在16-springboot-ssm-dubbo-provider中

package com.md.springboot.service.impl;

import com.alibaba.dubbo.config.annotation.Service;
import com.md.springboot.mapper.StudentMapper;
import com.md.springboot.model.Student;
import com.md.springboot.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author MD
 * @create 2020-08-22 9:37
 */

@Component
// 暴露接口
@Service(interfaceClass = StudentService.class,version = "1.0.0",timeout = 15000)
public class StudentServiceImpl implements StudentService {

    // 逆向工程自动生成的StudentMapper
    @Autowired
    private StudentMapper studentMapper;

    @Override
    public Student queryStudentById(Integer id) {
        return studentMapper.selectByPrimaryKey(id);
    }
}

14. StudentController 控制层

在17-springboot-ssm-dubbo-consumer中

package com.md.springboot.web;

import com.alibaba.dubbo.config.annotation.Reference;
import com.md.springboot.model.Student;
import com.md.springboot.service.StudentService;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author MD
 * @create 2020-08-22 9:43
 */
@RestController
public class StudentController {

//    使用暴露的接口
    @Reference(interfaceClass = StudentService.class,version = "1.0.0",check = false)
    private StudentService studentService;


    @RequestMapping(value = "/student")
    public Object queryStudent(Integer id){
        Student student = studentService.queryStudentById(id);

        return student;
    }

    @RequestMapping(value = "/student/detail/{id}")
    public Object queryStudent1(@PathVariable("id") Integer id){
        Student student = studentService.queryStudentById(id);

        return "RESTful："+student;
    }

}

15. 启动测试

1. 开启zookeeper
2. 开启提供者Tomcat
3. 开启消费者Tomcat