RocketMq的消息类型及代码案例

news2025/5/26 0:30:31

RocketMQ 提供了多种消息类型，以满足不同业务场景对 顺序性、事务性、时效性 的要求。其核心设计思想是通过解耦 “消息传递模式” 与 “业务逻辑”，实现高性能、高可靠的分布式通信。

一、主要类型包括

  1. 普通消息（基础类型）
  2. 顺序消息（保证消费顺序）
  3. 定时 / 延迟消息（控制投递时间）
  4. 事务消息（分布式事务最终一致性）
  5. 批量消息（提升吞吐量）

二、消息类型及代码示例

1. 普通消息（Normal Message）

描述：最基础的消息类型，支持异步发送、批量发送等模式，适用于无需严格顺序和事务保证的场景（如日志收集、通知推送）。
核心优势：高吞吐量、低延迟，生产端通过负载均衡自动选择 Broker。

import org.apache.rocketmq.client.apis.ClientConfiguration;
import org.apache.rocketmq.client.apis.ClientException;
import org.apache.rocketmq.client.apis.ClientServiceProvider;
import org.apache.rocketmq.client.apis.StaticSessionCredentialsProvider;
import org.apache.rocketmq.client.apis.message.Message;
import org.apache.rocketmq.client.apis.producer.Producer;
import org.apache.rocketmq.client.apis.producer.SendReceipt;

public class NormalMessageExample {
    public static void main(String[] args) throws ClientException, InterruptedException {
        // 1. 加载服务提供者（支持SPI扩展）
        ClientServiceProvider provider = ClientServiceProvider.loadService();
        
        // 2. 配置认证信息（密钥管理）
        String accessKey = "yourAccessKey";
        String secretKey = "yourSecretKey";
        StaticSessionCredentialsProvider credentialsProvider =
            new StaticSessionCredentialsProvider(accessKey, secretKey);
        
        // 3. 构建客户端配置（支持多协议、TLS加密）
        ClientConfiguration clientConfiguration = ClientConfiguration.newBuilder()
            .setEndpoints("localhost:8081") // 支持域名或IP:端口列表
            .setCredentialProvider(credentialsProvider)
            .setRequestTimeout(Duration.ofSeconds(3)) // 请求超时时间
            .build();
        
        // 4. 创建生产者（支持自动重试、批量发送）
        String topic = "normal-message-topic";
        Producer producer = provider.newProducerBuilder()
            .setClientConfiguration(clientConfiguration)
            .setTopics(topic)
            .setMaxAttempts(3) // 发送失败最大重试次数
            .build();
        
        // 5. 构建并发送消息
        Message message = provider.newMessageBuilder()
            .setTopic(topic)
            .setBody("Hello RocketMQ 5.0!".getBytes())
            .setTag("order") // 可选标签，用于消息过滤
            .setKeys("key123") // 消息业务键，用于查询
            .build();
        
        // 同步发送（阻塞当前线程直到返回结果）
        SendReceipt receipt = producer.send(message);
        System.out.println("消息发送成功: " + receipt.getMessageId());
        
        // 异步发送示例
        /*
        producer.sendAsync(message).thenAccept(sendReceipt -> {
            System.out.println("异步发送成功: " + sendReceipt.getMessageId());
        }).exceptionally(throwable -> {
            System.out.println("异步发送失败: " + throwable.getMessage());
            return null;
        });
        */
        
        // 6. 关闭资源（重要！避免内存泄漏）
        producer.close();
    }
}
2. 顺序消息（Ordered Message）

描述：通过将同一业务主键的消息路由到相同队列，保证消息消费顺序与发送顺序一致。
应用场景：金融交易流水、订单状态变更、时序数据处理。

import org.apache.rocketmq.client.apis.ClientConfiguration;
import org.apache.rocketmq.client.apis.ClientException;
import org.apache.rocketmq.client.apis.ClientServiceProvider;
import org.apache.rocketmq.client.apis.message.Message;
import org.apache.rocketmq.client.apis.producer.Producer;
import org.apache.rocketmq.client.apis.producer.SendReceipt;

