Java 8 精准筛选24小时内的记录

业务场景与传统方法面临的挑战

在许多业务场景中，我们需要根据特定的时间窗口来筛选数据。例如，一个常见的需求是每天早上7点，需要汇总并发送前一天早上6点到当天早上6点之间创建的所有记录。如果使用传统的java.util.Date和java.util.Calendar API来处理这类滚动时间窗口的逻辑，代码往往会变得冗长、复杂且容易出错。

考虑以下使用Calendar API实现类似逻辑的示例：

Date disturbanceDate = disruptionEventEntity.getDisturbanceDate();

Calendar now = Calendar.getInstance();
now.setTime(disturbanceDate);

// 定义时间窗口的开始和结束
Calendar before = Calendar.getInstance();
before.set(Calendar.HOUR_OF_DAY, 6);
before.set(Calendar.MINUTE, 0);
before.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY); // 硬编码星期几，不灵活
// ... 还需要为其他日期设置相同的逻辑

Calendar after = Calendar.getInstance();
after.set(Calendar.HOUR_OF_DAY, 6);
after.set(Calendar.MINUTE, 0);
after.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY); // 硬编码星期几，不灵活

boolean between = now.before(after) && now.after(before);
if (between){
  // 如果记录在此时间段内，则进行处理
}

这种方法存在几个明显的问题：

1. 代码重复与冗余： 对于不同的日期，需要重复设置Calendar实例的DAY_OF_WEEK等字段，导致代码难以维护。
2. 可读性差： Calendar的API设计相对复杂，理解其操作需要更多的上下文。
3. 易出错： 硬编码日期或星期几容易引入逻辑错误，尤其是在跨越月份或年份时。
4. 线程不安全： Calendar不是线程安全的，在多线程环境下可能导致问题。

使用 java.time API 优化解决方案

Java 8引入的java.time包（JSR-310）提供了一套全新的日期和时间API，旨在解决传统API的痛点。它具有不可变性、清晰的语义和链式操作等优点，非常适合处理这类时间窗口逻辑。

下面我们将展示如何使用java.time API来优雅地实现上述需求：筛选出在“昨天早上6点”到“今天早上6点”之间创建的记录。

1. 将传统 Date 转换为 java.time 对象

如果你的数据源仍然使用java.util.Date来存储时间，第一步是将其转换为java.time包中的对象，通常是LocalDateTime或ZonedDateTime。考虑到业务需求通常不涉及复杂的时区转换，LocalDateTime是一个不错的选择。

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.Date; // 假设这是从实体获取的旧Date对象

// 获取旧的java.util.Date对象
Date disturbanceDateOld = disruptionEventEntity.getDisturbanceDate();

// 将java.util.Date转换为LocalDateTime
// 1. 转换为Instant（时间戳）
// 2. 指定时区（系统默认时区或特定时区）
// 3. 转换为LocalDateTime
LocalDateTime disturbanceDate = disturbanceDateOld.toInstant()
                                                  .atZone(ZoneId.systemDefault()) // 使用系统默认时区，或指定如 ZoneId.of("Asia/Shanghai")
                                                  .toLocalDateTime();

注意事项：

• ZoneId.systemDefault()用于获取当前系统的默认时区。在生产环境中，建议明确指定一个时区（例如ZoneId.of("Asia/Shanghai")），以避免因服务器时区设置不同而导致的问题。
• 如果disturbanceDateOld可能为null，请添加相应的null检查。

2. 定义时间窗口的边界

接下来，我们需要定义“今天早上6点”和“昨天早上6点”这两个时间点作为筛选的边界。

// 获取当前日期，并结合指定时间点（早上6点）
// 首先获取当前日期的LocalDate部分
// 然后结合LocalTime.of(6, 0, 0)创建今天早上6点的LocalDateTime
LocalDateTime todayAtSix = LocalDateTime.of(
    LocalDate.now(ZoneId.systemDefault()), // 同样使用指定时区获取当前日期
    LocalTime.of(6, 0, 0)
);

// 计算昨天早上6点
// 在todayAtSix的基础上减去一天
LocalDateTime yesterdayAtSix = todayAtSix.minusDays(1);

通过LocalDate.now()获取当前日期，然后结合LocalTime.of(6, 0, 0)精确构造出LocalDateTime对象。minusDays(1)方法则以非常直观的方式计算出前一天的同一时间。

3. 执行时间范围判断

有了记录的创建时间(disturbanceDate)和时间窗口的两个边界(yesterdayAtSix, todayAtSix)，现在可以进行判断了。java.time对象提供了isAfter(), isBefore(), isEqual()等方法进行比较。

if (disturbanceDate.isAfter(yesterdayAtSix) && disturbanceDate.isBefore(todayAtSix)) {
    // 如果记录的创建时间在“昨天早上6点”之后
    // 并且在“今天早上6点”之前，则满足条件
    // 在此执行发送记录到集成系统等业务逻辑
    System.out.println("记录 " + disturbanceDate + " 在指定时间窗口内，进行处理。");
} else {
    System.out.println("记录 " + disturbanceDate + " 不在指定时间窗口内。");
}

完整示例代码

将上述步骤整合起来，完整的解决方案如下：

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.Date;

public class RecordFilteringService {

    // 假设这是一个模拟的实体类，实际中会从数据库或其他地方获取
    static class DisruptionEventEntity {
        private Date disturbanceDate;

