Dubbo3入门项目搭建-EW帮帮网

开发环境：jdk8、dubbo3.2.9、nacos2.3.0、springboot2.7.17、dubbo-admin0.6.0。

Dubbo 是一个高性能的 Java RPC（远程调用）框架，最初由阿里巴巴开发并开源，主要用于构建 SOA 架构下的分布式应用系统( soa简单理解就是将重复功能或模块抽成通用组件，对外提供服务，从而实现复用)。 Dubbo提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。Dubbo支持多种通信协议比如：dubbo、rmi、hessian、http、webservice、rest、redis等。

nacos即是注册中心又是配置中心，注册中心解决服务治理问题，配置中心解决配置文件散乱问题。

一、准备环境

1、mysql

1、在宿主机~/docker_install/mysql/目录下，创建docker-compose.yml文件：

version: '3.1'
services:
  mysql: #定义mysql服务
    image: mysql:8.4      #使用 MySQL 8.4 的官方镜像构建
    container_name: mysql8 #容器名称
    restart: always       #当Docker服务重启或容器异常退出时，容器会自动重启。
    ports:
      - "3307:3306"  #端口映射，将宿主机的3307端口映射到容器的3306端口
    volumes: #挂在目录
      - "~/docker_install/mysql/my.cnf:/etc/mysql/my.cnf"
      - "~/docker_install/mysql/data:/var/lib/mysql"
      - "~/docker_install/mysql/mysql-files:/var/lib/mysql-files"
    environment:
      MYSQL_ROOT_PASSWORD: 123456  #设置root用户的密码
      TZ: Asia/Shanghai    #时区
      LANG: en_US.UTF-8    #语言编码
      MYSQL_DATABASE: demo #初始化的数据库名称
    #授权  
    privileged: true     
    user: root

2、在宿主机~/docker_install/mysql/目录下，创建my.cnf文件：

#服务端参数配置
[mysqld]
user=root                             #MySQL启动用户
default-storage-engine=INNODB         #创建新表时将使用的默认存储引擎
character-set-server=utf8mb4          #设置mysql服务端默认字符集
collation-server=utf8mb4_general_ci   #数据库字符集对应一些排序等规则，注意要和character-set-server对应
default-authentication-plugin=mysql_native_password

max_connections=1000    # 允许最大连接数
max_connect_errors=100  # 最大错误连接数

[mysql]
default-character-set=utf8mb4

[client]
default-character-set=utf8mb4  # 设置mysql客户端默认字符集

3、创建容器

docker-compose -f docker-compose.yml -p mysql8 up -d

命令解释：

docker-compose ：服务编排工具。
-f docker-compose.yml ：指定要使用的yaml文件。
-p mysql8 ：设置项目名称，docker compose 使用项目名称来命名创建的容器、网络和卷等资源。避免在同一主机上运行多个不同的compose项目时出现命名冲突。
up ：用于启动由 docker-compose.yml 文件定义的所有服务。
-d（–detach）：以分离模式（detached mode）运行容器。（后台方式运行）

docker-compose常用命令：

ps ：基于docker-compose拉取的镜像生成的容器

up ：docker-compose 创建和启动容器

scale ：创建容器的数量

top ：显示容器的进程

logs ：看容器的输出日志

stop start、restart：停止、启动、重启

down ：删除容器，网络，数据卷，镜像

2、nacos

基于docker-compose编排方式安装nacos，并使用mysql持久化nacos配置信息。

1、创建docker-compose.yaml：

version: '3'
services:
  nacos:
    image: nacos/nacos-server:v2.3.0-slim
    # 容器名称
    container_name: nacos
    # 端口映射
    ports:
      - 8848:8848
      - 9848:9848
      - 9849:9849
    # 容器权限
    privileged: true
    # 参数设置
    environment:
      JVM_XMS: 128m
      JVM_XMX: 128m
      JVM_MS: 64m
      JVM_MMS: 64m
      MODE: standalone
      NACOS_REPLICAS: 1
      PREFER_HOST_MODE: ip
    # 挂载目录  
    volumes: 
      - ./logs:/home/nacos/logs
      - ./plugins:/home/nacos/plugins
      - ./data:/home/nacos/data
      - ./config/application.properties:/home/nacos/conf/application.properties
    networks:
      nacos:
        aliases:
          - nacos_2.3.0
networks:
  nacos:
    name: nacos_2.3.0
    driver: bridge

2、在宿主机./config/目录下，创建application.properties：

# 只需要修改下面MySQL账号密码、连接地址
spring.datasource.platform=mysql
db.num=1	
db.url.0=jdbc:mysql://127.0.0.1:3307/nacos_conf?characterEncoding=utf8&	connectTimeout=1000&socketTimeout=3000&autoReconnect=true
db.user=root
db.password=123456