import java.util.List;

public class OrderedMessageExample {
    public static void main(String[] args) throws ClientException, InterruptedException {
        ClientServiceProvider provider = ClientServiceProvider.loadService();
        ClientConfiguration config = ClientConfiguration.newBuilder()
            .setEndpoints("localhost:8081")
            .build();
        
        String topic = "ordered-message-topic";
        Producer producer = provider.newProducerBuilder()
            .setClientConfiguration(config)
            .setTopics(topic)
            .build();
        
        // 模拟订单状态变更（同一订单ID的消息必须顺序处理）
        String[] orderIds = {"order1001", "order1002", "order1001"};
        String[] orderStatus = {"CREATED", "PAYED", "SHIPPED"};
        
        for (int i = 0; i < orderIds.length; i++) {
            String orderId = orderIds[i];
            String status = orderStatus[i % orderStatus.length];
            
            // 关键：通过MessageGroup确保相同订单的消息发送到同一队列
            Message message = provider.newMessageBuilder()
                .setTopic(topic)
                .setBody(("订单[" + orderId + "]状态变更为: " + status).getBytes())
                .setMessageGroup(orderId) // 消息组决定消息路由的队列
                .setKeys(orderId) // 设置业务键便于查询
                .build();
            
            SendReceipt receipt = producer.send(message);
            System.out.println("发送顺序消息: " + receipt.getMessageId() 
                + ", 订单ID: " + orderId + ", 状态: " + status);
        }
        
        producer.close();
    }
}
3. 定时 / 延迟消息（Scheduled/Delay Message）

描述：消息发送后，需等待指定时间（或到达指定时间点）才会被消费者可见。
应用场景：订单超时自动关闭、任务调度、延迟重试。

import org.apache.rocketmq.client.apis.ClientConfiguration;
import org.apache.rocketmq.client.apis.ClientException;
import org.apache.rocketmq.client.apis.ClientServiceProvider;
import org.apache.rocketmq.client.apis.message.Message;
import org.apache.rocketmq.client.apis.producer.Producer;
import org.apache.rocketmq.client.apis.producer.SendReceipt;

import java.time.Duration;
import java.time.Instant;

public class DelayMessageExample {
    public static void main(String[] args) throws ClientException, InterruptedException {
        ClientServiceProvider provider = ClientServiceProvider.loadService();
        ClientConfiguration config = ClientConfiguration.newBuilder()
            .setEndpoints("localhost:8081")
            .build();
        
        String topic = "delay-message-topic";
        Producer producer = provider.newProducerBuilder()
            .setClientConfiguration(config)
            .setTopics(topic)
            .build();
        
        // 方式一：使用绝对时间戳（精确到毫秒）
        long timestamp = Instant.now().plus(Duration.ofMinutes(5)).toEpochMilli();
        Message messageByTimestamp = provider.newMessageBuilder()
            .setTopic(topic)
            .setBody("5分钟后执行的定时消息".getBytes())
            .setDeliveryTimestamp(timestamp) // 设置投递时间戳
            .build();
        
        // 方式二：使用预定义延迟级别（需Broker配置支持）
        Message messageByLevel = provider.newMessageBuilder()
            .setTopic(topic)
            .setBody("延迟30秒的消息".getBytes())
            .addProperty("DELAY", "3") // 假设3对应30秒（需Broker配置）
            .build();
        
        // 发送延迟消息
        SendReceipt receipt = producer.send(messageByTimestamp);
        System.out.println("延迟消息发送成功: " + receipt.getMessageId() 
            + ", 将于 " + Instant.ofEpochMilli(timestamp) + " 可见");
        
        producer.close();
    }
}
4. 事务消息（Transactional Message）

描述：
通过两阶段提交机制，保证本地事务与消息发送的最终一致性。

核心流程：

