Mybatis-Plus的insert执行之后，id是怎么获取的？

在日常开发中，会经常使用Mybatis-Plus

当简单的插入一条记录时，使用mapper的insert是比较简洁的写法

@Data
public class NoEo {

    Long id;

    String no;

}

NoEo noEo = new NoEo();

noEo.setNo("321");

noMapper.insert(noEo);

System.out.println(noEo);

这里可以注意到一个细节，就是不管我们使用的是什么类型的id，好像都不需要去setId，也能执行insert语句

不仅不需要setId，在insert语句执行完毕之后，我们还能通过实体类获取到这条insert的记录的id是什么

这背后的原理是什么呢？

自增类型ID

刚学Java的时候，插入了一条记录还要再select一次来获取这条记录的id，比较青涩

后面误打误撞才发现可以直接从insert的实体类中拿到这个id

难道框架是自己帮我查了一次嘛

先来看看自增id的情况

首先要先把yml中的mp的id类型设置为auto

mybatis-plus:
global-config:
db-config:
id-type: auto

然后从insert语句开始一直往下跟进

noMapper.insert(noEo);

后面会来到这个方法

// com.baomidou.mybatisplus.core.executor.MybatisSimpleExecutor#doUpdate
@Override
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
Statement stmt = null;
try {
Configuration configuration = ms.getConfiguration();
StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);

        stmt = prepareStatement(handler, ms.getStatementLog(), false);
return stmt == null ? 0 : handler.update(stmt);

    } finally {

        closeStatement(stmt);

    }

}

在执行了下面这个方法之后

handler.update(stmt)

实体类的id就赋值上了

继续往下跟

// org.apache.ibatis.executor.statement.PreparedStatementHandler#update
@Override
public int update(Statement statement) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;

  ps.execute();
int rows = ps.getUpdateCount();
Object parameterObject = boundSql.getParameterObject();
KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();

  keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);
return rows;

}

最后的赋值在这一行

keyGenerator.processAfter

可以看到会有一个KeyGenerator做一个后置增强，它具体的实现类是Jdbc3KeyGenerator

// org.apache.ibatis.executor.keygen.Jdbc3KeyGenerator#processAfter
@Override
public void processAfter(Executor executor, MappedStatement ms, Statement stmt, Object parameter) {

  processBatch(ms, stmt, parameter);

}

// org.apache.ibatis.executor.keygen.Jdbc3KeyGenerator#processBatch
public void processBatch(MappedStatement ms, Statement stmt, Object parameter) {
final String[] keyProperties = ms.getKeyProperties();
if (keyProperties == null || keyProperties.length == 0) {
return;

  }
try (ResultSet rs = stmt.getGeneratedKeys()) {
final ResultSetMetaData rsmd = rs.getMetaData();
final Configuration configuration = ms.getConfiguration();
if (rsmd.getColumnCount() < keyProperties.length) {
// Error?

    } else {

      assignKeys(configuration, rs, rsmd, keyProperties, parameter);

    }

  } catch (Exception e) {
throw new ExecutorException("Error getting generated key or setting result to parameter object. Cause: " + e, e);

  }

}

// org.apache.ibatis.executor.keygen.Jdbc3KeyGenerator#assignKeys
private void assignKeys(Configuration configuration, ResultSet rs, ResultSetMetaData rsmd, String[] keyProperties,

    Object parameter) throws SQLException {
if (parameter instanceof ParamMap || parameter instanceof StrictMap) {
// Multi-param or single param with @Param

    assignKeysToParamMap(configuration, rs, rsmd, keyProperties, (Map<String, ?>) parameter);

  } else if (parameter instanceof ArrayList && !((ArrayList<?>) parameter).isEmpty()

      && ((ArrayList<?>) parameter).get(0) instanceof ParamMap) {
// Multi-param or single param with @Param in batch operation

    assignKeysToParamMapList(configuration, rs, rsmd, keyProperties, (ArrayList<ParamMap<?>>) parameter);

  } else {
// Single param without @Param
// 当前case会走这里

    assignKeysToParam(configuration, rs, rsmd, keyProperties, parameter);

  }

}

