Java学习笔记（十八）

最新推荐文章于 2025-03-30 11:41:06 发布

路上阡陌

最新推荐文章于 2025-03-30 11:41:06 发布

阅读量1k

点赞数 25

文章标签： java 学习笔记

本文链接：https://blog.youkuaiyun.com/m0_51431003/article/details/143686848

版权

com.baomidou.mybatisplus.annotation.EnumValue

@EnumValue 是 MyBatis-Plus 框架中的一个注解，它主要用于将数据库中的枚举类型字段映射到 Java 枚举类型。通过使用 @EnumValue 注解，开发者可以轻松地实现枚举值与数据库字段的映射，避免了手动转换的繁琐步骤。以下是对 @EnumValue 注解的详细介绍：

一、作用

@EnumValue 注解标记在枚举类型的字段上，表示该字段是枚举值在数据库中存储的实际值。这对于枚举的持久化是关键，它确保枚举在数据库中的表示与 Java 枚举类的一致性。

二、应用场景

当数据库中的某个字段需要存储枚举类型的值（如状态码、类型标识符）时，可以使用 @EnumValue 注解来明确该字段。这有助于代码的清晰和一致性，同时简化了持久化逻辑。

三、使用方式

定义枚举类：

在枚举类中，使用 @EnumValue 注解来标记哪个字段将用于数据库存储。例如：

import com.baomidou.mybatisplus.annotation.EnumValue;

public enum Status {
    @EnumValue("1")
    ACTIVE("Active"),
    @EnumValue("0")
    INACTIVE("Inactive");

    private final String description;

    Status(String description) {
        this.description = description;
    }

    public String getDescription() {
        return description;
    }

    public static Status fromCode(String code) {
        for (Status status : values()) {
            if (status.name().equals(code)) { // 注意：这里应根据实际存储的字段进行比较，例如使用code字段
                return status;
            }
        }
        throw new IllegalArgumentException("Unknown code: " + code);
    }
}

注意：在上面的示例中，@EnumValue 注解被用在了枚举的构造函数参数上（虽然这通常不是标准用法，因为 @EnumValue 通常直接标注在枚举字段上，这里仅为了说明如何使用）。在实际应用中，应该有一个单独的字段（如 code）来存储数据库中的值，并使用 @EnumValue 注解来标记这个字段。

正确的用法应该像这样：

public enum Status {
    ACTIVE(@EnumValue("1") 1, "Active"),
    INACTIVE(@EnumValue("0") 0, "Inactive");

    @EnumValue
    private final int code; // 这个字段用于数据库存储
    private final String description;

    // 构造函数和其他方法...
}

但请注意，由于 Java 注解的限制，上面的代码在语法上是不正确的。在实际应用中，@EnumValue 通常标注在枚举的一个字段上，并通过枚举的构造函数或其他方法设置该字段的值。然而，MyBatis-Plus 在处理枚举时，通常是通过枚举的 name() 方法或自定义的转换逻辑来映射数据库值的，因此上面的示例主要是为了说明 @EnumValue 的用途，而不是一个可运行的代码。

正确的做法可能是定义一个包含 @EnumValue 注解的字段，并在 MyBatis-Plus 的配置中指定使用哪个字段进行映射（这通常是通过配置或自定义类型处理器来实现的）。

在实体类中使用枚举类型：

在实体类中，直接使用枚举类型作为字段类型，并配置 MyBatis-Plus 来处理枚举与数据库字段之间的映射。
配置 MyBatis-Plus：

根据需要，可以在 MyBatis-Plus 的配置中指定枚举类型的处理策略，例如使用哪个字段进行映射、是否使用自定义的类型处理器等。

四、注意事项

@EnumValue 注解通常与 MyBatis-Plus 的枚举类型处理器一起使用，以确保枚举值在数据库中的正确存储和读取。
在使用 @EnumValue 注解时，应确保枚举类中的字段与数据库中的字段类型一致。
如果数据库中的枚举值不是简单的字符串或数字，可能需要自定义类型处理器来处理枚举与数据库字段之间的映射。

综上所述，@EnumValue 注解是 MyBatis-Plus 中用于处理枚举类型字段映射的一个非常有用的工具。通过合理使用这个注解，开发者可以更加便捷地实现枚举值与数据库字段之间的映射，提高开发效率和代码质量。

Redis Stream

Redis Stream 是一种专门为处理消息队列和事件流设计的数据结构，它允许你以一种高效且持久化的方式存储和读取消息。以下是对 Redis Stream 结构的详细介绍，以及使用 Java 和 Jedis 库进行操作的代码示例。

Redis Stream 结构

Stream Key：
- 每个 Stream 都有一个唯一的键来标识它，这个键在 Redis 中就像其他任何键值对一样。
Message ID：
- 每条消息都有一个全局唯一的 ID，这个 ID 是由两部分组成的：一个时间戳（毫秒级）和一个序列号（在该时间戳内生成的消息的递增序号）。
Message Content：
- 每条消息包含一个或多个键值对，这些键值对构成了消息的实际内容。
Consumer Groups：
- 一个 Stream 可以有多个消费者组，每个消费者组内部维护一个游标（Last Delivered ID, LDID），用来跟踪组内消费者已经处理过的最新消息。
- 每个消费者组内的消费者可以并行地读取和处理消息，但它们共享同一个游标。
Pending Entries：
- 对于每个消费者，Redis 会维护一个待处理消息的列表（Pending Entries List, PEL），这个列表包含了消费者已经读取但尚未确认的消息。

使用 Jedis 操作 Redis Stream

以下是如何在 Java 中使用 Jedis 库来操作 Redis Stream 的示例代码。

依赖项

