[转载]使用hibernate实现树形结构无限级分类

好的，我明白了。对于你的问题，我可以给出以下参考答案：

使用 Hibernate 实现树形结构的无限级分类可以采用两种方式：嵌套集合模型和闭包表模型。其中，嵌套集合模型是比较常见的一种方式，它可以通过递归查询的方式来实现对树形结构的操作。

具体实现步骤如下：

1. 创建实体类，包括节点的 id、名称、父节点 id、子节点集合等属性。

2. 使用 Hibernate 的注解方式进行映射，同时在实体类中定义递归查询的方法，实现对树形结构的操作。

3. 在业务逻辑层中，通过调用实体类中的递归查询方法，实现对树形结构的增删改查操作。

示例代码如下：

@Entity
public class Category {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    @ManyToOne(fetch = FetchType.LAZY)
    private Category parent;
    @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL)
    private Set<Category> children = new HashSet<>();

    // getters and setters

    public void addChild(Category child) {
        children.add(child);
        child.setParent(this);
    }

    public void removeChild(Category child) {
        children.remove(child);
        child.setParent(null);
    }

    public void setParent(Category parent) {
        this.parent = parent;
    }

    public Category getParent() {
        return parent;
    }

    public Set<Category> getChildren() {
        return children;
    }

    public boolean isRoot() {
        return parent == null;
    }

    public boolean isLeaf() {
        return children.isEmpty();
    }

    public int getLevel() {
        if (isRoot()) {
            return 0;
        }
        return parent.getLevel() + 1;
    }

    public String getTreePath() {
        if (isRoot()) {
            return name;
        }
        return parent.getTreePath() + " > " + name;
    }

    public void addChilds(List<Category> childs) {
        for (Category child : childs) {
            addChild(child);
        }
    }
}

public interface CategoryDao extends JpaRepository<Category, Long> {
    List<Category> findByParentIsNull();
}

@Service
@Transactional
public class CategoryServiceImpl implements CategoryService {
    @Autowired
    CategoryDao categoryDao;

    @Override
    public void add(Category category) {
        categoryDao.save(category);
    }

    @Override
    public void delete(Long id) {
        Category category = categoryDao.findOne(id);
        if (category != null) {
            if (category.isRoot()) {
                categoryDao.delete(category);
            } else {
                category.getParent().removeChild(category);
            }
        }
    }

    @Override
    public void update(Category category) {
        categoryDao.save(category);
    }

    @Override
    public Category get(Long id) {
        return categoryDao.findOne(id);
    }

    @Override
    public List<Category> getAll() {
        return categoryDao.findAll();
    }

    @Override
    public List<Category> getRoots() {
        return categoryDao.findByParentIsNull();
    }

    @Override
    public List<Category> getChildren(Long id) {
        Category category = categoryDao.findOne(id);
        if (category != null) {
            return new ArrayList<>(category.getChildren());
        }
        return Collections.emptyList();
    }

    @Override
    public List<Category> getTree() {
        List<Category> roots = getRoots();
        for (Category root : roots) {
            fetchChildren(root);
        }
        return roots;
    }

    private void fetchChildren(Category parent) {
        List<Category> children = getChildren(parent.getId());
        parent.addChilds(children);
        for (Category child : children) {
            fetchChildren(child);
        }
    }
}

以上就是使用 Hibernate 实现树形结构无限级分类的基本步骤和示例代码，希望能对你有所帮助。如果你还有其他问题可以继续问我哦。