        public DisruptionEventEntity(Date disturbanceDate) {
            this.disturbanceDate = disturbanceDate;
        }

        public Date getDisturbanceDate() {
            return disturbanceDate;
        }
    }

    public void processRecordsCreatedWithinLast24Hours(DisruptionEventEntity disruptionEventEntity) {
        // 1. 将旧的java.util.Date转换为LocalDateTime
        LocalDateTime disturbanceDate = disruptionEventEntity.getDisturbanceDate()
                                                            .toInstant()
                                                            .atZone(ZoneId.systemDefault()) // 建议使用明确的时区，例如 ZoneId.of("Asia/Shanghai")
                                                            .toLocalDateTime();

        // 2. 定义时间窗口的边界
        // 获取当前日期，并设定时间为早上6点
        LocalDateTime todayAtSix = LocalDateTime.of(
            LocalDate.now(ZoneId.systemDefault()),
            LocalTime.of(6, 0, 0)
        );

        // 计算昨天早上6点
        LocalDateTime yesterdayAtSix = todayAtSix.minusDays(1);

        // 3. 执行时间范围判断
        // 注意：isAfter和isBefore是排他性的，即不包含边界时间点
        if (disturbanceDate.isAfter(yesterdayAtSix) && disturbanceDate.isBefore(todayAtSix)) {
            // 如果记录的创建时间在“昨天早上6点”之后且在“今天早上6点”之前
            System.out.println("记录创建时间: " + disturbanceDate + " 满足条件，进行处理。");
            // 在此执行发送记录到集成系统等业务逻辑
        } else {
            System.out.println("记录创建时间: " + disturbanceDate + " 不满足条件。");
        }
    }

    public static void main(String[] args) {
        RecordFilteringService service = new RecordFilteringService();

        // 模拟一些记录
        // 假设当前是 2023-10-25 09:00:00
        // todayAtSix 会是 2023-10-25 06:00:00
        // yesterdayAtSix 会是 2023-10-24 06:00:00

        // 满足条件的记录 (2023-10-24 07:00:00)
        service.processRecordsCreatedWithinLast24Hours(new DisruptionEventEntity(
            Date.from(LocalDateTime.of(2023, 10, 24, 7, 0).atZone(ZoneId.systemDefault()).toInstant())
        ));

        // 不满足条件的记录 (早于昨天6点: 2023-10-24 05:00:00)
        service.processRecordsCreatedWithinLast24Hours(new DisruptionEventEntity(
            Date.from(LocalDateTime.of(2023, 10, 24, 5, 0).atZone(ZoneId.systemDefault()).toInstant())
        ));

        // 不满足条件的记录 (晚于今天6点: 2023-10-25 07:00:00)
        service.processRecordsCreatedWithinLast24Hours(new DisruptionEventEntity(
            Date.from(LocalDateTime.of(2023, 10, 25, 7, 0).atZone(ZoneId.systemDefault()).toInstant())
        ));

        // 边界情况：恰好是昨天6点（不包含）
        service.processRecordsCreatedWithinLast24Hours(new DisruptionEventEntity(
            Date.from(LocalDateTime.of(2023, 10, 24, 6, 0).atZone(ZoneId.systemDefault()).toInstant())
        ));

        // 边界情况：恰好是今天6点（不包含）
        service.processRecordsCreatedWithinLast24Hours(new DisruptionEventEntity(
            Date.from(LocalDateTime.of(2023, 10, 25, 6, 0).atZone(ZoneId.systemDefault()).toInstant())
        ));
    }
}

关键优势与注意事项

1. 清晰与简洁： java.time API的命名和设计更符合人类的直观理解，minusDays(), isAfter(), isBefore()等方法使得代码意图一目了然。
2. 不可变性： java.time中的所有核心类（如LocalDateTime, LocalDate, LocalTime等）都是不可变的，这意味着它们是线程安全的，并且每次操作都会返回一个新的实例，避免了副作用。
3. 时区处理： java.time提供了强大的时区处理能力。在将java.util.Date转换为LocalDateTime时，务必考虑时区，并使用atZone(ZoneId)明确指定。如果忽略时区，可能会导致跨时区系统中的时间偏差。
4. 边界条件： isAfter()和isBefore()是排他性的，即它们不包含边界时间点。如果业务需求是包含边界时间点（例如“从昨天6点开始，到今天6点结束，包含6点整”），则需要使用isAfter(yesterdayAtSix) || disturbanceDate.isEqual(yesterdayAtSix)以及isBefore(todayAtSix) || disturbanceDate.isEqual(todayAtSix)，或者更简洁地使用!disturbanceDate.isBefore(yesterdayAtSix)和!disturbanceDate.isAfter(todayAtSix)。
5. 灵活性： 轻松调整时间窗口。例如，如果需要筛选过去48小时的记录，只需将minusDays(1)改为minusDays(2)。如果需要更改报告时间，只需修改LocalTime.of(6, 0, 0)。

总结

通过采用Java 8的java.time API，我们可以将复杂且易错的日期时间处理逻辑转化为简洁、清晰、健壮的代码。这不仅提升了开发效率，也大大降低了因日期时间处理不当而引发的潜在问题。在任何需要进行日期时间计算和比较的Java项目中，强烈推荐优先使用java.time包。