发送半消息（对消费者不可见）

  1. 执行本地事务
  2. 根据事务结果提交或回滚半消息
  3. 支持事务状态回查（处理超时情况）
import org.apache.rocketmq.client.apis.ClientConfiguration;
import org.apache.rocketmq.client.apis.ClientException;
import org.apache.rocketmq.client.apis.ClientServiceProvider;
import org.apache.rocketmq.client.apis.message.Message;
import org.apache.rocketmq.client.apis.producer.TransactionResolution;
import org.apache.rocketmq.client.apis.producer.TransactionalProducer;

public class TransactionalMessageExample {
    public static void main(String[] args) throws ClientException, InterruptedException {
        ClientServiceProvider provider = ClientServiceProvider.loadService();
        ClientConfiguration config = ClientConfiguration.newBuilder()
            .setEndpoints("localhost:8081")
            .build();
        
        String topic = "transactional-message-topic";
        TransactionalProducer producer = provider.newTransactionalProducerBuilder()
            .setClientConfiguration(config)
            .setTopics(topic)
            // 关键：设置事务状态回查处理器（当Broker长时间未收到事务状态时触发）
            .setTransactionChecker(messageView -> {
                System.out.println("回查事务状态: " + messageView.getBodyAsString());
                // 根据业务ID查询本地事务状态
                String bizId = messageView.getKeys().iterator().next();
                boolean transactionStatus = checkLocalTransactionStatus(bizId);
                return transactionStatus ? 
                    TransactionResolution.COMMIT : TransactionResolution.ROLLBACK;
            })
            .build();
        
        try {
            // 1. 开启事务上下文
            producer.beginTransaction();
            
            // 2. 发送半消息（未提交状态）
            Message message = provider.newMessageBuilder()
                .setTopic(topic)
                .setBody("用户账户扣款成功，通知库存系统扣减".getBytes())
                .setKeys("order_12345") // 设置业务键，用于回查
                .build();
            
            producer.send(message);
            
            // 3. 执行本地事务（如数据库操作）
            boolean localTransactionResult = executeLocalTransaction();
            
            // 4. 根据本地事务结果提交或回滚
            if (localTransactionResult) {
                producer.commit(); // 提交事务，消息对消费者可见
                System.out.println("本地事务执行成功，消息提交");
            } else {
                producer.rollback(); // 回滚事务，消息被丢弃
                System.out.println("本地事务执行失败，消息回滚");
            }
        } catch (Exception e) {
            producer.rollback(); // 异常时回滚
            e.printStackTrace();
        } finally {
            producer.close();
        }
    }
    
    private static boolean executeLocalTransaction() {
        // 模拟本地事务：如用户账户扣款
        System.out.println("执行本地事务...");
        return true; // 返回事务执行结果
    }
    
    private static boolean checkLocalTransactionStatus(String bizId) {
        // 模拟查询本地事务状态（如查询数据库订单状态）
        System.out.println("查询本地事务状态: " + bizId);
        return true; // 实际应根据业务ID查询真实状态
    }
}
5. 批量消息（Batch Message）

描述：将多条消息打包为一个批次发送，减少网络开销，提升吞吐量。
注意事项：

  • 所有消息必须属于同一 Topic
  • 总大小不能超过 4MB（默认限制，可配置）
  • 不支持事务和延迟属性
import org.apache.rocketmq.client.apis.ClientConfiguration;
import org.apache.rocketmq.client.apis.ClientException;
import org.apache.rocketmq.client.apis.ClientServiceProvider;
import org.apache.rocketmq.client.apis.message.Message;
import org.apache.rocketmq.client.apis.producer.Producer;
import org.apache.rocketmq.client.apis.producer.SendReceipt;

import java.util.ArrayList;
import java.util.List;

