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

本文主要是介绍用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<T> {

/**
* 根据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<String> updateColumns);

//
// @UpdateProvider(type = UpdateByExampleAppointColumnExampleProvider2.class, method = "updateByExampleAppointColumn")
// int updateByExampleAppointColumn2(@Param("record") T record, @Param("example") Object example,@Param("updateColumns") List<String> 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<String> 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>");
//获取全部列
Set<EntityColumn> 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("</set>");
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("<choose>");

//指定的字段会被强制更新
sql.append("<when test=\"");
sql.append(UPDATE_PROPERTIES).append(" != null and ").append(UPDATE_PROPERTIES).append(".contains('");
sql.append(column.getProperty());
sql.append("')\">");
sql.append(contents);
sql.append("</when>");

sql.append("<otherwise></otherwise>");
sql.append("</choose>");
return sql.toString();
}
}
```

 

需要实现指定字段更新的Mapper需要继承UpdateAppointColumnMapper，我是直接定义了一个名为BaseMapper的基类，让基类直接继承

```java
public interface BaseMapper<T> extends Mapper<T>,UpdateAppointColumnMapper<T> {}
```

一个数据仓储的基类

```java
public abstract class AbstractBaseRepository<T> {

@Autowired
protected IBaseMapper<T> baseMapper;

/**
* 更新指定字段
*
* @param record 更新对象
* @param example 更新条件
* @param updateColumns 需要更新的字段
* @return
*/
public void updateByExampleAppointColumn(T record, Example example, List<String> 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<String, Object> map, Example example, LoginInfo loginInfo){
if(MapUtils.isEmpty(map)){
throw new BusinessException("更新的字段必填");
}
List<String> 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<String, Object> map = lambdaUpdateWrapper.build();
this.updateByExampleAppointColumn(map, example, loginInfo);
}
}
```

LambdaUpdateWrapper：

```java
/**
* @author: jie
* @create: 2022/11/17 14:18
* @description:
*/
public class LambdaUpdateWrapper {
private Map<String, Object> updateMap;

public static LambdaUpdateWrapper create() {
return new LambdaUpdateWrapper();
}

public <T, R> LambdaUpdateWrapper set(ColumnFunction<T, R> 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<String, Object> build() {
return this.updateMap;
}

}
```

 

 

实例代码：

### （1）使用实体对象更新

 

```java
public void updateByExampleAppointColumnEntityTest(){
//更新的对象
Event event = Event.builder().beforeValue("1").afterValue("2").description(null).build();
//需要更新的字段
List<String> 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<String, Object> 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);
}
```

 

这篇关于用tk.mybaits实现指定字段更新的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！