Dubbo内部服务调用

  • 一、Dubbo介绍
  • 二、Dubbo 与 SpringCloud 的通信 Openfeign的区别
  • 1、协议支持方面
  • 2、通信性能方面
  • 三、Nacos介绍
  • 1、Nacos 与 Eureka 的选择
  • 四、项目搭建
  • 1、创建父工程
  • 1）新建父工程项目gateway_nacos_dubbo_springcloud
  • 2）在build.gradle中配置项目依赖版本控制
  • 2、创建网关 gateway
  • 1）新建子工程项目demo-gateway
  • 2）在build.gradle中引入`启动器`以及依赖
  • 3）启动类
  • 4）配置文件 bootstrap.yaml
  • 3、创建接口
  • 1）新建子工程项目demo-interface
  • 2）创建接口
  • 4、创建提供者
  • 1）新建子工程项目demo-provider
  • 2）在build.gradle中引入**启动器**以及依赖
  • 3）配置文件 application.yaml
  • 4）启动类
  • 5）提供者service 需要实现接口
  • 5、创建消费者
  • 1）新建子工程项目demo-consumer
  • 2）在build.gradle中引入**启动器**以及依赖
  • 3）配置文件application.yaml
  • 4）启动类
  • 5）controller层
  • 6）service层
  • 7）需要配置**网关策略配置**
  • 7.1 在demo-gateway项目中引入依赖
  • 7.2 Nacos客户端添加配置
  • 7.3 在demo-gateway项目的bootstrap.yaml配置文件中添加
  • 6、发送请求测试
  • 五、项目结构
  • 1、父子项目结构
  • 2、网关demo-gateway结构
  • 3、接口 demo-interface 结构
  • 4、提供者结构
  • 5、消费者demo-consumer结构


一、Dubbo介绍

Apache Dubbo是一款微服务开发框架，它提供了 RPC通信 与 微服务治理 两大关键能力

二、Dubbo 与 SpringCloud 的通信 Openfeign的区别

1、协议支持方面

  • Feign更加优雅简单。Feign是通过REST API实现的远程调用，基于Http传输协议，服务提供者需要对外暴露Http接口供消费者调用，服务粒度是http接口级的。通过短连接的方式进行通信，不适合高并发的访问
  • Dubbo方式更灵活。Dubbo是通过RPC调用实现的远程调用，支持多传输协议(Dubbo、Rmi、http、redis等等)，可以根据业务场景选择最佳的方式，非常灵活。默认的Dubbo协议：利用Netty，TCP传输，单一、异步、长连接，适合数据量小、高并发和服务提供者远远少于消费者的场景。Dubbo通过TCP长连接的方式进行通信，服务粒度是方法级的。

2、通信性能方面

  • Feign基于Http传输协议，底层实现是rest。在高并发场景下性能不够理想。
  • Dubbo框架的通信协议采用RPC协议，属于传输层协议，提升了交互的性能，保持了长连接，高性能。

三、Nacos介绍

Nacos致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据及流量管理。

1、Nacos 与 Eureka 的选择

  • Eureka 是 springcloud最早的注册中心，目前已经进入停更维护了
  • Nacos 除了服务的注册发现之外，还支持动态配置服务。动态配置消除了配置变更时重新部署应用和服务的需要，让配置管理变得更加高效和敏捷

四、项目搭建

1、创建父工程

1）新建父工程项目gateway_nacos_dubbo_springcloud
2）在build.gradle中配置项目依赖版本控制
plugins {
    id 'java'
    id 'org.springframework.boot' version '2.7.0'        //springboot依赖版本
    id 'io.spring.dependency-management' version '1.0.11.RELEASE' //spring的依赖管理插件版本
}

//版本控制
ext {
    set('springCloudVersion', "2021.0.3")                     //SpringCloud依赖版本
    set('springCloudAlibabaVersion', "2021.0.1.0")           //SpringCloudAlibaba依赖版本
    set('springBootVersion', "2.7.0")
}

