业务场景与传统方法面临的挑战
在许多业务场景中，我们需要根据特定的时间窗口来筛选数据。例如，一个常见的需求是每天早上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){
// 如果记录在此时间段内，则进行处理
}这种方法存在几个明显的问题：
- 代码重复与冗余： 对于不同的日期，需要重复设置Calendar实例的DAY_OF_WEEK等字段，导致代码难以维护。
- 可读性差： Calendar的API设计相对复杂，理解其操作需要更多的上下文。
- 易出错： 硬编码日期或星期几容易引入逻辑错误，尤其是在跨越月份或年份时。
- 线程不安全： Calendar不是线程安全的，在多线程环境下可能导致问题。
使用 java.time API 优化解决方案
Java 8引入的java.time包（JSR-310）提供了一套全新的日期和时间API，旨在解决传统API的痛点。它具有不可变性、清晰的语义和链式操作等优点，非常适合处理这类时间窗口逻辑。
下面我们将展示如何使用java.time API来优雅地实现上述需求：筛选出在“昨天早上6点”到“今天早上6点”之间创建的记录。
立即学习“Java免费学习笔记（深入）”；
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())
));
}
}关键优势与注意事项
- 清晰与简洁： java.time API的命名和设计更符合人类的直观理解，minusDays(), isAfter(), isBefore()等方法使得代码意图一目了然。
- 不可变性： java.time中的所有核心类（如LocalDateTime, LocalDate, LocalTime等）都是不可变的，这意味着它们是线程安全的，并且每次操作都会返回一个新的实例，避免了副作用。
- 时区处理： java.time提供了强大的时区处理能力。在将java.util.Date转换为LocalDateTime时，务必考虑时区，并使用atZone(ZoneId)明确指定。如果忽略时区，可能会导致跨时区系统中的时间偏差。
- 边界条件： isAfter()和isBefore()是排他性的，即它们不包含边界时间点。如果业务需求是包含边界时间点（例如“从昨天6点开始，到今天6点结束，包含6点整”），则需要使用isAfter(yesterdayAtSix) || disturbanceDate.isEqual(yesterdayAtSix)以及isBefore(todayAtSix) || disturbanceDate.isEqual(todayAtSix)，或者更简洁地使用!disturbanceDate.isBefore(yesterdayAtSix)和!disturbanceDate.isAfter(todayAtSix)。
- 灵活性： 轻松调整时间窗口。例如，如果需要筛选过去48小时的记录，只需将minusDays(1)改为minusDays(2)。如果需要更改报告时间，只需修改LocalTime.of(6, 0, 0)。
总结
通过采用Java 8的java.time API，我们可以将复杂且易错的日期时间处理逻辑转化为简洁、清晰、健壮的代码。这不仅提升了开发效率，也大大降低了因日期时间处理不当而引发的潜在问题。在任何需要进行日期时间计算和比较的Java项目中，强烈推荐优先使用java.time包。
