用tk.mybaits实现指定字段更新

​ 去年年底的因为业务需要需要在使用tk.mybaits框架的系统中实现指定字段的更新，可是tk.mybaits框架本身并不支持这个功能，我翻遍了CSDN和其他相关的技术相关的网站都没有找到相关的解决方法。于是我通过几天的翻阅相关资料和摸索后终于实现了这个功能。最近事情不是很多，想到又想到了去年解决的这个问题，于是有了这篇文章。分享一下当时的解决方法，为有同样需求的小伙伴抛砖引玉。
​ 这个问题如果系统使用的是Mybatis-Plus框架的话，实现只更新指定的字段是一件很简单的事情。只需要写以下代码即可：
```java
UpdateWrapper updateWrapper = new UpdateWrapper();
updateWrapper.eq("id", 1);
updateWrapper.set("status",  1);
updateWrapper.set("nickname",  "张三");
baseMapper.update(null, updateWrapper);
```
但是如果系统使用的是tk.mybaits则默认不支持这个功能，有一种迂回的解决的办法是现查询出对应的数据，在set需要更新的字段，再更新整条数据。但是这样终究不是很好，在并发情况下也很容易出现问题。至于tk.mybaits指定字段更新的方案，我在网上找了很久都没有找到相关的解决方法。随后我通过分析tk.mybaits在github的源码和issue回答找到些许线索。最终实现了这个功能。具体结局方案如下：
 
先定义一个名为UpdateAppointColumnMapper接口
```java
/**
* @author: jie
* @create: 2022/11/15 10:55
* @description: 通用Mapper接口,更新指定字段，实现
*/
@tk.mybatis.mapper.annotation.RegisterMapper
public interface UpdateAppointColumnMapper {
    /**
     * 根据Example条件更新实体`record`包含的不是null的属性值
     *
     * @param record
     * @param example
     * @return
     */
    @UpdateProvider(type = UpdateByExampleAppointColumnProvider.class, method = "dynamicSQL")
    int updateByExampleAppointColumn(@Param("record") T record, @Param("example") Object example,@Param("updateColumns") List updateColumns);

//
//    @UpdateProvider(type = UpdateByExampleAppointColumnExampleProvider2.class, method = "updateByExampleAppointColumn")
//    int updateByExampleAppointColumn2(@Param("record") T record, @Param("example") Object example,@Param("updateColumns") List updateColumns);

    /**
     * 根据Example条件更新实体`record`包含的不是null的属性值
     *
     * @param record
     * @param example
     * @return
     */
    @UpdateProvider(type = UpdateByExampleAppointColumnProvider.class, method = "dynamicSQL")
    int updateByExampleAppointColumnForMap(@Param("record") Map record, @Param("example") Object example, @Param("updateColumns") List updateColumns);
}
```
 
再定义一个名为UpdateByExampleAppointColumnProvider的Provider（核心代码）
```java
/**
* @author: jie
* @create: 2022/11/16 19:00
* @description:
*/
public class UpdateByExampleAppointColumnProvider extends MapperTemplate {
    public static final String UPDATE_PROPERTIES = "updateColumns";
    public UpdateByExampleAppointColumnProvider(Class mapperClass, MapperHelper mapperHelper) {
        super(mapperClass, mapperHelper);
    }
    /**
     * 根据Example更新非null字段
     *
     * @param ms
     * @return
     */
    public String updateByExampleAppointColumn(MappedStatement ms) {
        Class entityClass = getEntityClass(ms);
        ParameterMap paramterType = ms.getParameterMap();
        Configuration configuration = ms.getConfiguration();
        MetaObject metaObject = MetaObjectUtil.forObject(ms);
        SqlSource sqlSource = ms.getSqlSource();
        //BoundSql boundSql = sqlSource.getBoundSql(entityClass);
        StringBuilder sql = new StringBuilder();
        if (isCheckExampleEntityClass()) {
            sql.append(SqlHelper.exampleCheck(entityClass));
        }
        //安全更新，Example 必须包含条件
        if (getConfig().isSafeUpdate()) {
            sql.append(SqlHelper.exampleHasAtLeastOneCriteriaCheck("example"));
        }
        sql.append(SqlHelper.updateTable(entityClass, tableName(entityClass), "record"));
        //sql.append(sqlUtil.updateSetAppointColumns(entityClass, Arrays.asList("before_value")));
        sql.append(this.updateSetColumnsForce(entityClass, "record", true, isNotEmpty()));
        sql.append(SqlHelper.updateByExampleWhereClause());
        //sql.append(SqlHelper.wherePKColumns(entityClass, "record", true));
        return sql.toString();
    }

    public String updateByExampleAppointColumnForMap(MappedStatement ms){
        return updateByExampleAppointColumn(ms);
    }
 
    /**
     * update set列
     *
     * @param entityClass
     * @param entityName  实体映射名
     * @param notNull     是否判断!=null
     * @param notEmpty    是否判断String类型!=''
     * @return
     */
    public String updateSetColumnsForce(Class entityClass, String entityName, boolean notNull, boolean notEmpty) {
        StringBuilder sql = new StringBuilder();
        sql.append("");
        //获取全部列
        Set columnSet = EntityHelper.getColumns(entityClass);
        //对乐观锁的支持
        EntityColumn versionColumn = null;
        //当某个列有主键策略时，不需要考虑他的属性是否为空，因为如果为空，一定会根据主键策略给他生成一个值
        for (EntityColumn column : columnSet) {
            if (column.getEntityField().isAnnotationPresent(Version.class)) {
                if (versionColumn != null) {
                    throw new VersionException(entityClass.getCanonicalName() + " 中包含多个带有 @Version 注解的字段，一个类中只能存在一个带有 @Version 注解的字段!");
                }
                versionColumn = column;
            }
            if (!column.isId() && column.isUpdatable()) {
                if (column == versionColumn) {
                    Version version = versionColumn.getEntityField().getAnnotation(Version.class);
                    String versionClass = version.nextVersion().getCanonicalName();
                    //version = ${@tk.mybatis.mapper.version@nextVersionClass("versionClass", version)}
                    sql.append(column.getColumn())
                            .append(" = ${@tk.mybatis.mapper.version.VersionUtil@nextVersion(")
                            .append("@").append(versionClass).append("@class, ")
                            .append(column.getProperty()).append(")},");
                } else if (notNull) {
                    sql.append(this.getIfNotNull(entityName, column, column.getColumnEqualsHolder(entityName) + ",", notEmpty));
                } else {
                    sql.append(column.getColumnEqualsHolder(entityName) + ",");
                }
            }
        }
        sql.append("");
        return sql.toString();
    }
    /**
     * 判断自动!=null的条件结构
     *
     * @param entityName
     * @param column
     * @param contents
     * @param empty
     * @return
     */
    public String getIfNotNull(String entityName, EntityColumn column, String contents, boolean empty) {
        StringBuilder sql = new StringBuilder();
        sql.append("");
        //指定的字段会被强制更新
        sql.append("");
        sql.append(contents);
        sql.append("");
        sql.append("");
        sql.append("");
        return sql.toString();
    }
}
```
 