//全部模块通用配置
allprojects{
    // 项目的默认名称和版本
    group ='com.threesides'
    version ='1.0.0-SNAPSHOT'
    // 指定JDK版本
    sourceCompatibility = '11'

    // 指定仓库地址
    repositories {
        // aliyun镜像
        maven { url 'https://maven.aliyun.com/repository/public' }
        maven { url 'https://maven.aliyun.com/repository/google' }
        maven { url 'https://maven.aliyun.com/repository/gradle-plugin' }
        maven { url 'https://maven.aliyun.com/repository/spring' }
        maven { url 'https://maven.aliyun.com/repository/grails-core' }
        maven { url 'https://maven.aliyun.com/repository/apache-snapshots' }
//        本地仓库
        mavenLocal()
        //   中央️仓库
        mavenCentral()
    }
}

// 子模块配置
subprojects {

    // 使用插件
    apply plugin: 'java'
    apply plugin: 'org.springframework.boot'
    apply plugin: 'io.spring.dependency-management'

    //子模块通用依赖
    dependencies {
        testImplementation "org.springframework.boot:spring-boot-starter-test:${springBootVersion}"
        testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${springBootVersion}"
    }

    //子模块依赖管理
    dependencyManagement {
        dependencies {
            dependency "org.springframework.boot:spring-boot-starter:${springBootVersion}"
        }
        imports {
            mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
            mavenBom "com.alibaba.cloud:spring-cloud-alibaba-dependencies:${springCloudAlibabaVersion}"
        }
    }
}

2、创建网关 gateway

1）新建子工程项目demo-gateway
2）在build.gradle中引入启动器以及依赖
group 'com.threesides'
version '1.0.0-SNAPSHOT'

jar.enabled = true
bootJar.enabled = true

dependencies {
    testImplementation 'org.springframework.boot:spring-boot-starter-test'  //测试环境
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'

    implementation group: 'com.alibaba.cloud', name: 'spring-cloud-starter-alibaba-nacos-discovery' //注册中心，这里使用的是alibaba-nacos，其他注册中心也可
    implementation group: 'com.alibaba.cloud', name: 'spring-cloud-starter-alibaba-nacos-config'   //配置中心，这里使用的是alibaba-nacos

    implementation 'org.springframework.cloud:spring-cloud-starter-gateway'  //网关 gateway 项目不能同时依赖spring-boot-starter-web
    implementation 'org.springframework.cloud:spring-cloud-loadbalancer'    // 负载均衡 SpringCloud 版本在 2021.0.x以上必须引依赖

    implementation 'org.springframework.cloud:spring-cloud-starter-bootstrap'

}

test {
    useJUnitPlatform()
}
3）启动类
@SpringBootApplication
@EnableDiscoveryClient
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}
4）配置文件 bootstrap.yaml
server:
  port: 1101
spring:
  application:
    name: demo-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848

3、创建接口

1）新建子工程项目demo-interface
2）创建接口
public interface DemoInterface {
    public String demo(String message);
}

4、创建提供者

1）新建子工程项目demo-provider
2）在build.gradle中引入启动器以及依赖
group 'com.threesides'
version '1.0.0-SNAPSHOT'

archivesBaseName = "demo-provider"

jar.enabled = true
bootJar.enabled = true

dependencies {

    // 引入本地的  xxxx模块
    implementation project(':demo-interface')

    // 引入 spring-cloud 依赖
    // 注册中心，这里使用的是alibaba-nacos，其他注册中心也可。
    implementation group: 'com.alibaba.cloud', name: 'spring-cloud-starter-alibaba-nacos-discovery'

    implementation group: 'org.springframework.boot', name: 'spring-boot-starter-web'

    //dubbo
    implementation 'org.apache.dubbo:dubbo-spring-boot-starter:3.0.8'
    implementation 'com.alibaba.nacos:nacos-client:2.1.0' // 由于我使用的客户端是2.1.0 
   //由于报错  java.lang.ClassNotFoundException: com.google.common.collect.Maps
	//引入guava
	implementation 'com.google.guava:guava:31.1-jre'

    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
}

test {
    useJUnitPlatform()
}
3）配置文件 application.yaml
server:
  port: 8010
#  dubbo的配置
dubbo:
  application:
    name: demo-provider
  registry:
    address: nacos://127.0.0.1:8848
4）启动类
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;