public class BatchMessageExample {
    public static void main(String[] args) throws ClientException, InterruptedException {
        ClientServiceProvider provider = ClientServiceProvider.loadService();
        ClientConfiguration config = ClientConfiguration.newBuilder()
            .setEndpoints("localhost:8081")
            .build();
        
        String topic = "batch-message-topic";
        Producer producer = provider.newProducerBuilder()
            .setClientConfiguration(config)
            .setTopics(topic)
            .build();
        
        // 创建批量消息集合
        List<Message> messages = new ArrayList<>();
        for (int i = 0; i < 100; i++) { // 示例：批量发送100条消息
            Message message = provider.newMessageBuilder()
                .setTopic(topic)
                .setBody(("批量消息-" + i).getBytes())
                .setKeys("key-" + i)
                .build();
            messages.add(message);
        }
        
        // 智能拆分大批次（避免超过4MB限制）
        List<List<Message>> batches = splitMessages(messages);
        
        // 发送所有批次
        for (List<Message> batch : batches) {
            List<SendReceipt> receipts = producer.send(batch);
            System.out.println("批量发送成功，共" + receipts.size() + "条消息");
        }
        
        producer.close();
    }
    
    // 智能拆分大批次消息（实际生产中建议实现）
    private static List<List<Message>> splitMessages(List<Message> messages) {
        // 简单实现：实际应根据消息大小动态拆分
        List<List<Message>> result = new ArrayList<>();
        result.add(messages);
        return result;
    }
}
6. 消费者示例（通用）

描述：RocketMQ 5.0 支持 Push 和 Pull 两种消费模式，以下是基于长轮询的 PushConsumer 示例。

import org.apache.rocketmq.client.apis.ClientConfiguration;
import org.apache.rocketmq.client.apis.ClientException;
import org.apache.rocketmq.client.apis.ClientServiceProvider;
import org.apache.rocketmq.client.apis.consumer.ConsumeResult;
import org.apache.rocketmq.client.apis.consumer.FilterExpression;
import org.apache.rocketmq.client.apis.consumer.FilterExpressionType;
import org.apache.rocketmq.client.apis.consumer.PushConsumer;

import java.time.Duration;

public class ConsumerExample {
    public static void main(String[] args) throws ClientException, InterruptedException {
        ClientServiceProvider provider = ClientServiceProvider.loadService();
        ClientConfiguration config = ClientConfiguration.newBuilder()
            .setEndpoints("localhost:8081")
            .build();
        
        // 订阅主题和过滤表达式（支持SQL92语法）
        String topic = "normal-message-topic";
        FilterExpression filterExpression = new FilterExpression(
            "TAG = 'order' AND age > 18", // 示例SQL过滤条件
            FilterExpressionType.SQL92
        );
        
        // 创建PushConsumer（基于长轮询的"伪推"模式）
        PushConsumer consumer = provider.newPushConsumerBuilder()
            .setClientConfiguration(config)
            .setConsumerGroup("my-consumer-group") // 消费组决定消息负载方式
            .setSubscriptionExpressions(Map.of(topic, filterExpression))
            .setMaxPollInterval(Duration.ofSeconds(30)) // 长轮询超时时间
            .setConsumptionThreadCount(10) // 消费线程数
            .setMessageListener(messageView -> {
                try {
                    // 处理消息逻辑（业务代码）
                    System.out.println("接收到消息: " + messageView.getBodyAsString());
                    System.out.println("消息属性: " + messageView.getProperties());
                    
                    // 模拟业务处理耗时
                    Thread.sleep(100);
                    
                    // 返回消费结果（成功/失败）
                    return ConsumeResult.SUCCESS;
                } catch (Exception e) {
                    // 消费失败时返回RETRY，消息将重试消费
                    System.out.println("消息消费失败: " + e.getMessage());
                    return ConsumeResult.FAILURE;
                }
            })
            .build();
        
        // 保持主线程运行，避免消费者立即关闭
        System.out.println("消费者已启动，按Ctrl+C退出...");
        Thread.sleep(Long.MAX_VALUE);
    }
}

关键依赖配置（Maven）

