Spring Boot四层JPA实体映射单表及无后处理嵌套Map获取咨询

针对你的四层层级数据场景，我提供两种贴合需求的可行方案：

一、直接获取嵌套Map结构（无需后处理） #

如果你不需要实体类，直接想要Map<Long, Map<Long, Map<Long, List<Long>>>>格式的数据（key依次对应topId、upperId、lowerId，value为对应层级的bottomId列表），可以通过Spring Data JPA的自定义Repository方法实现，在查询环节直接完成结构组装：

1. 定义Repository接口 #

public interface HierarchyRepository extends JpaRepository<HierarchyDto, Serializable> {

    // 原生SQL查询所有扁平化数据行
    @Query(value = "SELECT top_id, upper_id, lower_id, bottom_id FROM your_hierarchy_table", nativeQuery = true)
    List<Object[]> findAllHierarchyRows();

    // 直接返回嵌套Map的默认方法
    default Map<Long, Map<Long, Map<Long, List<Long>>>> getNestedMap() {
        return findAllHierarchyRows().stream()
                .collect(Collectors.groupingBy(
                        row -> (Long) row[0],
                        Collectors.groupingBy(
                                row -> (Long) row[1],
                                Collectors.groupingBy(
                                        row -> (Long) row[2],
                                        Collectors.mapping(row -> (Long) row[3], Collectors.toList())
                                )
                        )
                ));
    }
}

2. （可选）用DTO接收数据（更易维护） #

如果希望代码可读性更高，可以定义一个简单的DTO来接收单表数据：

public class HierarchyDto {
    private Long topId;
    private Long upperId;
    private Long lowerId;
    private Long bottomId;

    // 全参构造器、getter方法
    public HierarchyDto(Long topId, Long upperId, Long lowerId, Long bottomId) {
        this.topId = topId;
        this.upperId = upperId;
        this.lowerId = lowerId;
        this.bottomId = bottomId;
    }

    // getter省略...
}

然后修改Repository的查询逻辑，基于DTO实现：

@Query("SELECT new com.yourpackage.HierarchyDto(h.topId, h.upperId, h.lowerId, h.bottomId) FROM HierarchyEntity h")
List<HierarchyDto> findAllHierarchyDtos();

default Map<Long, Map<Long, Map<Long, List<Long>>>> getNestedMap() {
    return findAllHierarchyDtos().stream()
            .collect(Collectors.groupingBy(
                    HierarchyDto::getTopId,
                    Collectors.groupingBy(
                            HierarchyDto::getUpperId,
                            Collectors.groupingBy(
                                    HierarchyDto::getLowerId,
                                    Collectors.mapping(HierarchyDto::getBottomId, Collectors.toList())
                            )
                    )
            ));
}

之后你在Service中直接调用hierarchyRepository.getNestedMap()，就能拿到目标结构，完全无需额外后处理。

二、JPA实体层级结构映射（适合需要实体操作的场景） #

如果必须使用你定义的四层实体层级结构，由于数据存储在单表中，直接用JPA的@OneToMany/@ManyToOne关联会存在映射冲突和性能问题，更合理的方式是：先查询扁平化数据，再在内存中组装层级实体。

1. 定义基础实体（暂不关联） #

先保留你原有的实体结构，但暂时去掉JPA关联注解：

public class Top {
    private Long id;
    private List<Upper> uppers = new ArrayList<>();

    // 构造器、getter、setter省略...
}

public class Upper {
    private Long id;
    private Top parent;
    private List<Lower> lowers = new ArrayList<>();

    // 构造器、getter、setter省略...
}

public class Lower {
    private Long id;
    private Upper parent;
    private List<Bottom> bottoms = new ArrayList<>();

    // 构造器、getter、setter省略...
}

public class Bottom {
    private Long id;
    private Lower parent;

    // 构造器、getter、setter省略...
}

2. 在Service中组装层级结构 #

利用Repository查询到的扁平化数据，手动构建实体层级：

@Service
public class HierarchyService {
    @Autowired
    private HierarchyRepository hierarchyRepository;

    public List<Top> getHierarchyEntities() {
        List<HierarchyDto> dtos = hierarchyRepository.findAllHierarchyDtos();
        Map<Long, Top> topMap = new HashMap<>();
        Map<Long, Upper> upperMap = new HashMap<>();
        Map<Long, Lower> lowerMap = new HashMap<>();

        for (HierarchyDto dto : dtos) {
            // 构建Top并缓存
            Top top = topMap.computeIfAbsent(dto.getTopId(), Top::new);
            // 构建Upper并关联到Top
            Upper upper = upperMap.computeIfAbsent(dto.getUpperId(), id -> {
                Upper u = new Upper(id);
                u.setParent(top);
                top.getUppers().add(u);
                return u;
            });
            // 构建Lower并关联到Upper
            Lower lower = lowerMap.computeIfAbsent(dto.getLowerId(), id -> {
                Lower l = new Lower(id);
                l.setParent(upper);
                upper.getLowers().add(l);
                return l;
            });
            // 构建Bottom并关联到Lower
            Bottom bottom = new Bottom(dto.getBottomId());
            bottom.setParent(lower);
            lower.getBottoms().add(bottom);
        }

        return new ArrayList<>(topMap.values());
    }
}

关键说明 #

• 单表存储层级数据时，JPA原生的关联注解并不适配——因为每个层级的实体对应表中多行记录，直接映射会导致重复加载和数据一致性问题。
• 嵌套Map方案利用Java Stream的分组操作，在Repository层完成转换，完全满足你“无需后处理”的要求，代码简洁且性能可控。

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