在Spring Data JPA中使用@CreationTimestamp/@UpdateTimestamp设置LocalDateTime精度

问题核心 #

代码生成的LocalDateTime是纳秒精度（9位小数），但MySQL的timestamp(6)仅支持微秒精度（6位小数），导致保存后内存实体与数据库查询实体的时间字段精度不一致，断言isEqualTo失败。以下是几种无需修改数据库Schema的优雅解决方案：

方法1：通过注解+JPA配置强制时间精度 #

直接在实体类的时间字段上指定精度，并配置Hibernate截断纳秒到微秒：

修改实体类字段 #

在@Column注解中添加precision = 6，明确绑定数据库字段的精度：

@AllArgsConstructor
@Data
@MappedSuperclass
@NoArgsConstructor
@SuperBuilder
@Table("my_table")
public class MyEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @CreationTimestamp
    @Column(updatable = false, precision = 6)
    private LocalDateTime created;

    @UpdateTimestamp
    @Column(name = "last_update", precision = 6)
    private LocalDateTime updated;
}

添加JPA配置 #

在application.properties（或application.yml）中添加Hibernate配置，强制将LocalDateTime截断到微秒精度：

# 针对Hibernate 5.4+，指定LocalDateTime的JDBC精度为6（微秒）
spring.jpa.properties.hibernate.jdbc.localdatetime_precision=6

# 可选：统一设置时区，避免时区差异导致的时间偏差
spring.jpa.properties.hibernate.jdbc.time_zone=UTC

此方案会让Hibernate在写入数据库时自动截断纳秒部分，读取时保持6位精度，内存中的实体时间与数据库查询结果一致，断言即可通过。

方法2：自定义属性转换器（AttributeConverter） #

通过自定义转换器，在实体与数据库交互时自动截断纳秒到微秒：

实现全局转换器 #

创建一个自动应用到所有LocalDateTime字段的转换器：

import javax.persistence.AttributeConverter;
import javax.persistence.Converter;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

@Converter(autoApply = true)
public class LocalDateTimeMicrosecondConverter implements AttributeConverter<LocalDateTime, LocalDateTime> {

    @Override
    public LocalDateTime convertToDatabaseColumn(LocalDateTime attribute) {
        // 写入数据库时截断到微秒
        return attribute != null ? attribute.truncatedTo(ChronoUnit.MICROS) : null;
    }

    @Override
    public LocalDateTime convertToEntityAttribute(LocalDateTime dbData) {
        // 读取时直接返回数据库的微秒精度时间
        return dbData;
    }
}

（可选）指定单个字段应用转换器 #

如果不想全局生效，可在目标字段上添加@Convert注解：

@CreationTimestamp
@Column(updatable = false)
@Convert(converter = LocalDateTimeMicrosecondConverter.class)
private LocalDateTime created;

@UpdateTimestamp
@Column(name = "last_update")
@Convert(converter = LocalDateTimeMicrosecondConverter.class)
private LocalDateTime updated;

此方案通过转换器统一处理时间精度，代码侵入性低，适合需要灵活控制转换逻辑的场景。

方法3：重写equals/hashCode忽略纳秒部分 #

@Data自动生成的equals会精确比较纳秒，可重写equals和hashCode方法，只比较到微秒级别：

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.Objects;

@AllArgsConstructor
@Data
@MappedSuperclass
@NoArgsConstructor
@SuperBuilder
@Table("my_table")
public class MyEntity {

    // 原有字段...

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyEntity myEntity = (MyEntity) o;
        return Objects.equals(id, myEntity.id) &&
                Objects.equals(name, myEntity.name) &&
                equalsToMicrosecond(created, myEntity.created) &&
                equalsToMicrosecond(updated, myEntity.updated);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name,
                truncateToMicrosecond(created),
                truncateToMicrosecond(updated));
    }

    private boolean equalsToMicrosecond(LocalDateTime dt1, LocalDateTime dt2) {
        if (dt1 == null && dt2 == null) return true;
        if (dt1 == null || dt2 == null) return false;
        return dt1.truncatedTo(ChronoUnit.MICROS).equals(dt2.truncatedTo(ChronoUnit.MICROS));
    }

    private LocalDateTime truncateToMicrosecond(LocalDateTime dt) {
        return dt != null ? dt.truncatedTo(ChronoUnit.MICROS) : null;
    }
}

此方案无需修改配置或添加转换器，直接从对象比较逻辑入手，适合不想改动持久层逻辑的场景。

总结 #

• 推荐方法1，仅需注解和配置即可解决问题，最简洁优雅；
• 若需要更灵活的转换逻辑，选择方法2；
• 若只想调整对象比较规则，选择方法3。

内容的提问来源于stack exchange，提问作者Crazy Dino