<dependencies>
    <!-- RocketMQ 5.0 Java客户端 -->
    <dependency>
        <groupId>org.apache.rocketmq</groupId>
        <artifactId>rocketmq-client-java</artifactId>
        <version>5.1.0</version>
    </dependency>
    
    <!-- gRPC依赖 -->
    <dependency>
        <groupId>io.grpc</groupId>
        <artifactId>grpc-netty-shaded</artifactId>
        <version>1.54.0</version>
    </dependency>
    
    <!-- 序列化依赖 -->
    <dependency>
        <groupId>com.google.protobuf</groupId>
        <artifactId>protobuf-java</artifactId>
        <version>3.21.9</version>
    </dependency>
</dependencies>

三、最佳实践建议

  1. 连接配置：

    • 生产环境建议使用域名而非 IP，支持动态扩容
    • 开启 TLS 加密（通过ClientConfiguration.setSslTrustStorePath）

  2. 消息大小：

    • 单条消息建议不超过 1MB
    • 批量消息总大小不超过 4MB（可通过producer.setMaxMessageSize调整）

  3. 异常处理：

    • 生产者需捕获ClientException并实现重试逻辑
    • 消费者应避免长时间阻塞，建议使用异步处理

  4. 性能调优：

    • 生产者：调整sendMsgTimeout和maxAttempts参数
    • 消费者：根据业务吞吐量调整consumptionThreadCount

  5. 监控告警：

    • 监控 Topic 的 TPS、RT、堆积量等指标
    • 配置告警阈值（如单队列堆积超过 10 万条）

四、总结

RocketMQ支持多种消息类型以满足不同业务需求：普通消息适用于高吞吐场景；顺序消息保证消费顺序；定时/延迟消息控制投递时间；事务消息确保分布式事务一致性；批量消息提升吞吐量。每种类型都提供了对应的Java代码示例，包括生产者配置、消息构建和发送逻辑。最佳实践建议包括合理配置连接、控制消息大小、完善异常处理、性能调优和监控告警。通过解耦消息传递与业务逻辑，RocketMQ实现了高性能、高可靠的分布式通信能力。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2385719.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

安卓无障碍脚本开发全教程

安卓无障碍脚本开发全教程

文章目录 第一部分&#xff1a;无障碍服务基础1.1 无障碍服务概述核心功能&#xff1a; 1.2 基本原理与架构1.3 开发环境配置所需工具&#xff1a;关键依赖&#xff1a; 第二部分&#xff1a;创建基础无障碍服务2.1 服务声明配置2.2 服务配置文件关键属性说明&#xff1a; 2.3 …
阅读更多...
SOC-ESP32S3部分：10-GPIO中断按键中断实现

SOC-ESP32S3部分：10-GPIO中断按键中断实现

飞书文档https://x509p6c8to.feishu.cn/wiki/W4Wlw45P2izk5PkfXEaceMAunKg 学习了GPIO输入和输出功能后&#xff0c;参考示例工程&#xff0c;我们再来看看GPIO中断&#xff0c;IO中断的配置分为三步 配置中断触发类型安装中断服务注册中断回调函数 ESP32-S3的所有通用GPIO…
阅读更多...
战略-2.1 -战略分析（PEST/五力模型/成功关键因素）

战略-2.1 -战略分析（PEST/五力模型/成功关键因素）

战略分析路径&#xff0c;先宏观&#xff08;PEST&#xff09;、再产业&#xff08;产品生命周期、五力模型、成功关键因素&#xff09;、再竞争对手分析、最后企业内部分析。 本文介绍&#xff1a;PEST、产品生命周期、五力模型、成功关键因素、产业内的战略群组 一、宏观环境…
阅读更多...
python第三方库安装错位

python第三方库安装错位

问题所在 今天在安装我的django库时&#xff0c;我的库安装到了python3.13版本。我本意是想安装到python3.11版本的。我的pycharm右下角也设置了python3.11 但是太可恶了&#xff0c;我在pycharm的项目终端执行安装命令的时候还是给我安装到了python3.13的位置。 解决方法 我…
阅读更多...
如何把vue项目部署在nginx上

