通用 Mapper 进阶实例：为什么好久都没更新了？

最新推荐文章于 2024-01-18 12:01:02 发布

isea533

最新推荐文章于 2024-01-18 12:01:02 发布

阅读量1w

点赞数 20

分类专栏： Mybatis示例 Mybatis

版权归博主所有，转载先联系博主，请带上本文链接！联系方式：abel533@gmail.com

本文链接：https://blog.csdn.net/isea533/article/details/104776347

版权

Mybatis 同时被 2 个专栏收录

71 篇文章 57 订阅

订阅专栏

Mybatis示例

31 篇文章 580 订阅

订阅专栏

前几天发现有人 3 个月前在 GitHub 发 issue#708 这项目是不是已经不维护了，然后我看了看通用 Mapper 最近一次更新的内容和时间：
在这里插入图片描述
虽然合并了 PR，但是没有发布版本，最后一个版本的发布信息如下：

也就是从2019年1月28日后就没有发布过新的版本。在这个项目初期（1~2年内）由于更新频繁，再次获得过 版本帝 的称号，为什么最近变化很少了呢？难道是真的不维护了吗？

当然不是，实际上我认为从下面这个提交和对应的 4.1.2 版本开始，基本上就不需要更新了。
在这里插入图片描述
从核心功能稳定开始，增加了大量的通用方法，现在还有很多没有合并的 PR 中，基本上都是通用方法的实现。在项目的中期，我个人也是响应多数开发者的想法，增加尽可能多的通用方法。由于我自己也一直在用通用 Mapper，我发现了一些严重的问题，这些问题影响了我对增加通用方法的看法。

我发现由于通用 Mapper 大量方法的存在，尤其是 Example 这个方法的熟练使用者，过度依赖此类方法。还有很多明明很简单 SQL 能完成的事，来回调用了好几个通用方法才实现。使用 select 获取大量数据的情况，明明只需要几个字段，也不加选择的直接去用。当通用 Mapper 没有提供某些方法时，就想着有人能提供自己需要的方法。通用 Mapper 的目的就是为了让开发人员能偷懒，能把更多的时间用在重要的事情上，但是有一部分人在不该偷懒的地方也偷懒了。

完全没有性能要求的小型项目可以不做任何考虑去用，但是不要习以为常，还要知道什么时候不能用。

有娃之后的这一年，时间真的少了，issue 和 pr 几乎没精力处理了，感谢所有主动在 issue 中帮助他人的开发者，感谢所有 pr 的提交者。通用 Mapper 5 新版的核心实现都有1年多了（在 Add LanguageDriver to ProviderSqlSource #1391 PR 之后实现），仍然没有足够的精力完善基础方法的实现，这个版本基于 jdk8 和 mybatis 3.5.x 最新版本，用起来会更简单，扩展会更方便，也只会提供少量的通用方法作为示例，2020年必须实现，不能再拖了。

以后的趋势是，通用 Mapper 只需要提供少量必要的通用方法就够了，能从业务逻辑中抽取通用业务逻辑时可以自己扩展方法，这样的方法才是更好的通用方法，从下面开始，本文以实际案例介绍一个通用业务逻辑的实现。

同级数据上下和拖拽移动排序的功能

业务场景很简单，符合某些查询条件的数据通过一列 顺序号 进行排序，在 UI 操作上有上下移动或拖拽排序的功能要求，因为有近 10 个表存在这样的设计，为了简化实现，通过封装便于开发人员直接使用现成的方法。下面开始简单的设计分析。

业务接口设计

/**
 * 移动节点顺序
 *
 * @param movingId 移动的 id
 * @param targetId 目标 id
 * @param isBefore 目标节点的上方true or 下面false
 * @return
 */
int move(Long movingId, Long targetId, boolean isBefore);

整体设计针对拖拽排序，上下移动只是拖拽排序的两个特例，拖拽时的位置可能是目标节点的上方或者下方，接口简单的通过 true/false 区分。

拖拽排序操作分析

在这里插入图片描述
如图所示的 4 种情况，经过分析，分为下面 4 种逻辑：

向下移动：
- 图1：移动到前：
  - (source, target)-1
  - source=target-1
  - target不变
- 图2：移动到后：
  - (source,target]-1
  - source=target
