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\tool\maven_repository\mysql\mysql-connector-java\5.1.9\mysql-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:\Java\code\springboot\15-springboot-ssm-dubbo-interface\src\main\java">
            <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. 启动测试

开启zookeeper
开启提供者Tomcat
开启消费者Tomcat

posted @ 2020-12-30 22:28 达达i 阅读(3405) 评论(0) 编辑收藏举报

刷新页面返回顶部

山丘i

不积硅步，无以至千里；不积小流，无以成江海；

SpringBoot集成Dubbo

一、基本步骤

1. Dubbo服务接口

2. Dubbo服务提供者

3. Dubbo服务消费者

4. 测试

5. 总结

二、SpringBoot 集成 SSM+Dubbo

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

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

3. 配置 MyBatis 逆向工程

4. 服务提供者添加依赖

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

6. 配置提供者核心配置

7. 配置提供者启动类

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

9. 服务消费者添加依赖

10. 配置消费者核心配置

11. 配置消费者启动类

12. 创建 StudentService 业务接口类

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

14. StudentController 控制层

15. 启动测试

公告

山丘i

不积硅步，无以至千里； 不积小流，无以成江海；

SpringBoot集成Dubbo

一、基本步骤

1. Dubbo服务接口

2. Dubbo服务提供者

3. Dubbo服务消费者

4. 测试

5. 总结

二、SpringBoot 集成 SSM+Dubbo

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

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

3. 配置 MyBatis 逆向工程

4. 服务提供者添加依赖

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

6. 配置提供者核心配置

7. 配置提供者启动类

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

9. 服务消费者添加依赖

10. 配置消费者核心配置

11. 配置消费者启动类

12. 创建 StudentService 业务接口类

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

14. StudentController 控制层

15. 启动测试

公告

不积硅步，无以至千里；不积小流，无以成江海；