如何把vue项目部署在nginx上

1&#xff1a;在vscode中把vue项目打包会出现dist文件夹 按照图示内容即可把vue项目部署在nginx上
阅读更多...
Vue3集成Element Plus完整指南：从安装到主题定制下-实现后台管理系统框架搭建

Vue3集成Element Plus完整指南：从安装到主题定制下-实现后台管理系统框架搭建

本文将详细介绍如何使用 Vue 3 构建一个综合管理系统&#xff0c;包括路由配置、页面布局以及常用组件集成。 一、路由配置 首先&#xff0c;我们来看系统的路由配置&#xff0c;这是整个应用的基础架构&#xff1a; import {createRouter, createWebHistory} from vue-rout…
阅读更多...
SpringBoot项目配置文件、yml配置文件

SpringBoot项目配置文件、yml配置文件

一. 配置文件格式 1. SpringBoot项目提供了多种属性配置方式(properties、yaml、yml)。 二. yml配置文件 1. 格式&#xff1a; (1) 数值前边必须有空格&#xff0c;作为分隔符。 (2) 使用缩进表示层级关系&#xff0c;缩进时&#xff0c;不允许使用Tab键&#xff0c;只能使用空…
阅读更多...
windows11 安装 jupyter lab

windows11 安装 jupyter lab

1、安装python环境 略 2、安装jupyterlab pip install jupyterlab 3、将jupyterlab的目录配置到path pip show jupyterlab 看到location的值&#xff0c;那么 jupyterlab就安装在与之同级的Scripts下&#xff0c;将Scripts目录设置在Path即可。
阅读更多...
【算法】：动态规划--背包问题

【算法】：动态规划--背包问题

背包问题 引言 什么是背包问题&#xff1f; 背包问题就是一个有限的背包&#xff0c;给出一定的物品&#xff0c;如何合理的装入物品使得背包中的物品的价值最大&#xff1f; 01背包 01背包&#xff0c;顾名思义就是每一种给定的物品要么选择&#xff0c;要么不选&#xff…
阅读更多...
Nginx核心功能

Nginx核心功能

目录 前言一. 正向代理1.配置正向代理&#xff08;1&#xff09;添加正向代理&#xff08;2&#xff09;验证正向代理 二. 反向代理1.配置nginx七层代理&#xff08;1&#xff09;环境安装&#xff08;2&#xff09;配置nginx七层代理转发&#xff08;3&#xff09;测试 2. 配置…
阅读更多...
upload-labs通关笔记-第15关 文件上传之图片马getimagesize绕过

upload-labs通关笔记-第15关 文件上传之图片马getimagesize绕过

系列目录 upload-labs通关笔记-第1关 文件上传之前端绕过&#xff08;3种渗透方法&#xff09; upload-labs通关笔记-第2关 文件上传之MIME绕过-CSDN博客 upload-labs通关笔记-第3关 文件上传之黑名单绕过-CSDN博客 upload-labs通关笔记-第4关 文件上传之.htacess绕过-CSDN…
阅读更多...
【游戏设计】游戏玩法与游戏机制

【游戏设计】游戏玩法与游戏机制

在游戏设计中&#xff0c;“玩法”&#xff08;Gameplay&#xff09;和“机制”&#xff08;Game Mechanic&#xff09;是两个频繁出现但容易混淆的概念。许多新手开发者、设计师甚至玩家常常将两者混为一谈。本文将通过定义、对比和案例解析的方式&#xff0c;清晰地阐明二者的…
阅读更多...
Spring的资源Resource和ResourceLoader

Spring的资源Resource和ResourceLoader

两者区别和联系 Resource 和ResourceLoader 都是 Spring 框架中用于资源访问的接口 Resource 是“资源本身”&#xff0c;ResourceLoader 是“资源工厂/加载器”&#xff0c;负责创建 Resource。 ​ Resource:Spring 统一抽象的“资源”对象,可以表示文件、类路径下的文件、U…
阅读更多...
【AI实战】从“苦AI”到“爽AI”：Magentic-UI 把“人类-多智能体协作”玩明白了！