需要实现指定字段更新的Mapper需要继承UpdateAppointColumnMapper，我是直接定义了一个名为BaseMapper的基类，让基类直接继承
```java
public interface BaseMapper extends Mapper,UpdateAppointColumnMapper {}
```
一个数据仓储的基类
```java
public abstract class AbstractBaseRepository {
    @Autowired
    protected IBaseMapper baseMapper;
    /**
     *   更新指定字段
     *
     * @param  record 更新对象
     * @param example 更新条件
     * @param updateColumns 需要更新的字段
     * @return
     */
    public void updateByExampleAppointColumn(T record, Example example, List updateColumns, LoginInfo loginInfo){
        record.setUpdateUser(loginInfo.getUserId());
        this.baseMapper.updateByExampleAppointColumn(record, example, updateColumns);
    }
    /**
     *  根据Map更新指定字段
     *
     * @param map map 更新Map
     * @param example 更新条件
     * @return void
     */
    public void updateByExampleAppointColumn(Map map, Example example, LoginInfo loginInfo){
        if(MapUtils.isEmpty(map)){
            throw new BusinessException("更新的字段必填");
        }
        List updateColumns = map.keySet().stream().collect(Collectors.toList());
        map.put("updateUser", loginInfo.getUserId());
        this.baseMapper.updateByExampleAppointColumnForMap(map, example, updateColumns);
    }
    /**
     *  根据Map更新指定字段
     *
     * @param lambdaUpdateWrapper lambdaUpdateWrapper
     * @param example 更新条件
     * @return void
     */
    public void updateByExampleAppointColumn(LambdaUpdateWrapper lambdaUpdateWrapper, Example example, LoginInfo loginInfo){
        Map map = lambdaUpdateWrapper.build();
        this.updateByExampleAppointColumn(map, example, loginInfo);
    }
}
```
LambdaUpdateWrapper：
```java
/**
* @author: jie
* @create: 2022/11/17 14:18
* @description:
*/
public class LambdaUpdateWrapper {
    private Map updateMap;
    public static LambdaUpdateWrapper create() {
        return new LambdaUpdateWrapper();
    }
    public  LambdaUpdateWrapper set(ColumnFunction column, Object value) {
        return set(FieldUtil.name(column), value);
    }
    public LambdaUpdateWrapper set(String columnName, Object value) {
        this.updateMap.put(columnName, value);
        return this;
    }
    public Map build() {
        return this.updateMap;
    }
}
```
 
 
实例代码：
### （1）使用实体对象更新
 
```java
public void updateByExampleAppointColumnEntityTest(){
//更新的对象
Event event = Event.builder().beforeValue("1").afterValue("2").description(null).build();
//需要更新的字段
List updateColumns = Arrays.asList("beforeValue","afterValue","description");
//指定更新条件
Example example = Example.builder(Event.class)
.andWhere(WeekendSqls.custom()
.andEqualTo("bizId", "123")
.andEqualTo("active", CommonYesNoEnum.YES.getCode())).build();
updateByExampleAppointColumn(event, example, updateColumns);
}
```
 
### （2）使用 MAP 更新
 
```java
public void updateByExampleAppointColumnMapTest(){
//更新的MAP
Map map = new HashMap();
map.put("beforeValue","1");
map.put("afterValue","2");
map.put("description",null);
//指定更新条件
Example example = Example.builder(Event.class)
.andWhere(WeekendSqls.custom()
.andEqualTo("bizId", "123")
.andEqualTo("active", CommonYesNoEnum.YES.getCode())).build();
updateByExampleAppointColumnForMap(map, example);
}
```
 
### (3) 使用 LambdaUpdateWrapper 更新
```java
oid updateByExampleAppointColumnLambdaUpdateWrapperTest() {
//更新的MAP
LambdaUpdateWrapper lambdaUpdateWrapper = LambdaUpdateWrapper.create()
.set(Event::getBeforeValue, "1")
.set(Event::getAfterValue, "1")
.set(Event::getDescription, null);
//指定更新条件
Example example = Example.builder(Event.class)
.andWhere(WeekendSqls.custom()
.andEqualTo("bizId", "123")
.andEqualTo("active", CommonYesNoEnum.YES.getCode())).build();
eventRepository.updateByExampleAppointColumn(lambdaUpdateWrapper, example);
}
```
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！