解决User实体转DTO时循环依赖导致的StackOverflowError问题

问题根源 #

当调用toUser()映射时，当前用户的followers和following集合中的User对象会再次触发toUser()调用，而这些User的关联集合又可能包含原用户，形成无限递归调用，最终导致StackOverflowError。

解决方案 #

1. 限制递归深度（仅映射一层关联）

通过重载Mapper方法，控制是否展开关联关系：当前用户返回完整信息（含关联），关联的用户仅返回核心基础信息，不继续递归其关联。

public static UserResponse toUser(User user) {
    // 默认映射完整信息（包含当前用户的关联）
    return toUser(user, true);
}

// 私有重载方法，控制是否展开关联
private static UserResponse toUser(User user, boolean includeRelations) {
    UserResponse userResponse = new UserResponse();
    userResponse.setId(user.getId());
    userResponse.setFirstName(user.getFirstName());
    userResponse.setLastName(user.getLastName());
    
    if (includeRelations) {
        // 关联用户仅映射基础信息，不递归他们的followers/following
        userResponse.setFollowers(user.getFollowers().stream()
                .map(u -> toUser(u, false))
                .toList());
        userResponse.setFollowing(user.getFollowing().stream()
                .map(u -> toUser(u, false))
                .toList());
    } else {
        // 不包含关联关系，避免递归
        userResponse.setFollowers(Collections.emptyList());
        userResponse.setFollowing(Collections.emptyList());
    }
    return userResponse;
}

2. 分层DTO设计

创建两种DTO：完整版（包含关联）和精简版（仅核心字段），映射时当前用户用完整版，关联用户用精简版。

// 精简版DTO：仅保留核心用户信息
public class UserSimpleResponse {
    private Long id;
    private String firstName;
    private String lastName;
    // getter、setter省略
}

// 完整版DTO：继承精简版，增加关联字段
public class UserFullResponse extends UserSimpleResponse {
    private List<UserSimpleResponse> followers;
    private List<UserSimpleResponse> following;
    // getter、setter省略
}

// Mapper实现
public static UserFullResponse toFullUser(User user) {
    UserFullResponse response = new UserFullResponse();
    response.setId(user.getId());
    response.setFirstName(user.getFirstName());
    response.setLastName(user.getLastName());
    
    // 关联用户映射为精简版DTO，无递归风险
    response.setFollowers(user.getFollowers().stream()
            .map(UserMapper::toSimpleUser)
            .toList());
    response.setFollowing(user.getFollowing().stream()
            .map(UserMapper::toSimpleUser)
            .toList());
    return response;
}

public static UserSimpleResponse toSimpleUser(User user) {
    UserSimpleResponse response = new UserSimpleResponse();
    response.setId(user.getId());
    response.setFirstName(user.getFirstName());
    response.setLastName(user.getLastName());
    return response;
}

3. 用缓存避免重复映射

通过Set记录已处理的用户ID，再次遇到同一用户时仅返回基础信息，打破循环链。

public static UserResponse toUser(User user) {
    // 初始化已处理ID集合
    return toUser(user, new HashSet<>());
}

private static UserResponse toUser(User user, Set<Long> processedIds) {
    // 已处理过的用户，仅返回基础信息
    if (processedIds.contains(user.getId())) {
        UserResponse simpleResp = new UserResponse();
        simpleResp.setId(user.getId());
        simpleResp.setFirstName(user.getFirstName());
        simpleResp.setLastName(user.getLastName());
        simpleResp.setFollowers(Collections.emptyList());
        simpleResp.setFollowing(Collections.emptyList());
        return simpleResp;
    }
    
    processedIds.add(user.getId());
    UserResponse userResponse = new UserResponse();
    userResponse.setId(user.getId());
    userResponse.setFirstName(user.getFirstName());
    userResponse.setLastName(user.getLastName());
    
    // 递归处理关联用户，传入已处理集合
    userResponse.setFollowers(user.getFollowers().stream()
            .map(u -> toUser(u, processedIds))
            .toList());
    userResponse.setFollowing(user.getFollowing().stream()
            .map(u -> toUser(u, processedIds))
            .toList());
    
    processedIds.remove(user.getId()); // 移除ID，不影响其他分支映射
    return userResponse;
}

额外注意点 #

检查User实体类的字段与Mapper调用的getter是否匹配：原实体中字段为friends_of和friends，但Mapper调用了getFollowers()和getFollowing()，需确保实体类的getter方法与字段对应（例如friends_of的getter为getFollowers()），否则会导致关联数据为空或错误。

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