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

灰太狼 2023-07-13 04:10 19阅读 0赞

前几天发现有人 3 个月前在 GitHub 发 [issue\#708 这项目是不是已经不维护了][issue_708] ，然后我看了看 [通用 Mapper][Mapper] 最近一次更新的内容和时间：  
![在这里插入图片描述][20200316205533667.png]  
虽然合并了 PR，但是没有发布版本，最后一个版本的发布信息如下：  
![在这里插入图片描述][20200316205618908.png]  
也就是从2019年1月28日后就没有发布过新的版本。在这个项目初期（1~2年内）由于更新频繁，再次获得过 **版本帝** 的称号，为什么最近变化很少了呢？难道是真的不维护了吗？

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

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

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

有娃之后的这一年，时间真的少了，issue 和 pr 几乎没精力处理了，感谢所有主动在 issue 中帮助他人的开发者，感谢所有 pr 的提交者。通用 Mapper 5 新版的核心实现都有1年多了（在 [Add LanguageDriver to ProviderSqlSource \#1391][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` 区分。

## 拖拽排序操作分析 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2lzZWE1MzM_size_16_color_FFFFFF_t_70 1]  
如图所示的 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` 这样的方法。针对上图的分析，排序分为下面几个数据库操作。

1.  获取 id 对应的顺序号：因为只需要这两个值，所以提供一个通用方法只获取这两项值即可。
2.  更新 target 和 source 区间的顺序号，根据方向可能 `+1` 或者 `-1`。
3.  更新拖拽节点的顺序号，按上面只有图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 + " > #{movingSeq} and " + seqColumnName + " < #{targetSeq}")
                    .append(" </when>")
                    .append(" <when test=\"direction == @io.mybatis.demo.custom.seq.MoveDirection@DownAfter\">")
                    .append(" set " + seqColumnName + " = " + seqColumnName + " - 1 where " + seqColumnName + " > #{movingSeq} and " + seqColumnName + " <= #{targetSeq}")
                    .append(" </when>")
                    .append(" <when test=\"direction == @io.mybatis.demo.custom.seq.MoveDirection@UpBefore\">")
                    .append(" set " + seqColumnName + " = " + seqColumnName + " + 1 where " + seqColumnName + " >= #{targetSeq} and " + seqColumnName + " < #{movingSeq}")
                    .append(" </when>")
                    .append(" <when test=\"direction == @io.mybatis.demo.custom.seq.MoveDirection@UpAfter\">")
                    .append(" set " + seqColumnName + " = " + seqColumnName + " + 1 where " + seqColumnName + " > #{targetSeq} and " + seqColumnName + " < #{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][https_github.com_abel533_mapper-move-spring-boot]

[issue_708]: https://github.com/abel533/Mapper/issues/708
[Mapper]: https://github.com/abel533/Mapper
[20200316205533667.png]: https://img-blog.csdnimg.cn/20200316205533667.png
[20200316205618908.png]: https://img-blog.csdnimg.cn/20200316205618908.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2lzZWE1MzM_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200316205422770.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2lzZWE1MzM=,size_16,color_FFFFFF,t_70
[Add LanguageDriver to ProviderSqlSource _1391]: https://github.com/mybatis/mybatis-3/pull/1391
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2lzZWE1MzM_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200316213822200.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2lzZWE1MzM=,size_16,color_FFFFFF,t_70
[https_github.com_abel533_mapper-move-spring-boot]: https://github.com/abel533/mapper-move-spring-boot