Dubbo（72）Dubbo的序列化机制是什么？

Victor3562025-04-23 11:01

Dubbo的序列化机制是指在网络传输过程中，将Java对象转换为字节流(序列化)以及将字节流转换回Java对象(反序列化)的过程。Dubbo支持多种序列化协议，每种协议都有其优缺点，适用于不同的场景。以下是关于Dubbo序列化机制的详细介绍，并结合代码示例说明如何配置和使用不同的序列化协议。

常见的序列化协议

  • Hessian：一种跨语言的二进制序列化协议，速度较快，支持跨语言。
  • JSON：一种文本序列化协议，易于阅读和调试，但性能较低。
  • Kryo：一种高效的二进制序列化协议，适用于大数据传输，但不支持跨语言。
  • Protobuf：Google开发的高效二进制序列化协议，支持跨语言。

默认序列化协议

Dubbo默认使用Hessian2作为序列化协议。你可以通过配置文件或注解来修改序列化协议。

1. 项目结构

我们将创建一个简单的项目结构，包含一个服务提供者和一个服务消费者：

css 复制代码 
dubbo-demo
├── dubbo-api
│   └── src/main/java/com/example/dubbo/api
│       └── MyService.java
├── dubbo-provider
│   └── src/main/java/com/example/dubbo/provider
│       └── MyServiceImpl.java
│       └── DubboProviderApplication.java
├── dubbo-consumer
│   └── src/main/java/com/example/dubbo/consumer
│       └── MyServiceConsumer.java
│       └── DubboConsumerApplication.java
└── pom.xml

2. 创建服务接口模块（dubbo-api）

服务接口模块 dubbo-api 定义了服务接口。

2.1 创建 pom.xml

在 dubbo-api 模块中创建 pom.xml 文件：

xml 复制代码 
<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://www.w3.org/2001/04/xmldsig-more#">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>dubbo-api</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.7.8</version>
        </dependency>
    </dependencies>
</project>

2.2 创建服务接口

在 dubbo-api/src/main/java/com/example/dubbo/api 目录下创建 MyService 接口：

java 复制代码 
package com.example.dubbo.api;

public interface MyService {
    String sayHello(String name);
}

3. 创建服务提供者模块（dubbo-provider）

服务提供者模块 dubbo-provider 实现了服务接口并提供服务。

3.1 创建 pom.xml

在 dubbo-provider 模块中创建 pom.xml 文件：

xml 复制代码 
<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://www.w3.org/2001/04/xmldsig-more#">

    <parent>
        <groupId>com.example</groupId>
        <artifactId>dubbo-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <artifactId>dubbo-provider</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>dubbo-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>
</project>

3.2 创建服务实现

在 dubbo-provider/src/main/java/com/example/dubbo/provider 目录下创建 MyServiceImpl 类：

java 复制代码 
package com.example.dubbo.provider;

import com.example.dubbo.api.MyService;
import org.apache.dubbo.config.annotation.DubboService;

@DubboService
public class MyServiceImpl implements MyService {
    @Override
    public String sayHello(String name) {
        return "Hello, " + name;
    }
}

3.3 创建启动类

在 dubbo-provider/src/main/java/com/example/dubbo/provider 目录下创建 DubboProviderApplication 类：

java 复制代码 
package com.example.dubbo.provider;

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

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

3.4 配置文件

在 dubbo-provider/src/main/resources 目录下创建 application.yml 配置文件：

yaml 复制代码 
spring:
  application:
    name: dubbo-provider
  main:
    web-application-type: none

dubbo:
  application:
    name: dubbo-provider
  registry:
    address: zookeeper://localhost:2181
  protocol:
    name: dubbo
    port: 20880
  scan:
    base-packages: com.example.dubbo.provider

4. 创建服务消费者模块（dubbo-consumer）

服务消费者模块 dubbo-consumer 调用服务提供者提供的服务。

4.1 创建 pom.xml

在 dubbo-consumer 模块中创建 pom.xml 文件：

xml 复制代码 
<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://www.w3.org/2001/04/xmldsig-more#">

    <parent>
        <groupId>com.example</groupId>
        <artifactId>dubbo-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <artifactId>dubbo-consumer</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>dubbo-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

4.2 创建服务消费者

在 dubbo-consumer/src/main/java/com/example/dubbo/consumer 目录下创建 MyServiceConsumer 类：

java 复制代码 
package com.example.dubbo.consumer;

import com.example.dubbo.api.MyService;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyServiceConsumer {

    @DubboReference
    private MyService myService;

    @GetMapping("/sayHello")
    public String sayHello(@RequestParam String name) {
        return myService.sayHello(name);
    }
}

4.3 创建启动类

在 dubbo-consumer/src/main/java/com/example/dubbo/consumer 目录下创建 DubboConsumerApplication 类：

java 复制代码 
package com.example.dubbo.consumer;

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

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

4.4 配置文件