// org.apache.ibatis.executor.keygen.Jdbc3KeyGenerator#assignKeysToParam
private void assignKeysToParam(Configuration configuration, ResultSet rs, ResultSetMetaData rsmd,

    String[] keyProperties, Object parameter) throws SQLException {

  Collection<?> params = collectionize(parameter);
if (params.isEmpty()) {
return;

  }

  List<KeyAssigner> assignerList = new ArrayList<>();
for (int i = 0; i < keyProperties.length; i++) {

    assignerList.add(new KeyAssigner(configuration, rsmd, i + 1, null, keyProperties[i]));

  }

  Iterator<?> iterator = params.iterator();
while (rs.next()) {
if (!iterator.hasNext()) {
throw new ExecutorException(String.format(MSG_TOO_MANY_KEYS, params.size()));

    }
Object param = iterator.next();

    assignerList.forEach(x -> x.assign(rs, param));

  }

}

// org.apache.ibatis.executor.keygen.Jdbc3KeyGenerator.KeyAssigner#assign
protected void assign(ResultSet rs, Object param) {
if (paramName != null) {
// If paramName is set, param is ParamMap

    param = ((ParamMap<?>) param).get(paramName);

  }
MetaObject metaParam = configuration.newMetaObject(param);
try {
if (typeHandler == null) {
if (metaParam.hasSetter(propertyName)) {
// 获取主键的类型

        Class<?> propertyType = metaParam.getSetterType(propertyName);
// 获取主键类型处理器

        typeHandler = typeHandlerRegistry.getTypeHandler(propertyType,

            JdbcType.forCode(rsmd.getColumnType(columnPosition)));

      } else {
throw new ExecutorException("No setter found for the keyProperty '" + propertyName + "' in '"

            + metaParam.getOriginalObject().getClass().getName() + "'.");

      }

    }
if (typeHandler == null) {
// Error?

    } else {
// 获取主键的值
Object value = typeHandler.getResult(rs, columnPosition);
// 设置主键值

      metaParam.setValue(propertyName, value);

    }

  } catch (SQLException e) {
throw new ExecutorException("Error getting generated key or setting result to parameter object. Cause: " + e,

        e);

  }

}

// com.mysql.cj.jdbc.result.ResultSetImpl#getObject(int, java.lang.Class<T>)
@Override
public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
// ...
else if (type.equals(Long.class) || type.equals(Long.TYPE)) {

            checkRowPos();

            checkColumnBounds(columnIndex);
return (T) this.thisRow.getValue(columnIndex - 1, this.longValueFactory);


        }
// ...

}

最后可以看到这个自增id是在ResultSet的thisRow里面

然后后面的流程就是去解析这个字节数据获取这个long的id

就不往下赘述了

雪花算法ID

yml切换回雪花算法

mybatis-plus:
global-config:
db-config:
id-type: assign_id

在使用雪花算法的时候，也是会走到这个方法

// com.baomidou.mybatisplus.core.executor.MybatisSimpleExecutor#doUpdate
@Override
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
Statement stmt = null;
try {
Configuration configuration = ms.getConfiguration();
StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);

        stmt = prepareStatement(handler, ms.getStatementLog(), false);
return stmt == null ? 0 : handler.update(stmt);

    } finally {

        closeStatement(stmt);

    }

}

但是不同的是，执行完这一行之后，实体类的id字段就已经赋值上了

StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);

继续往下跟进

// org.apache.ibatis.session.Configuration#newStatementHandler
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);

  statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
return statementHandler;

}

// org.apache.ibatis.executor.statement.RoutingStatementHandler#RoutingStatementHandler
public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {

switch (ms.getStatementType()) {
// ...
case PREPARED:

      delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
// ...

  }


}

最后跟进到一个构造器，会有一个processParameter的方法

