Java实现列表上移，下移操作总结

最近遇到这么一个需求，要求对列表中的数据进行自定义排序操作，思前想后，决定通过上下移动来实现此功能。

实现思路：

1.在数据库中对要进行排序那张表新增一个sort字段用于排序。

2.每当新增一条记录时，sort的值都会在上一条的记录上进行+1。即每次新增记录时，先查出已存在的sort值最大的那条记录，然后新增记录的sort值为该记录的sort的值+1。

3.列表向上移动的时候查询出当前数据的上一条数据的sort值，两者交换sort值，同理向下移动的时候，查询出下一条数据的sort值，两者交换。 

springboot+mybatis代码实现：

1.SQL

  <select id="selectMaxSort" resultType="java.lang.Integer">
    select IFNULL(max(sort),0)  from classic_case
  </select>
  <select id="moveUp" resultMap="ResultMapWithBLOBs" parameterType="java.lang.Integer">
        select
        <include refid="Base_Column_List"/>
        ,
        <include refid="Blob_Column_List"/>
        from classic_case f
        WHERE f.sort &lt; #{sort} order by f.sort desc limit 0,1
  </select>
  <select id="moveDown" resultMap="ResultMapWithBLOBs" parameterType="java.lang.Integer">
        select
        <include refid="Base_Column_List"/>
        ,
        <include refid="Blob_Column_List"/>
        from classic_case f
        WHERE f.sort &gt; #{sort} order by f.sort asc limit 0,1
  </select>

2.dao

/**
     * @Description:查找当前最大的sort值
     * @date: 17:44 2019-3-29
     * @param:
     * @return: int
     */
    Integer selectMaxSort();


    /**
     * 上移
     * @param sort
     * @return
     */
    ClassicCase moveUp(Integer sort);

    /**
     *  下移
     * @param sort
     * @return
     */
    ClassicCase moveDown(Integer sort);

3.Service

    /**
     * 添加记录
     * @param record
     * @return
     */
    int insertSelective(ClassicCase record);   

   /**
     * 上移
     * @param classicId
     * @return
     */
    void moveUp(Integer classicId);

    /**
     * 下移
     * @param classicId
     */
    void moveDown(Integer classicId);




 @Override
    public int insertSelective(ClassicCase record) {

        //获取当前最大的sort值

        Integer sort = classicCaseMapper.selectMaxSort();
        //如果为0，目前还没有数据
        if (sort == 0) {
            //将sort值设为1
            record.setSort(1);
        } else {
            //否则在最大的sort值上加一
            record.setSort(sort + 1);
        }
        System.out.println(record.getDetail());
        return classicCaseMapper.insertSelective(record);
    }

 @Override
    public void moveUp(Integer classicId) {

        //获取要上移的那条数据的信息
        ClassicCase classicCase = classicCaseMapper.selectByPrimaryKey(classicId);

        //查询上一条记录
        ClassicCase casePrev = classicCaseMapper.moveUp(classicCase.getSort());

        //最上面的记录不能上移
        if (casePrev == null) {
            return;
        }
        //交换两条记录的sort值
        Integer temp = classicCase.getSort();
        classicCase.setSort(casePrev.getSort());
        casePrev.setSort(temp);

        //更新到数据库
        classicCaseMapper.updateByPrimaryKeySelective(classicCase);
        classicCaseMapper.updateByPrimaryKeySelective(casePrev);
    }


    @Override
    public void moveDown(Integer classicId) {
        //获取要下移的那条数据的信息
        ClassicCase classicCase = classicCaseMapper.selectByPrimaryKey(classicId);

        //查询下一条记录
        ClassicCase caseNext = classicCaseMapper.moveDown(classicCase.getSort());

        //最下面的记录不能下移
        if (caseNext == null) {
            return;
        }
        //交换两条记录的sort值
        Integer temp = classicCase.getSort();
        classicCase.setSort(caseNext.getSort());
        caseNext.setSort(temp);

        //更新到数据库
        classicCaseMapper.updateByPrimaryKeySelective(classicCase);
        classicCaseMapper.updateByPrimaryKeySelective(caseNext);
    }

4.Controller

   /**
     * 更新排序
     * @param sortStr 操作字符（down---下移，up---上移）
     * @param classicId 案例id
     * @return
     */
    @RequestMapping(value = "/updateSort",method = RequestMethod.GET)
    public BaseResponse updateSort(String sortStr, Integer classicId) {

        ResponseBuilder custom = ResponseBuilder.custom();
        try {
            if (sortStr.equals("down")) {
                classicCaseService.moveDown(classicId);
            } else if (sortStr.equals("up")) {
                classicCaseService.moveUp(classicId);
            }

            custom.success(Constant.SUCCESS,Constant.SUCCESS_CODE);
        } catch (Exception e) {
            custom.failed(Constant.FAIL, Constant.EXCEPTION_CODE);
        }
        return custom.build();
    }

这便是该功能的简单实现，我个人认识浅薄，有更好的方法还望各位大神指教。