【AI实战】从“苦AI”到“爽AI”：Magentic-UI 把“人类-多智能体协作”玩明白了！

Hello&#xff0c;亲爱的小伙伴们&#xff01;你是否曾经在深夜里&#xff0c;为了自动化点外卖、筛机票、抓网页数据焦头烂额&#xff1f;有没有幻想过哪天能出个“贴心AI管家”&#xff0c;一键点菜、搞定事务、自动操作网页&#xff0c;比你还懂你&#xff1f;更关键——还让…
阅读更多...
Linux之 SPI 驱动框架- spi-mem 框架

Linux之 SPI 驱动框架- spi-mem 框架

一、框架变更的历程 1.1 旧框架图 1.2 新框架图 那么问题来了&#xff0c; 为什么要开发新的 SPI 存储器接口&#xff1f; 有了这个新的框架&#xff0c; SPI NOR 和SPI NAND 都可以基于相同的SPI控制器驱动进行支持了。m25p80 驱动将被修改成&#xff0c;使用spi-mem 接口&a…
阅读更多...
振动分析 - 献个宝

振动分析 - 献个宝

1.一个自制的振动能量分析工具 这个分析工具似乎真的定位到了故障的具体位置。 1.1对一组实验室虚拟信号的分析结果： 1.2 对现场真实数据的分析结果 依照边频带的调制，和边频的缝隙宽度，基本定位到问题。 追加几份待看的文档： 齿轮结构的频谱特征 - 知乎使用 FFT 获得…
阅读更多...
【论文阅读】——D^3-Human: Dynamic Disentangled Digital Human from Monocular Vi

【论文阅读】——D^3-Human: Dynamic Disentangled Digital Human from Monocular Vi

文章目录 摘要1 引言2 相关工作3 方法3.1 HmSDF 表示3.2 区域聚合3.3. 变形场3.4. 遮挡感知可微分渲染3.5 训练3.5.1 训练策略3.5.2 重建损失3.5.3 正则化限制 4. 实验4.1 定量评估4.2 定性评价4.3 消融研究4.4 应用程序 5 结论 摘要 我们介绍 D 3 D^{3} D3人&#xff0c;一种…
阅读更多...
高分辨率北半球多年冻土数据集（2000-2016）

高分辨率北半球多年冻土数据集（2000-2016）

关键数据集分类&#xff1a;冰冻圈数据集时间分辨率&#xff1a;10 year < x < 100 year空间分辨率&#xff1a;1km - 10km共享方式&#xff1a;开放获取数据大小&#xff1a;339.79 MB数据时间范围&#xff1a;2000-01-01 — 2016-12-31元数据更新时间&#xff1a;2022-…
阅读更多...
基于开源AI智能名片链动2+1模式S2B2C商城小程序的管理与运营策略研究

基于开源AI智能名片链动2+1模式S2B2C商城小程序的管理与运营策略研究

摘要&#xff1a;本文通过分析开源AI智能名片链动21模式S2B2C商城小程序的技术架构与商业逻辑&#xff0c;探讨其在企业管理与运营中的实践价值。结合案例研究&#xff0c;论证该模式如何通过清晰的目标设定、动态反馈机制和资源整合能力&#xff0c;提升团队执行力与客户粘性。…
阅读更多...
储能电站：风光储一体化能源中心数字孪生

储能电站：风光储一体化能源中心数字孪生

在 “双碳” 目标引领下&#xff0c;我国能源产业加速向清洁低碳、绿色化转型&#xff0c;风能、太阳能等可再生能源的开发利用成为关键。然而&#xff0c;风能和太阳能的波动性、间歇性与随机性&#xff0c;给大规模接入电网带来挑战。储能技术的兴起&#xff0c;为解决这一难…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023