// com.baomidou.mybatisplus.core.MybatisParameterHandler#MybatisParameterHandler
public MybatisParameterHandler(MappedStatement mappedStatement, Object parameter, BoundSql boundSql) {
this.typeHandlerRegistry = mappedStatement.getConfiguration().getTypeHandlerRegistry();
this.mappedStatement = mappedStatement;
this.boundSql = boundSql;
this.configuration = mappedStatement.getConfiguration();
this.sqlCommandType = mappedStatement.getSqlCommandType();
this.parameterObject = processParameter(parameter);

}

在这个方法里面会去增强参数

// com.baomidou.mybatisplus.core.MybatisParameterHandler#processParameter
public Object processParameter(Object parameter) {
/* 只处理插入或更新操作 */
if (parameter != null

        && (SqlCommandType.INSERT == this.sqlCommandType || SqlCommandType.UPDATE == this.sqlCommandType)) {
//检查 parameterObject
if (ReflectionKit.isPrimitiveOrWrapper(parameter.getClass())

            || parameter.getClass() == String.class) {
return parameter;

        }

        Collection<Object> parameters = getParameters(parameter);
if (null != parameters) {

            parameters.forEach(this::process);

        } else {

            process(parameter);

        }

    }
return parameter;

}

// com.baomidou.mybatisplus.core.MybatisParameterHandler#process
private void process(Object parameter) {
if (parameter != null) {
TableInfo tableInfo = null;
Object entity = parameter;
if (parameter instanceof Map) {

            Map<?, ?> map = (Map<?, ?>) parameter;
if (map.containsKey(Constants.ENTITY)) {
Object et = map.get(Constants.ENTITY);
if (et != null) {

                    entity = et;

                    tableInfo = TableInfoHelper.getTableInfo(entity.getClass());

                }

            }

        } else {

            tableInfo = TableInfoHelper.getTableInfo(parameter.getClass());

        }
if (tableInfo != null) {
//到这里就应该转换到实体参数对象了,因为填充和ID处理都是争对实体对象处理的,不用传递原参数对象下去.
MetaObject metaObject = this.configuration.newMetaObject(entity);
if (SqlCommandType.INSERT == this.sqlCommandType) {

                populateKeys(tableInfo, metaObject, entity);

                insertFill(metaObject, tableInfo);

            } else {

                updateFill(metaObject, tableInfo);

            }

        }

    }

}

最终生成id并赋值的操作是在populateKeys中

// com.baomidou.mybatisplus.core.MybatisParameterHandler#populateKeys
protected void populateKeys(TableInfo tableInfo, MetaObject metaObject, Object entity) {
final IdType idType = tableInfo.getIdType();
final String keyProperty = tableInfo.getKeyProperty();
if (StringUtils.isNotBlank(keyProperty) && null != idType && idType.getKey() >= 3) {
final IdentifierGenerator identifierGenerator = GlobalConfigUtils.getGlobalConfig(this.configuration).getIdentifierGenerator();
Object idValue = metaObject.getValue(keyProperty);
if (StringUtils.checkValNull(idValue)) {
if (idType.getKey() == IdType.ASSIGN_ID.getKey()) {
if (Number.class.isAssignableFrom(tableInfo.getKeyType())) {

                    metaObject.setValue(keyProperty, identifierGenerator.nextId(entity));

                } else {

                    metaObject.setValue(keyProperty, identifierGenerator.nextId(entity).toString());

                }

            } else if (idType.getKey() == IdType.ASSIGN_UUID.getKey()) {

                metaObject.setValue(keyProperty, identifierGenerator.nextUUID(entity));

            }

        }

    }

}

在tableInfo中可以得知Id的类型

如果是雪花算法类型，那么生成雪花id；UUID同理

总结

insert之后，id被赋值到实体类的时机要根据具体情况具体讨论：

如果是自增类型的id，那么要在插入数据库完成之后，在ResultSet的ByteArrayRow中获取到这个id

如果是雪花算法id，那么在在插入数据库之前，会通过参数增强的方式，提前生成一个雪花id，然后赋值给实体类