在 dubbo-consumer/src/main/resources 目录下创建 application.yml 配置文件：

yaml 复制代码 
spring:
  application:
    name: dubbo-consumer

dubbo:
  application:
    name: dubbo-consumer
  registry:
    address: zookeeper://localhost:2181
  protocol:
    name: dubbo
  scan:
    base-packages: com.example.dubbo.consumer

5. 配置序列化协议

我们可以通过配置文件指定序列化协议。以下是如何配置不同的序列化协议的示例。

5.1 配置Hessian序列化协议

默认情况下，Dubbo使用Hessian2作为序列化协议。如果你想显式指定，可以在配置文件中添加以下配置：

yaml 复制代码 
dubbo:
  protocol:
    name: dubbo
    serialization: hessian2

5.2 配置JSON序列化协议

如果你想使用JSON序列化协议，可以在配置文件中添加以下配置：

yaml 复制代码 
dubbo:
  protocol:
    name: dubbo
    serialization: json

5.3 配置Kryo序列化协议

如果你想使用Kryo序列化协议，可以在配置文件中添加以下配置：

yaml 复制代码 
dubbo:
  protocol:
    name: dubbo
    serialization: kryo

5.4 配置Protobuf序列化协议

如果你想使用Protobuf序列化协议，可以在配置文件中添加以下配置：

yaml 复制代码 
dubbo:
  protocol:
    name: dubbo
    serialization: protobuf

6. 根项目的 pom.xml

在根项目 dubbo-demo 中创建 pom.xml 文件，定义模块和依赖管理：

xml 复制代码 
<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://www.w3.org/xmldsig-more#">

    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>dubbo-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

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

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo</artifactId>
                <version>2.7.8</version>
            </dependency>
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-spring-boot-starter</artifactId>
                <version>2.7.8</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.1</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>2.3.4.RELEASE</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

7. 启动Zookeeper

确保Zookeeper在本地运行，默认端口为 2181。可以通过下载Zookeeper并运行以下命令启动Zookeeper：

sh 复制代码 
bin/zkServer.sh start

8. 启动服务提供者和消费者

  1. 启动服务提供者：运行 DubboProviderApplication 类。
  2. 启动服务消费者：运行 DubboConsumerApplication 类。

9. 验证序列化协议

通过访问消费者服务的URL来验证序列化协议的配置是否生效。例如：

bash 复制代码 
http://localhost:8080/sayHello?name=Dubbo

代码总结

通过以上步骤，我们详细展示了Dubbo的序列化机制，包括如何配置和使用不同的序列化协议。以下是关键步骤的总结：

  1. 定义项目结构：创建服务接口模块、服务提供者模块和服务消费者模块。
  2. 创建服务接口模块：定义服务接口。
  3. 创建服务提供者模块：实现服务接口并提供服务。
  4. 创建服务消费者模块：引用服务并调用服务。
  5. 配置序列化协议：通过配置文件指定序列化协议。
  6. 配置项目依赖管理 ：在根项目 pom.xml 中定义模块和依赖管理。
  7. 启动Zookeeper：确保服务注册中心正常运行。
  8. 启动服务提供者和消费者：分别启动服务提供者和消费者。
  9. 验证序列化协议：通过访问消费者服务验证序列化协议的配置是否生效。

通过这些步骤，可以深入理解Dubbo的序列化机制，确保系统的高效和稳定运行。

相关推荐
像风一样自由20208 分钟前
RESTful API工具和框架详解
后端·restful
草捏子9 分钟前
接口幂等性设计：6种解决方法让重复请求不再成为系统隐患
后端
Captaincc9 分钟前
AI coding的隐藏王者，悄悄融了2亿美金
前端·后端·ai编程
盖世英雄酱5813619 分钟前
同事说缓存都用redis啊，数据不会丢失！真的吗？
redis·后端·面试
L2ncE2 小时前
双非计算机自救指南（找工作版）
后端·面试·程序员
cdg==吃蛋糕2 小时前
solr自动建议接口简单使用
后端·python·flask
Joseit2 小时前
基于 Spring Boot实现的图书管理系统
java·spring boot·后端
{⌐■_■}2 小时前
【go】什么是Go语言的GPM模型？工作流程？为什么Go语言中的GMP模型需要有P?
java·开发语言·后端·golang
IT杨秀才3 小时前
LangChain框架入门系列(5)：Memory
人工智能·后端·langchain
程序猿chen3 小时前
JVM考古现场（二十四）：逆熵者·时间晶体的永恒之战
java·jvm·git·后端·程序人生·java-ee·改行学it
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03我决定放弃搞 Java 了04YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】05DeepSeek各版本说明与优缺点分析06RAG 实践- Ollama+RagFlow 部署本地知识库07yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记08苍穹外卖面试总结09如何在WPS和Word/Excel中直接使用DeepSeek功能10组基轨迹建模 GBTM的介绍与实现（Stata 或 R）