列表的上移动和下移动实现

实现思路：

1. 定义一个自增的字段sort,从小到大。

2. 上移动：? 当前sort字段 + 1 ,上一个的sort修改为当前查询的sort 。

3. 下移动： 当前sort字段 - 1 ，下一个的sort值修改为当前的sort

4. 注意判断sort不存在情况。

数据库：

create table t1
(
    class_id   int auto_increment primary key,
    class_sort int,
    class_name varchar(255)
);
INSERT INTO t1 (class_sort, class_name) VALUES
(1, 'Test Record 1'),
(2, 'Test Record 2'),
(3, 'Test Record 3'),
(4, 'Test Record 4'),
(5, 'Test Record 5');

?java实现

值交换实现：

1.字段值sort的添加，因为是自增的情况，所以每次添加查询sort的最大值 +1。

2. 拿到要移动的id值，根据id查询到sort ，上移动? + 1 ，根据id去修改（sort值+1）

3. 下移动-1,根据id值修改（sort值-1）；

4. 被改变的id值 修改为 查询到的id值的 sort

package com.ma.mybatistest.entity;

import lombok.Data;

@Data
public class Remove {

    private Integer classId;

    private Integer classSort;

    private String className;
}

package com.ma.mybatistest.mapper;

import com.ma.mybatistest.entity.Remove;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.util.List;

/**
 * @author Mtz
 * @version 1.0
 * @2023/12/2214:16
 * @function
 * @comment
 */

@Mapper
public interface RemoveTestMapper {

    // 添加数据
    int addT1(Remove remove);

    // 根据id 查询
    @Select("SELECT * FROM t1 WHERE class_id = #{classId}")
    Remove getRemoveList(int classId);
    
     // 查询最大的sort
    @Select("SELECT MAX(class_sort) FROM t1")
    int getMaxSort();
    
    // 根据id 修改 Sort
    // 数据更新
    @Update("UPDATE t1 SET class_sort = #{newSort} WHERE class_id = #{classId}")
    void updateRemoveSort(@Param("classId") int classId, @Param("newSort") int newSort);


    // 下一条记录
    @Select("SELECT * FROM t1 WHERE class_sort > #{classSort} ORDER BY class_sort ASC LIMIT #{limit}")
    Remove getNextRecord(@Param("classSort") Integer classSort, @Param("limit") int limit);

     // 上一条记录
    @Select("SELECT * FROM t1 WHERE class_sort < #{classSort} ORDER BY class_sort DESC LIMIT #{limit}")
    Remove getPreviousRecord(@Param("classSort") Integer classSort, @Param("limit") int limit);

    @Select("SELECT * FROM t1 ORDER BY class_sort ASC")
    List<Remove> getAllRecordsOrderedBySort();
}

    // 上移动
    @Test
    void moveUp() {
        int targetId = 16;  // 要上移的记录的 class_id

        // 获取要上移的记录
        Remove target = removeTestMapper.getRemoveList(targetId);
        if (target == null) {
            return;  // 处理记录不存在的情况
        }

        // 获取上一个记录
        Remove previousRecord = removeTestMapper.getPreviousRecord(target.getClassSort(), 1);

        // 如果上一个记录存在，进行交换排序值的操作
        if (previousRecord != null) {
            // 获取上一个记录的排序值
            int previousSortValue = previousRecord.getClassSort();

            // 进行交换排序值的操作
            removeTestMapper.updateRemoveSort(target.getClassId(), previousSortValue);
            removeTestMapper.updateRemoveSort(previousRecord.getClassId(), target.getClassSort());
        }
    }


    // 下移动
    @Test
    void moveDown() {
        int targetId = 18;  // 要下移的记录的 class_id

        // 获取要下移的记录
        Remove target = removeTestMapper.getRemoveList(targetId);
        if (target == null) {
            return;  // 处理记录不存在的情况
        }

        // 获取下一个记录的排序值（确保只返回一个记录）
        Remove next = removeTestMapper.getNextRecord(target.getClassSort(), 1);

        // 如果下一个记录存在，进行交换排序值的操作
        if (next != null) {
            // 获取下一个记录的排序值
            int nextSort = next.getClassSort();

            // 进行交换排序值的操作
            removeTestMapper.updateRemoveSort(target.getClassId(), nextSort);
            removeTestMapper.updateRemoveSort(next.getClassId(), target.getClassSort());
        }
    }