向上移动：
- 图3：移动到前：
  - [target,source)+1
  - source=target
- 图4：移动到后：
  (target,source)+1
  source=target+1
  - target不变

注意： ( 为开区间，不包含对应的值，[ 为闭区间，包含对应的值。

拖拽数据库操作设计

为了尽可能的高效，这里不会使用 selectByPrimaryKey 这样的方法。针对上图的分析，排序分为下面几个数据库操作。

获取 id 对应的顺序号：因为只需要这两个值，所以提供一个通用方法只获取这两项值即可。
更新 target 和 source 区间的顺序号，根据方向可能 +1 或者 -1。
更新拖拽节点的顺序号，按上面只有图2和图3需要更新

经过上面3个操作后顺序号就改变了，也就是最多需要执行 3 次数据库操作，而且还能保证顺序号连贯。

通用 Mapper 接口设计实现

由于需要知道 Model 中的顺序号字段，因此先提供一个注解用于指定顺序号字段：

/**
 * 顺序号
 */
@Target({ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Seq {
}

然后是通用 Mapper 接口:

/**
 * 拖拽排序接口
 */
@RegisterMapper
public interface MoveMapper<T> {
    /**
     * 1. 获取给定 ids 对应的顺序号
     *
     * @param ids
     * @return
     */
    @SelectProvider(type = MoveProvider.class, method = "dynamicSQL")
    List<SeqModel> getSeqs(@Param("ids") String ids);

    /**
     * 2. 移动节点调整中间部分的顺序，相邻节点调整时不需要调用当前方法
     *
     * @param movingSeq  移动节点序号
     * @param targetSeq  目标节点序号
     * @param direction  位置
     * @param conditions 额外条件
     * @return
     */
    @UpdateProvider(type = MoveProvider.class, method = "dynamicSQL")
    int move(@Param("movingSeq") Long movingSeq, @Param("targetSeq") Long targetSeq,
             @Param("direction") MoveDirection direction, @Param("conditions") Map<String, Object> conditions);

    /**
     * 3. 根据主键更新顺序号
     *
     * @param id
     * @param seq
     * @return
     */
    @UpdateProvider(type = MoveProvider.class, method = "dynamicSQL")
    int updateSeqById(@Param("id") Long id, @Param("seq") Long seq);

}

其中 SeqModel 包含了 id 和顺序号字段:

public class SeqModel implements Serializable {
    private static final long serialVersionUID = 1L;
    private Long id;
    private Long seq;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Long getSeq() {
        return seq;
    }

    public void setSeq(Long seq) {
        this.seq = seq;
    }
}

还有一个代表图1~图4 四种情况的枚举：

/**
 * 移动方向和位置
 */
public enum MoveDirection {
    /**
     * 向下移动到目标节点前（上）(source,target)-1
     */
    DownBefore,
    /**
     * 向下移动到目标节点后（下）(source,target]-1
     */
    DownAfter,
    /**
     * 向上移动到目标节点前（上）[target,source)+1
     */
    UpBefore,
    /**
     * 向上移动到目标节点后（下）(target,source)+1
     */
    UpAfter
}

MoveProvider 中是具体 SQL 的实现：

public class MoveProvider extends MapperTemplate {

    public MoveProvider(Class<?> mapperClass, MapperHelper mapperHelper) {
        super(mapperClass, mapperHelper);
    }

    /**
     * 获取 Seq 顺序号列名
     *
     * @param entityClass
     * @return
     */
    private String getSeqColumnName(Class<?> entityClass) {
        //获取全部列
        Set<EntityColumn> columnList = EntityHelper.getColumns(entityClass);
        List<EntityColumn> seqColumns = columnList.stream().filter(column -> column.getEntityField().isAnnotationPresent(Seq.class)).collect(Collectors.toList());
        if (seqColumns.size() == 0) {
            throw new RuntimeException(entityClass.getCanonicalName() + " 类中不存在带有 @Seq 注解的顺序号字段");
        } else if (seqColumns.size() > 1) {
            throw new RuntimeException(entityClass.getCanonicalName() + " 类中存在多个带有 @Seq 注解的顺序号字段");
        }
        return seqColumns.get(0).getColumn();
    }

    /**
     * 移动
     *
     * @param ms
     * @return
     */
    public String move(MappedStatement ms) {
        Class<?> entityClass = this.getEntityClass(ms);
        StringBuilder sql = new StringBuilder();
        //获取 Seq 顺序号列名
        String seqColumnName = getSeqColumnName(entityClass);
        //下面是 4 中情况下的分别处理
        sql.append("update ").append(tableName(entityClass))
                .append(" <choose>")
                .append(" <when test=\"direction == @io.mybatis.demo.custom.seq.MoveDirection@DownBefore\">")
                .append(" set " + seqColumnName + " = " + seqColumnName + " - 1 where " + seqColumnName + " &gt; #{movingSeq} and " + seqColumnName + " &lt; #{targetSeq}")
                .append(" </when>")
                .append(" <when test=\"direction == @io.mybatis.demo.custom.seq.MoveDirection@DownAfter\">")
                .append(" set " + seqColumnName + " = " + seqColumnName + " - 1 where " + seqColumnName + " &gt; #{movingSeq} and " + seqColumnName + " &lt;= #{targetSeq}")
                .append(" </when>")
                .append(" <when test=\"direction == @io.mybatis.demo.custom.seq.MoveDirection@UpBefore\">")
                .append(" set " + seqColumnName + " = " + seqColumnName + " + 1 where " + seqColumnName + " &gt;= #{targetSeq} and " + seqColumnName + " &lt; #{movingSeq}")
                .append(" </when>")
                .append(" <when test=\"direction == @io.mybatis.demo.custom.seq.MoveDirection@UpAfter\">")
                .append(" set " + seqColumnName + " = " + seqColumnName + " + 1 where " + seqColumnName + " &gt; #{targetSeq} and " + seqColumnName + " &lt; #{movingSeq}")
                .append(" </when>")
                .append(" </choose>");
        //追加其他 where 条件
        sql.append(" <foreach collection=\"conditions\" item=\"val\" index=\"colName\">");
        sql.append(" and ${colName} = #{val}");
        sql.append(" </foreach>");
        return sql.toString();
    }

    /**
     * 获取指定 ids 对应的序号
     *
     * @param ms
     * @return
     */
    public String getSeqs(MappedStatement ms) {
        Class<?> entityClass = this.getEntityClass(ms);
        StringBuilder sql = new StringBuilder();
        //获取 Seq 顺序号列名
        String seqColumnName = getSeqColumnName(entityClass);
        sql.append("select id, ").append(seqColumnName).append(" as seq from ").append(tableName(entityClass)).append(" where id in ( ${ids})");
        return sql.toString();
    }

    /**
     * 根据 id 更新序号
     *
     * @param ms
     * @return
     */
    public String updateSeqById(MappedStatement ms) {
        Class<?> entityClass = this.getEntityClass(ms);
        StringBuilder sql = new StringBuilder();
        //获取 Seq 顺序号列名
        String seqColumnName = getSeqColumnName(entityClass);
        sql.append("update ").append(tableName(entityClass)).append(" set ").append(seqColumnName).append(" = #{seq} where id = #{id}");
        return sql.toString();
    }

}

上面的实现中，根据当前的整体的设计尽可能的简单实现，例如上面直接限制了主键字段为 id，还额外使用 @Param("conditions") Map<String, Object> conditions 作为其他查询条件。${ids}的写法会有SQL注入风险，但是这儿是内部调用，不通过Service暴露出Dao的这个接口。

现在是有了通用方法，还可以再进一步，封装业务逻辑。

封装业务逻辑

根据前面的图示，这里直接把业务逻辑封装起来，使用起来更加简单。

这里用最简单的静态类，参数传递 Dao 实现（还能设计抽象类，或者接口配合 default 方法实现）：

public class MoveMapperUtil {

    /**
     * 列表顺序上下移动操作（不存在父子结构关系）
     *
     * @param mapper     dao 实例，需要继承 MoveMapper
     * @param movingId   被移动节点的 id
     * @param targetId   移动的目标 id
     * @param direction  移动的位置，上方或者下方
     * @param conditions 额外条件, 会追加到 where 查询条件，例如 name=1 and age=20
     * @param <M>
     * @return 结果0时所有顺序都没变化，相邻节点时交换位置时结果2，其他情况下>2
     */
    public static <M extends MoveMapper> int move(M mapper, Long movingId, Long targetId, Direction direction, Map<String, Object> conditions) {
        Assert.notNull(mapper);
        Assert.notNull(movingId);
        Assert.notNull(targetId);
        Assert.notNull(direction);
        //移动操作影响的行数
        int resultCount = 0;
        //获取两个ID对应的顺序号
        List<SeqModel> seqs = mapper.getSeqs(movingId + "," + targetId);
        Assert.isTrue(seqs.size() == 2);
        Map<Long, Long> idSeqMap = seqs.stream().collect(Collectors.toMap(SeqModel::getId, SeqModel::getSeq));
        Long movingSeq = idSeqMap.get(movingId);
        Long targetSeq = idSeqMap.get(targetId);
        Assert.notNull(movingSeq);
        Assert.notNull(targetSeq);
        MoveDirection position = null;
        switch (direction) {
            case AFTER:
                position = movingSeq < targetSeq  /* true - 向下移动*/ ? MoveDirection.DownAfter : MoveDirection.UpAfter;
                break;
            case BEFORE:
                position = movingSeq < targetSeq  /*true - 向下移动*/ ? MoveDirection.DownBefore : MoveDirection.UpBefore;
                break;
            default:
        }
        Assert.notNull(position);
        //先更新区间范围内的顺序，相邻节点时可能更新0或1条数据，不相邻时>=1条
        if (Math.abs(movingSeq - targetSeq) == 1) {
            //相邻节点时，只有两种情况需要交换位置，下面的 SQL 只会更新 target 顺序
            if (position == MoveDirection.DownAfter
                    || position == MoveDirection.UpBefore) {
                resultCount += mapper.move(movingSeq, targetSeq, position, conditions);
            }
        } else {//不相邻时，中间阶段顺序一定会变
            resultCount += mapper.move(movingSeq, targetSeq, position, conditions);
        }
        //根据位置更新移动节点
        Long newSeq = movingSeq;
        switch (position) {
            case DownBefore:
                newSeq = targetSeq - 1;
                break;
            case DownAfter:
            case UpBefore:
                newSeq = targetSeq;
                break;
            case UpAfter:
                newSeq = targetSeq + 1;
                break;
            default:
        }
        //当移动节点的顺序变化时更新（例外情况，向下移动到下一个节点的上方，此时位置不变）
        if (!newSeq.equals(movingSeq)) {
            resultCount += mapper.updateSeqById(movingId, newSeq);
        }
        return resultCount;
    }

}

这里没有用 isUpdate，而是用了下面这个枚举：

public enum Direction {
    BEFORE,
    AFTER
}

到这里整个实现就完成了，下面通过简单数据进行演示。

测试

测试数据

drop table user if exists;

create table user (
  id bigint primary key,
  sequence int,
  name varchar(32),
  py varchar(5)
);

insert into user(id, sequence, name, py) values(1, 1,'毕淑儒','BSR');
insert into user(id, sequence, name, py) values(2, 2,'蔡兴熙','CXX');
insert into user(id, sequence, name, py) values(3, 3,'曾三杰','ZSJ');
insert into user(id, sequence, name, py) values(4, 4,'常元琴','CYQ');
insert into user(id, sequence, name, py) values(5, 5,'陈栋芬','CDF');
insert into user(id, sequence, name, py) values(6, 6,'陈宁婷','CNZ');
insert into user(id, sequence, name, py) values(7, 7,'陈瑞','CR');
insert into user(id, sequence, name, py) values(8, 8,'陈武宵','CWX');
insert into user(id, sequence, name, py) values(9, 9,'陈晓丽','CXL');
insert into user(id, sequence, name, py) values(10, 10,'陈涛','CT');

对应的实体

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    private Long id;
    //这里用到了顺序号注解
    @Seq
    @Order
    private Integer sequence;
    private String name;
    private String py;
    //省略setter和getter方法

UserMapper 接口

public interface UserMapper extends Mapper<User>, MoveMapper<User> {

}

Service 接口和实现

public interface UserService {
    /**
     * 获取所有
     *
     * @return
     */
    List<User> getAll();

    /**
     * 移动节点顺序
     *
     * @param movingId 移动的 id
     * @param targetId 目标 id
     * @param isBefore 目标节点的上方true or 下面false
     * @return
     */
    int move(Long movingId, Long targetId, boolean isBefore);
}

//-----------------

@Service
public class UserServiceImpl implements UserService {

	@Autowired
	private UserMapper userMapper;

    @Override
    public List<User> getAll() {
        return userMapper.selectAll();
    }

    @Override
    public int move(Long movingId, Long targetId, boolean isBefore) {
        return MoveMapperUtil.move(userMapper, movingId, targetId, 
                                   isBefore ? Direction.BEFORE: Direction.AFTER, Collections.emptyMap());
    }

}

测试代码

logger.info("----------当前顺序----------");
userService.getAll();
logger.info("将 3 号挪到 7 号后面");
userService.move(3L, 7L, false);
logger.info("----------移动后的顺序----------");
userService.getAll();
logger.info("将 4 号挪到 8 号前面");
userService.move(4L, 8L, true);
logger.info("----------移动后的顺序----------");
userService.getAll();
logger.info("将 9 号挪到 2 号前面");
userService.move(9L, 2L, true);
logger.info("----------移动后的顺序----------");
userService.getAll();
logger.info("将 10 号挪到 1 号后面");
userService.move(10L, 1L, false);
logger.info("----------移动后的顺序----------");
userService.getAll();

通过详细的 SQL 日志能看到所有数据，所以上面没有输出查询的结果。通过这里执行输出的 SQL 日志可以很清楚的看到 move 后的顺序。

SQL 日志

Application              : ----------当前顺序----------
UserMapper.selectAll     : ==>  Preparing: SELECT id,sequence,name,py FROM user ORDER BY sequence ASC 
UserMapper.selectAll     : ==> Parameters: 
UserMapper.selectAll     : <==    Columns: ID, SEQUENCE, NAME, PY
UserMapper.selectAll     : <==        Row: 1, 1, 毕淑儒, BSR
UserMapper.selectAll     : <==        Row: 2, 2, 蔡兴熙, CXX
UserMapper.selectAll     : <==        Row: 3, 3, 曾三杰, ZSJ
UserMapper.selectAll     : <==        Row: 4, 4, 常元琴, CYQ
UserMapper.selectAll     : <==        Row: 5, 5, 陈栋芬, CDF
UserMapper.selectAll     : <==        Row: 6, 6, 陈宁婷, CNZ
UserMapper.selectAll     : <==        Row: 7, 7, 陈瑞, CR
UserMapper.selectAll     : <==        Row: 8, 8, 陈武宵, CWX
UserMapper.selectAll     : <==        Row: 9, 9, 陈晓丽, CXL
UserMapper.selectAll     : <==        Row: 10, 10, 陈涛, CT
UserMapper.selectAll     : <==      Total: 10
Application              : 将 3 号挪到 7 号后面
UserMapper.getSeqs       : ==>  Preparing: select id, sequence as seq from user where id in ( 3,7) 
UserMapper.getSeqs       : ==> Parameters: 
UserMapper.getSeqs       : <==    Columns: ID, SEQ
UserMapper.getSeqs       : <==        Row: 3, 3
UserMapper.getSeqs       : <==        Row: 7, 7
UserMapper.getSeqs       : <==      Total: 2
UserMapper.move          : ==>  Preparing: update user set sequence = sequence - 1 where sequence > ? and sequence <= ? 
UserMapper.move          : ==> Parameters: 3(Long), 7(Long)
UserMapper.move          : <==    Updates: 4
UserMapper.updateSeqById : ==>  Preparing: update user set sequence = ? where id = ? 
UserMapper.updateSeqById : ==> Parameters: 7(Long), 3(Long)
UserMapper.updateSeqById : <==    Updates: 1
Application              : ----------移动后的顺序----------
UserMapper.selectAll     : ==>  Preparing: SELECT id,sequence,name,py FROM user ORDER BY sequence ASC 
UserMapper.selectAll     : ==> Parameters: 
UserMapper.selectAll     : <==    Columns: ID, SEQUENCE, NAME, PY
UserMapper.selectAll     : <==        Row: 1, 1, 毕淑儒, BSR
UserMapper.selectAll     : <==        Row: 2, 2, 蔡兴熙, CXX
UserMapper.selectAll     : <==        Row: 4, 3, 常元琴, CYQ
UserMapper.selectAll     : <==        Row: 5, 4, 陈栋芬, CDF
UserMapper.selectAll     : <==        Row: 6, 5, 陈宁婷, CNZ
UserMapper.selectAll     : <==        Row: 7, 6, 陈瑞, CR
UserMapper.selectAll     : <==        Row: 3, 7, 曾三杰, ZSJ
UserMapper.selectAll     : <==        Row: 8, 8, 陈武宵, CWX
UserMapper.selectAll     : <==        Row: 9, 9, 陈晓丽, CXL
UserMapper.selectAll     : <==        Row: 10, 10, 陈涛, CT
UserMapper.selectAll     : <==      Total: 10
Application              : 将 4 号挪到 8 号前面
UserMapper.getSeqs       : ==>  Preparing: select id, sequence as seq from user where id in ( 4,8) 
UserMapper.getSeqs       : ==> Parameters: 
UserMapper.getSeqs       : <==    Columns: ID, SEQ
UserMapper.getSeqs       : <==        Row: 4, 3
UserMapper.getSeqs       : <==        Row: 8, 8
UserMapper.getSeqs       : <==      Total: 2
UserMapper.move          : ==>  Preparing: update user set sequence = sequence - 1 where sequence > ? and sequence < ? 
UserMapper.move          : ==> Parameters: 3(Long), 8(Long)
UserMapper.move          : <==    Updates: 4
UserMapper.updateSeqById : ==>  Preparing: update user set sequence = ? where id = ? 
UserMapper.updateSeqById : ==> Parameters: 7(Long), 4(Long)
UserMapper.updateSeqById : <==    Updates: 1
Application              : ----------移动后的顺序----------
UserMapper.selectAll     : ==>  Preparing: SELECT id,sequence,name,py FROM user ORDER BY sequence ASC 
UserMapper.selectAll     : ==> Parameters: 
UserMapper.selectAll     : <==    Columns: ID, SEQUENCE, NAME, PY
UserMapper.selectAll     : <==        Row: 1, 1, 毕淑儒, BSR
UserMapper.selectAll     : <==        Row: 2, 2, 蔡兴熙, CXX
UserMapper.selectAll     : <==        Row: 5, 3, 陈栋芬, CDF
UserMapper.selectAll     : <==        Row: 6, 4, 陈宁婷, CNZ
UserMapper.selectAll     : <==        Row: 7, 5, 陈瑞, CR
UserMapper.selectAll     : <==        Row: 3, 6, 曾三杰, ZSJ
UserMapper.selectAll     : <==        Row: 4, 7, 常元琴, CYQ
UserMapper.selectAll     : <==        Row: 8, 8, 陈武宵, CWX
UserMapper.selectAll     : <==        Row: 9, 9, 陈晓丽, CXL
UserMapper.selectAll     : <==        Row: 10, 10, 陈涛, CT
UserMapper.selectAll     : <==      Total: 10
Application              : 将 9 号挪到 2 号前面
UserMapper.getSeqs       : ==>  Preparing: select id, sequence as seq from user where id in ( 9,2) 
UserMapper.getSeqs       : ==> Parameters: 
UserMapper.getSeqs       : <==    Columns: ID, SEQ
UserMapper.getSeqs       : <==        Row: 2, 2
UserMapper.getSeqs       : <==        Row: 9, 9
UserMapper.getSeqs       : <==      Total: 2
UserMapper.move          : ==>  Preparing: update user set sequence = sequence + 1 where sequence >= ? and sequence < ? 
UserMapper.move          : ==> Parameters: 2(Long), 9(Long)
UserMapper.move          : <==    Updates: 7
UserMapper.updateSeqById : ==>  Preparing: update user set sequence = ? where id = ? 
UserMapper.updateSeqById : ==> Parameters: 2(Long), 9(Long)
UserMapper.updateSeqById : <==    Updates: 1
Application              : ----------移动后的顺序----------
UserMapper.selectAll     : ==>  Preparing: SELECT id,sequence,name,py FROM user ORDER BY sequence ASC 
UserMapper.selectAll     : ==> Parameters: 
UserMapper.selectAll     : <==    Columns: ID, SEQUENCE, NAME, PY
UserMapper.selectAll     : <==        Row: 1, 1, 毕淑儒, BSR
UserMapper.selectAll     : <==        Row: 9, 2, 陈晓丽, CXL
UserMapper.selectAll     : <==        Row: 2, 3, 蔡兴熙, CXX
UserMapper.selectAll     : <==        Row: 5, 4, 陈栋芬, CDF
UserMapper.selectAll     : <==        Row: 6, 5, 陈宁婷, CNZ
UserMapper.selectAll     : <==        Row: 7, 6, 陈瑞, CR
UserMapper.selectAll     : <==        Row: 3, 7, 曾三杰, ZSJ
UserMapper.selectAll     : <==        Row: 4, 8, 常元琴, CYQ
UserMapper.selectAll     : <==        Row: 8, 9, 陈武宵, CWX
UserMapper.selectAll     : <==        Row: 10, 10, 陈涛, CT
UserMapper.selectAll     : <==      Total: 10
Application              : 将 10 号挪到 1 号后面
UserMapper.getSeqs       : ==>  Preparing: select id, sequence as seq from user where id in ( 10,1) 
UserMapper.getSeqs       : ==> Parameters: 
UserMapper.getSeqs       : <==    Columns: ID, SEQ
UserMapper.getSeqs       : <==        Row: 1, 1
UserMapper.getSeqs       : <==        Row: 10, 10
UserMapper.getSeqs       : <==      Total: 2
UserMapper.move          : ==>  Preparing: update user set sequence = sequence + 1 where sequence > ? and sequence < ? 
UserMapper.move          : ==> Parameters: 1(Long), 10(Long)
UserMapper.move          : <==    Updates: 8
UserMapper.updateSeqById : ==>  Preparing: update user set sequence = ? where id = ? 
UserMapper.updateSeqById : ==> Parameters: 2(Long), 10(Long)
UserMapper.updateSeqById : <==    Updates: 1
Application              : ----------移动后的顺序----------
UserMapper.selectAll     : ==>  Preparing: SELECT id,sequence,name,py FROM user ORDER BY sequence ASC 
UserMapper.selectAll     : ==> Parameters: 
UserMapper.selectAll     : <==    Columns: ID, SEQUENCE, NAME, PY
UserMapper.selectAll     : <==        Row: 1, 1, 毕淑儒, BSR
UserMapper.selectAll     : <==        Row: 10, 2, 陈涛, CT
UserMapper.selectAll     : <==        Row: 9, 3, 陈晓丽, CXL
UserMapper.selectAll     : <==        Row: 2, 4, 蔡兴熙, CXX
UserMapper.selectAll     : <==        Row: 5, 5, 陈栋芬, CDF
UserMapper.selectAll     : <==        Row: 6, 6, 陈宁婷, CNZ
UserMapper.selectAll     : <==        Row: 7, 7, 陈瑞, CR
UserMapper.selectAll     : <==        Row: 3, 8, 曾三杰, ZSJ
UserMapper.selectAll     : <==        Row: 4, 9, 常元琴, CYQ
UserMapper.selectAll     : <==        Row: 8, 10, 陈武宵, CWX
UserMapper.selectAll     : <==      Total: 10

总结

通过本文，希望读者能有收获，能根据自己的需要设计通用方法，不要只是为了偷懒将自己局限在已有的通用方法中。大而全的通用方法不一定适合自己，根据自己需要选择和设计的通用方法才更满足自己的需要。

通用 Mapper 就是为了方便扩展设计的，这么容易扩展的通用 Mapper 当然不需要频繁更新了。

本文对应完整代码：https://github.com/abel533/mapper-move-spring-boot

isea533

关注

20
点赞
踩
24

收藏

觉得还不错? 一键收藏
打赏
17
评论
通用 Mapper 进阶实例：为什么好久都没更新了？

写篇博客关于通用 Mapper，通用 Service 方法。可以简单实现同级列表数据的上下拖拽改变顺序。为什么很久没更新？核心已经很完善了，扩展也很容易。实际上我还想精简方法，不想增加过多的方法，有需要的自己扩展。...
复制链接

扫一扫