Spring Boot+Hibernate集成Redis缓存时懒加载集合初始化失败求助

问题根源 #

你遇到的本质问题是：Hibernate的懒加载代理对象在Session关闭后无法初始化，而GenericJackson2JsonRedisSerializer序列化/反序列化时会触发这些代理的加载逻辑，此时已经没有Hibernate Session，导致报错。即使改为FetchType.EAGER，如果查询时没有真正加载关联对象（比如JPQL未显式关联查询），或者Jackson序列化时仍处理了代理对象，问题依然存在。

方案1：改用DTO缓存（最推荐） #

直接缓存JPA实体容易受Hibernate代理、懒加载逻辑影响，建议定义与缓存需求匹配的DTO，将实体转换为DTO后再存入Redis：

1. 创建UserDTO及关联对象的DTO：

public class UserDTO {
    private UUID id;
    private AuthenticationEventDTO lastAuthentication;
    private List<IdentityDTO> identities;
    private List<RoleDTO> roles;
    private TenantDTO tenant;

    // Getter、Setter、构造方法
}

// 对应关联对象的DTO示例
public class IdentityDTO {
    // 只保留需要缓存的字段
}

2. 服务层查询实体后，转换为DTO再缓存：

@Service
public class UserService {
    @Autowired
    private UserRepository userRepo;
    @Autowired
    private RedisTemplate<String, UserDTO> redisTemplate;

    public UserDTO getUserById(UUID id) {
        // 先查缓存
        UserDTO cachedUser = redisTemplate.opsForValue().get("user_entity:" + id);
        if (cachedUser != null) {
            return cachedUser;
        }
        // 查数据库，显式加载所有关联对象
        User user = userRepo.findByIdWithAllAssociations(id);
        // 转换为DTO（可使用ModelMapper等工具简化）
        UserDTO userDTO = convertToDTO(user);
        // 存入缓存
        redisTemplate.opsForValue().set("user_entity:" + id, userDTO);
        return userDTO;
    }
}

3. 仓库层添加显式关联查询的方法：

@Repository
public interface UserRepository extends JpaRepository<User, UUID> {
    @Query("SELECT u FROM User u JOIN FETCH u.lastAuthentication JOIN FETCH u.identities JOIN FETCH u.roles JOIN FETCH u.tenant WHERE u.id = :id")
    User findByIdWithAllAssociations(@Param("id") UUID id);
}

方案2：配置Jackson处理Hibernate懒加载代理 #

通过引入Jackson的Hibernate模块，让序列化器识别并正确处理Hibernate代理对象：

1. 添加Maven依赖：

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-hibernate5</artifactId>
</dependency>

2. 配置Redis序列化器，注册Hibernate模块：

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        GenericJackson2JsonRedisSerializer serializer = new GenericJackson2JsonRedisSerializer();
        ObjectMapper objectMapper = serializer.getObjectMapper();
        // 注册Hibernate模块，自动处理懒加载代理
        Hibernate5Module hibernateModule = new Hibernate5Module();
        // 可选：未加载的代理对象序列化时直接忽略，避免触发加载
        hibernateModule.disable(Hibernate5Module.Feature.FORCE_LAZY_LOADING);
        objectMapper.registerModule(hibernateModule);
        // 避免空Bean序列化报错
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);

        template.setValueSerializer(serializer);
        template.setKeySerializer(new StringRedisSerializer());
        return template;
    }
}

方案3：临时应急：忽略特定关联字段 #

如果某些关联字段不需要缓存，可直接在实体字段上添加@JsonIgnore，让Jackson序列化时跳过该字段：

@JsonIgnore
@Fetch(FetchMode.JOIN)
@JoinTable(name = "user_identities", joinColumns = {
        @JoinColumn(name = "user_id")}, inverseJoinColumns = {
        @JoinColumn(name = "user_identity_id")})
@OneToMany(fetch = FetchType.LAZY, orphanRemoval = true)
private List<Identity> identities;

内容的提问来源于stack exchange，提问作者Денис Анд