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

淡淡的烟草味﹌ 2022-02-25 06:16 889阅读 1赞

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

实现思路：

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 < #{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 > #{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();
        }

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