首先，你需要在你的项目中添加 Jedis 库的依赖项。如果你使用的是 Maven，你可以在 pom.xml 文件中添加以下依赖：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.0.1</version> <!-- 请使用最新版本 -->
</dependency>

添加消息到 Stream

import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.XAddParams;

import java.util.HashMap;
import java.util.Map;

public class RedisStreamExample {

    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379); // 连接到 Redis 服务器

        String streamKey = "mystream";
        Map<String, String> message = new HashMap<>();
        message.put("field1", "value1");
        message.put("field2", "value2");

        // 使用 XADD 命令添加消息到 Stream
        String messageId = jedis.xadd(streamKey, XAddParams.xAddParams().maxLen(1000).approx(), message);
        System.out.println("Added message with ID: " + messageId);

        jedis.close();
    }
}

读取消息

import redis.clients.jedis.Jedis;
import redis.clients.jedis.StreamEntryID;
import redis.clients.jedis.Tuple;

import java.util.List;
import java.util.Map;

public class ReadMessagesExample {

    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379); // 连接到 Redis 服务器

        String streamKey = "mystream";
        String lastId = "0"; // 从 Stream 的起始位置开始读取

        // 使用 XREAD 命令读取消息
        List<Map.Entry<String, List<Map.Entry<StreamEntryID, List<Tuple>>>>> messages = jedis.xread(
                1, // 阻塞超时（秒），0 表示非阻塞
                Map.of(streamKey, List.of(new StreamEntryID(lastId)))
        );

        for (Map.Entry<String, List<Map.Entry<StreamEntryID, List<Tuple>>>> entry : messages) {
            String key = entry.getKey();
            for (Map.Entry<StreamEntryID, List<Tuple>> messageEntry : entry.getValue()) {
                StreamEntryID messageId = messageEntry.getKey();
                List<Tuple> messageFields = messageEntry.getValue();
                System.out.println("Message ID: " + messageId);
                for (Tuple tuple : messageFields) {
                    System.out.println("Field: " + tuple.getField() + ", Value: " + tuple.getValue());
                }
            }
        }

        jedis.close();
    }
}

使用消费者组读取消息

import redis.clients.jedis.Jedis;
import redis.clients.jedis.StreamEntryID;
import redis.clients.jedis.Tuple;

import java.util.List;
import java.util.Map;

public class ConsumerGroupExample {

    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379); // 连接到 Redis 服务器

        String streamKey = "mystream";
        String consumerGroup = "mygroup";
        String consumerName = "myconsumer";
        String startId = "0"; // 从 Stream 的起始位置开始读取

        // 创建消费者组（如果已存在会报错，可以添加异常处理）
        try {
            jedis.xgroupCreate(streamKey, consumerGroup, startId, true);
        } catch (Exception e) {
            if (!"BUSYGROUP Consumer Group name already exists".equals(e.getMessage())) {
                throw e;
            }
        }

        // 使用 XREADGROUP 命令读取消息
        List<Map.Entry<String, List<Map.Entry<StreamEntryID, List<Tuple>>>>> messages = jedis.xreadGroup(
                consumerGroup,
                consumerName,
                1, // 阻塞超时（秒），0 表示非阻塞
                Map.of(streamKey, List.of(new StreamEntryID(startId), ">")) // 从消费者组的起始位置开始读取新消息
        );

        for (Map.Entry<String, List<Map.Entry<StreamEntryID, List<Tuple>>>> entry : messages) {
            String key = entry.getKey();
            for (Map.Entry<StreamEntryID, List<Tuple>> messageEntry : entry.getValue()) {
                StreamEntryID messageId = messageEntry.getKey();
                List<Tuple> messageFields = messageEntry.getValue();
                System.out.println("Message ID: " + messageId);
                for (Tuple tuple : messageFields) {
                    System.out.println("Field: " + tuple.getField() + ", Value: " + tuple.getValue());
                }

                // 处理消息后确认
                jedis.xack(streamKey, consumerGroup, messageId);
            }
        }

        jedis.close();
    }
}

Redis Stream 每个消息只会被消费者组其中一个消费者消费一次吗

在Redis Stream中，每个消息确实只会被消费者组中的一个消费者消费一次。这一机制确保了消息的高效且可靠的传递。

在Redis Stream中，消费者组（Consumer Groups）是一个核心概念。通过使用消费者组，可以实现多个消费者共同消费消息，但每个消息在这个组内只会被一个消费者处理。这是如何工作的呢？

消费者组的创建：首先，需要使用XGROUP CREATE命令创建一个消费者组。这个命令会指定一个流（Stream）和一个消费者组的名称，并设置消费者组开始消费的起始消息ID。
消息的消费：当消息被添加到流中时，消费者组中的消费者可以使用XREADGROUP命令来读取这些消息。Redis Stream会确保每条消息在消费者组内部只被一个消费者读取到。
消费状态的管理：每个消费者组都有一个名为last_delivered_id的游标，它在流中的消息数组上向前移动，表示当前消费者组已经消费到哪条消息了。这样，即使有多个消费者同时读取消息，也能确保每条消息只被处理一次。
消息的确认：消费者处理完消息后，需要使用XACK命令来确认消息已被处理。这个命令会告诉Redis Stream这条消息已经被成功消费，可以从消费者的待处理消息列表中移除。

如果不使用消费者组，那么所有连接到该Stream的消费者都将接收到相同的消息，这可能会导致重复消费。但通过使用消费者组，Redis Stream提供了高效且可靠的消息处理机制，确保了每条消息只会被特定的消费者处理一次。

因此，可以得出结论：在Redis Stream中，每个消息只会被消费者组中的一个消费者消费一次。