# 随机字符串，要长点
nacos.core.auth.plugin.nacos.token.secret.key=0123321adsfffdasf343134124fasfdfdffas34134343

在mysql中执行sql脚本：https://github.com/alibaba/nacos/blob/2.3.0/config/src/main/resources/META-INF/nacos-db.sql

3、创建容器

docker-compose up -d

nacos访问地址：http://ip:8848/nacos

3、dubbo-admin

dubbo-admin：https://github.com/apache/dubbo-admin/archive/refs/tags/0.6.0.zip

dubbo-admin （dubbo可视化后台）它是一个前后的分离项目，基于springboot+vue开发，需要依赖 nodejs、jdk、maven环境。

1、从github拉取代码：git clone https://github.com/apache/dubbo-admin.git

2、使用idea打开dubbo-admin-server，修改application.properties中的nacos配置:

server.port=38080
dubbo.protocol.port=30880
dubbo.application.qos-port=32222


# centers in dubbo, if you want to add parameters, please add them to the url
admin.registry.address=nacos://127.0.0.1:8848
admin.config-center=nacos://127.0.0.1:8848
admin.metadata-report.address=nacos://127.0.0.1:8848
#---------------------------------------------------

# dubbo-admin  账号密码
admin.root.user.name=root
admin.root.user.password=root

#session timeout, default is one hour
admin.check.sessionTimeoutMilli=3600000


#compress
server.compression.enabled=true
server.compression.mime-types=text/css,text/javascript,application/javascript
server.compression.min-response-size=10240

#token timeout, default is one hour
admin.check.tokenTimeoutMilli=3600000
#Jwt signingKey
admin.check.signSecret=86295dd0c4ef69a1036b0b0c15158d77

#dubbo config
dubbo.application.name=dubbo-admin
dubbo.registry.address=${admin.registry.address}
#dubbo.registry.parameters.namespace=70b158a6-7e64-478d-8c5b-699089aa81d1

# id generate type
mybatis-plus.global-config.db-config.id-type=none

dubbo.application.logger=slf4j

3、运行dubbo-admin后端项目

通过nacos控制台可以看到dubbo-admin服务实例已成功注册到nacos中。

4、使用vscode或webstorm打开dubbo-admin-ui：(node版本16.20.2)

5、运行dobbo-admin前端项目：

# 安装项目依赖
npm install

# 启动前端项目
npm run dev

6、浏览器访问duboo-admin web页面：http://localhost:38082/。账号/密码：root/root

二、项目搭建

项目地址：https://gitee.com/aopmin/dubbo3-demo.git

1、创建maven父工程

1、创建maven父工程，不使用脚手架方式构建：

2、父工程删除src源码目录

3、在父工程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>cn.aopmin</groupId>
    <artifactId>dubbo3-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <description>duubo3示例项目父工程</description>

    <modules>
        <module>dubbo3-provider</module>
        <module>dubbo3-consumer</module>
        <module>dubbo3-api</module>
    </modules>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.boot.version>2.7.17</spring.boot.version>
        <nacos.boot.version>0.2.12</nacos.boot.version>
        <dubbo.version>3.2.9</dubbo.version>
    </properties>

    <dependencyManagement>
          <dependencies>
              <dependency>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-starter-parent</artifactId>
                  <version>${spring.boot.version}</version>
                  <type>pom</type>
                  <scope>import</scope>
              </dependency>
          </dependencies>
      </dependencyManagement>
</project>

最终项目结构：

2、创建公共接口模块

dubbo是一个面向接口的远程调用，消费端如果想要调用生产端的接口，只需引入对应api接口模块jar包即可，所以这里我们偷懒一下把它抽成公用模块方便复用。

创建一个dubbo接口：

package cn.aopmin.api;

/**
 * HelloService
 * @author aopmin
 * @since 2024/12/29
 */
public interface HelloService {
    String getMsg();
}

3、创建provider服务提供者