@EnableDubbo
@SpringBootApplication
public class ProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProviderApplication.class, args);
    }
}
5）提供者service 需要实现接口
import org.apache.dubbo.config.annotation.DubboService;

@DubboService
public class DemoProviderImpl implements DemoInterface {
    @Override
    public String demo(String message) {
        System.out.println(message);
        return message+"成功了";
    }
}

5、创建消费者

1）新建子工程项目demo-consumer
2）在build.gradle中引入启动器以及依赖
group 'com.threesides'
version '1.0.0-SNAPSHOT'

archivesBaseName = "demo-consumer"

jar.enabled = true
bootJar.enabled = true

dependencies {

    // 引入本地的  xxxx模块
    implementation project(':demo-interface')

    // 引入 spring-cloud 依赖
    // 注册中心，这里使用的是alibaba-nacos，其他注册中心也可。
    implementation group: 'com.alibaba.cloud', name: 'spring-cloud-starter-alibaba-nacos-discovery'

    implementation group: 'org.springframework.boot', name: 'spring-boot-starter-web'

    //dubbo
    implementation 'org.apache.dubbo:dubbo-spring-boot-starter:3.0.8'
    implementation 'com.alibaba.nacos:nacos-client:2.1.0' // 由于我使用的客户端是2.1.0 
   //由于报错  java.lang.ClassNotFoundException: com.google.common.collect.Maps
	//引入guava
	implementation 'com.google.guava:guava:31.1-jre'
	
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
}

test {
    useJUnitPlatform()
}
3）配置文件application.yaml
server:
  port: 8011
spring:
  application:
    name: demo-consumer
  cloud:
    nacos:
      discovery:
        server-addr: http://127.0.0.1:8848   # 注册中心  http://ip:端口号
dubbo:
  registry:
    address: nacos://127.0.0.1:8848
    register: false
4）启动类
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;

@EnableDubbo
@SpringBootApplication
public class ComsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ComsumerApplication.class, args);
    }
}
5）controller层
@RestController
@RequestMapping("/demo")
public class DemoConsumerController {

    @Autowired
    private DemoConsumerService demoConsumerService;

    @GetMapping("/getProviderService")
    public String getProviderService() {
        return demoConsumerService.getProviderService();
    }

}
6）service层
import org.apache.dubbo.config.annotation.DubboReference;

@Service
public class DemoConsumerService {

    @DubboReference
    private DemoInterface demoInterface;

    public String getProviderService() {
        return demoInterface.demo("使用Dubbo调用");
    }

}
7）需要配置网关策略配置

这里引入Nacos的配置中心的使用

7.1 在demo-gateway项目中引入依赖

implementation group: 'com.alibaba.cloud', name: 'spring-cloud-starter-alibaba-nacos-config'

7.2 Nacos客户端添加配置

java 手动连接nacos 读取配置_spring cloud


java 手动连接nacos 读取配置_dubbo_02

spring:
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true   #开启网关拉取nacos的服务
      routes:
        - id: demo-consumer
          uri: lb://demo-consumer
          predicates:
            - Path=/demo/**
7.3 在demo-gateway项目的bootstrap.yaml配置文件中添加
spring:
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yaml
        refresh-enabled: true # 是否动态刷新,默认为false
        # 支持多个共享dataId的配置，优先级小于extension-configs,shared-configs是一个集合
        shared-configs[0]:
          # 网关 通用配置可以定义在这个里面
          dataId: demo-gateway.yaml # 配置文件名dataId
          group: DEFAULT_GROUP  # 默认为DEFAULT_GROUP

6、发送请求测试

这里使用的Restful Fast Request插件测试
http://localhost:1101/demo/getProviderServicejava 手动连接nacos 读取配置_java_03

五、项目结构

1、父子项目结构

java 手动连接nacos 读取配置_spring cloud_04

2、网关demo-gateway结构

java 手动连接nacos 读取配置_架构_05

3、接口 demo-interface 结构

java 手动连接nacos 读取配置_dubbo_06

4、提供者结构

java 手动连接nacos 读取配置_java_07

5、消费者demo-consumer结构

java 手动连接nacos 读取配置_dubbo_08