MyBatis实现递归查询的方法详解

那么我们就来详细讲解下MyBatis实现递归查询的方法。

什么是递归查询？

递归查询即指对同一个表或不同表中的同一种关系，进行不断的重复查询的过程。

举个例子，我们有一个表dept，它的字段结构如下：

字段名称	类型	说明
id	integer	主键，自增长
name	varchar	部门名称
parent	integer	上级部门编号

其中，parent字段表示该部门的上级部门编号。

现在我们需要查询某一个部门的所有子部门，或者查询某一个部门的所有上级部门，这就涉及到递归查询。

MyBatis的递归查询实现方法

MyBatis可以通过使用联合查询、使用多次查询语句（如使用循环或递归），或自定义类型处理器等方式来实现递归查询。这里我们介绍一种使用MyBatis自定义类型处理器实现递归查询的方法。

第一步：创建递归处理器

我们需要创建一个自定义的类型处理器，在查询结果中处理递归关系。代码如下：

@MappedTypes(List.class)
@MappedJdbcTypes(JdbcType.ARRAY)
public class RecursionHandler<E extends RecursiveEntity<E>> implements TypeHandler<List<E>> {

    private final Class<E> entityClass;

    public RecursionHandler(Class<E> entityClass) {
        this.entityClass = entityClass;
    }

    @Override
    public void setParameter(PreparedStatement ps, int i, List<E> parameter, JdbcType jdbcType) throws SQLException {
        Array array = ps.getConnection().createArrayOf("BIGINT", parameter.stream().map(RecursiveEntity::getId).toArray());
        ps.setArray(i, array);
    }

    @Override
    public List<E> getResult(ResultSet rs, String columnName) throws SQLException {
        Array array = rs.getArray(columnName);
        return processArray(array);
    }

    @Override
    public List<E> getResult(ResultSet rs, int columnIndex) throws SQLException {
        Array array = rs.getArray(columnIndex);
        return processArray(array);
    }

    @Override
    public List<E> getResult(CallableStatement cs, int columnIndex) throws SQLException {
        Array array = cs.getArray(columnIndex);
        return processArray(array);
    }

    private List<E> processArray(Array array) throws SQLException {
        if (array == null) {
            return null;
        }
        Long[] ids = (Long[]) array.getArray();
        if (ids == null || ids.length == 0) {
            return Collections.emptyList();
        }
        return recursion(ids);
    }

    private List<E> recursion(Long[] ids) {
        Map<Long, E> entityMap = new HashMap<>();
        // 第一次查询，查询所有的父级实体
        List<E> entities = queryAllParent(ids);
        // 第二次查询，查询所有的子级实体以及自己
        List<E> children = queryAllChildren(ids);
        // 合并父级实体和子级实体
        for (E entity : entities) {
            entityMap.put(entity.getId(), entity);
        }
        for (E child : children) {
            if (entityMap.containsKey(child.getId())) {
                E entity = entityMap.get(child.getId());
                entityMap.put(child.getId(), entity.merge(child));
            } else {
                entityMap.put(child.getId(), child);
            }
        }
        return new ArrayList<>(entityMap.values());
    }

    /**
     * 获取所有的父级实体
     */
    private List<E> queryAllParent(Long[] ids) {
        return null;
    }

    /**
     * 获取所有的子级实体
     */
    private List<E> queryAllChildren(Long[] ids) {
        return null;
    }

}

我们通过实现TypeHandler接口，对结果集进行处理。在processArray方法中，我们进行了递归查询，并将最终结果返回。

第二步：定义递归实体类

我们需要定义递归实体类，这里我们定义一个RecursiveEntity接口，用于返回实体类之间的递归关系。代码如下：

public interface RecursiveEntity<T extends RecursiveEntity<T>> {

    Long getId();

    Long getParentId();

    T merge(T other);

}

可以看到，递归实体类需要返回自己的主键和上级主键，同时需要定义合并方法merge，用于处理父级和子级的冲突。

第三步：在Mapper.xml中使用递归处理器

在Mapper.xml中使用自定义类型处理器，示例代码如下：

<resultMap type="com.example.domain.Dept" id="deptMap">
  <result property="id" column="id" />
  <result property="name" column="name" />
  <result property="parent" column="parent_id" typeHandler="com.example.handler.RecursionHandler"/>
</resultMap>

<select id="findByParent" resultMap="deptMap">
    SELECT * FROM dept WHERE parent_id IN (#{parentIds})
</select>

在上面的代码中，我们使用了命名参数parentIds来指定上级部门，同时将parent字段的类型处理器设置为了com.example.handler.RecursionHandler。

第四步：调用MyBatis查询方法

最后，我们可以通过调用MyBatis的查询方法来实现递归查询，示例代码如下：

List<Dept> depts = deptMapper.findByParent(parentIds);

上面的代码中，我们直接调用Mapper接口的findByParent方法，并将上级部门的编号传入。

至此，我们就介绍了使用MyBatis自定义类型处理器实现递归查询的完整攻略。如果你需要查询部门所有下级部门或上级部门，只需要将findByParent方法改为findByChildren即可，具体的实现逻辑与上面相同。

示例一：查询某一部门的所有子部门

如果我们需要查询某一个部门的所有子部门，可以使用以下代码：

public List<Dept> listChildren(Dept dept) {
    List<Long> ids = new ArrayList<>();
    ids.add(dept.getId());
    return deptMapper.findByParent(ids);
}

上面的代码中，我们将被查询的部门的编号加入到parentIds中，然后调用deptMapper.findByParent方法来进行查询。查询结果会包含该部门及其所有子部门。

示例二：查询某一部门的所有上级部门

如果我们需要查询某一个部门所有上级部门，可以使用以下代码：

public List<Dept> listParent(Dept dept) {
    List<Long> ids = new ArrayList<>();
    Long id = dept.getParent();
    while (id != null) {
        ids.add(id);
        Dept parentDept = deptMapper.findById(id);
        if (parentDept == null) {
            break;
        }
        id = parentDept.getParent();
    }
    return deptMapper.findByChildren(ids);
}

上面的代码中，我们从被查询的部门一直往上查找，直到找到最上级的部门。然后将所有上级部门的编号存入childrenIds中，并调用deptMapper.findByChildren来进行查询。查询结果会包含该部门及其所有上级部门。