1、服务提供者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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>cn.aopmin</groupId>
        <artifactId>dubbo3-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>dubbo3-provider</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- spring boot starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- springboot-web依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- dubbo依赖 -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>${dubbo.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>javassist</artifactId>
                    <groupId>org.javassist</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- dubbo整合nacos -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-registry-nacos</artifactId>
            <!-- <version>3.2.9</version> -->
            <version>${dubbo.version}</version>
        </dependency>

        <!-- 公共接口模块 -->
        <dependency>
            <groupId>cn.aopmin</groupId>
            <artifactId>dubbo3-api</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

</project>

2、创建启动类

package cn.aopmin;

import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 服务提供者
 * @author aopmin
 * @since 2024/12/29
 */
@EnableDubbo // 开启dubbo
@SpringBootApplication
public class ProviderApp {
    public static void main(String[] args) {
        SpringApplication.run(ProviderApp.class, args);
        System.out.println("Provider started successfully!");
    }
}

4、编写dubbo接口实现类

package cn.aopmin.service;

import cn.aopmin.api.HelloService;
import org.apache.dubbo.config.annotation.DubboService;

import java.time.LocalDateTime;
import java.util.HashMap;

/**
 * dubbo接口实现类
 * @author aopmin
 * @since 2024/12/29
 */
@DubboService
public class HelloSericeImpl implements HelloService {
    @Override
    public String getMsg() {
        return new HashMap<String,Object>(){{
            put("status","200");
            put("msg","Hello Dubbo!");
            put("datetime", LocalDateTime.now());
        }}.toString();
    }
}

5、创建application.yml文件

server:
  port: 5656 # 服务端口号

spring:
  application:
    name: dubbo3-provider # 服务名称

# dubbo配置
dubbo:
  application:
    name: ${spring.application.name}
  # 通信规则，dubbo支持多种通信规则，如dubbo、rmi、hessian、http等
  protocol:
    name: dubbo #使用dubbo协议
    port: 20880  # dubbo协议端口，以供消费者访问，-1即为随机端口
   # 注册中心配置
  registry:
    address: nacos://127.0.0.1:8848 #nacos

6、启动服务提供者

启动成功后可以dubbo-admin、nacos中查看：

最终项目结构：

4、创建consumer服务消费者

1、服务消费者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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>cn.aopmin</groupId>
        <artifactId>dubbo3-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>dubbo3-consumer</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- spring boot starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- springboot-web依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- &lt;!&ndash;nacos配置中心依赖&ndash;&gt; -->
        <!-- <dependency> -->
        <!--     <groupId>com.alibaba.boot</groupId> -->
        <!--     <artifactId>nacos-config-spring-boot-starter</artifactId> -->
        <!--     <version>${nacos.boot.version}</version> -->
        <!-- </dependency> -->

        <!-- dubbo依赖 -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>${dubbo.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>javassist</artifactId>
                    <groupId>org.javassist</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- dubbo整合nacos -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-registry-nacos</artifactId>
            <!-- <version>3.2.9</version> -->
            <version>${dubbo.version}</version>
        </dependency>

        <!-- 公共接口模块 -->
        <dependency>
            <groupId>cn.aopmin</groupId>
            <artifactId>dubbo3-api</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
</project>

2、创建启动类

package cn.aopmin;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 服务消费者
 * @author aopmin
 * @since 2024/12/29
 */
@SpringBootApplication
public class ConsumerApp {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApp.class, args);
        System.out.println("Consumer started successfully!");
    }
}

3、配置application.yml：

server:
  port: 5657 # 服务端口号

spring:
  application:
    name: dubbo3-consumer # 服务名称

# dubbo配置
dubbo:
  application:
    name: ${spring.application.name}
    qosPort: 33333 # 服务质量监控中心端口,默认为22222
  # 通信规则，dubbo支持多种通信规则，如dubbo、rmi、hessian、http等
  protocol:
    name: dubbo #使用dubbo协议
    port: 20881  # dubbo协议端口，以供消费者访问，-1即为随机端口
   # 注册中心配置
  registry:
    address: nacos://127.0.0.1:8848 #nacos

4、编写web接口

package cn.aopmin.controller;

import cn.aopmin.api.HelloService;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * web接口
 * @author aopmin
 * @since 2024/12/29
 */
@RestController
public class HelloController {

    // 注入远程服务(类似@autowried,只不过autowried注入的是spring容器中的bean对象), 设置超时时间:1s和重试次数:2次
    @DubboReference(timeout = 1000, retries = 1)
    private HelloService helloService;

    @RequestMapping("/hello")
    public String hello() {
        return helloService.getMsg();
    }
}

5、启动服务消费者

6、测试

curl -i -X GET "http://localhost:5657/hello"

最终项目结构：

三、Dubbo运行原理

dubbo一次RPC调用的过程，分为4个角色：
    Client：消费者
    Client Stub：客户端存档，由框架实现
    Server Stub：服务端存档，由框架实现
    Server：提供者
    
调用过程：
	1、Client发起远程调用
	   Client发起远程调用，实际上是由它的代理ClientStub实现的
	   ClientStub把要调用目标类、目标方法、实参等等进行序列化，然后通过网络传递给ServerStub。
	   ServerStub接收数据反序列化，再调用对应的目标类、目标方法，得到执行结果
	   ServerStub把目标方法的结果进行序列化，通过网络返回给ClientStub
	   ClientStub接收数据反序列化，得到结果。把这个结果返回给Client
	2、Client得到执行的结果,返回给调用者

Dubbo3入门项目搭建

一、准备环境

1、mysql

2、nacos

3、dubbo-admin

二、项目搭建

1、创建maven父工程

2、创建公共接口模块

3、创建provider服务提供者

4、创建consumer服务消费者

三、Dubbo运行原理

网站公告

今日签到

热门文章

最新发布