手敲MyBatis(十三章)-返回Insert操作自增索引值
2023-12-22 19:39:36
1.目的
这一章的目的主要是插入语句以后返回插入记录的id，因为插入语句可分为要返回记录id，不要返回记录id的以及不同数据源类型执行的时机也不同（如：oracle不支持主键，需要先插入序列再增加，Mysql支持主键增加一条记录就会有索引）。
如下图，insert里包含selectKey，由selectKey去执行查询此次新增的id记录，我们看到selectKey标签上的属性有keyProperty、order、resultType。
- keyProperty这个是把返回索引的索引放入id里
- order为after则是在insert后执行selectKey
- resultType则是查询返回的类型，示例里为Long
我们最主要的目的就是解析这样的selectKey，然后存入MappedStatement里到时执行时使用，执行Update时则执行selectKey的方法，最后在activity实体id赋值执行完的记录id。
?2.设计说明
标黄色的是修改的，其余都是新增的方法。
?1.构建时（builder）
在构建（builder）时，我们需要解析下selectKey的标签，而selectKey是在语句里，所以需要更改XMLStatementBuilder类添加解析selectKey的标签。最后把解析好的标签放入到addMappedStatement()，这里的动作是两次addMappedStatement()，为什么是两次呢？ps:可以看下面两个图。
- 第一次，SqlCommandType是“SELECT”，代表selectKey本身的语句，需要存储一次MappedStatement
- 第二次，SqlCommandType是“INSERT”，代表是selectKey父级的INSERT标签，它下面要包含这个selectKey的MappedStatement信息，然后如果有selectKey则创建SelectKeyGenerator对象，需要再一次存储MappedStatement。
ps此处看不懂可以调试全局看下，多看几遍就懂了为什么这样设计了。
2.selectKey执行时（executor keygen）
2.1?定义接口：
针对上述情况，需要定义接口KeyGenerator，定义方法为processBefore()（针对Oracle不支持主键的）和processAfter()（支持主键的，如MySql）
2.2 实现接口：
NoKenGenerator和SelectKeyGenerator，不要求返回记录的就执行NoKenGenerator（实现方法什么都不操作）。SelectKeyGenerator的实现则是执行查询索引操作，并将结果添加到insert的操作的实体里，这样就得到了索引。
3.执行时（executor）
我们存储到MappedStatement以后就要流转到执行时，因为SelectKey是查询，所以在Executor时
添加了重载的query()方法。
BaseExecutor实现新的query()方法，拿到了sql语句后，调用原有的doQuery，由SimpleExecutor类实现，此时就会调用BaseStatementHandler构造方法，这里新添加了generateKeys()方法，主要是检查下是否需要在insert前执行selectKey（如：Mysql是insert后，Oracle是insert前）。
执行了新增方法时，则需要添加调用KeyGenerator的processAfter()方法，这个方法依然要检查是否在insert后执行selectKey。
4.结果集的更改(resultset)
由于之前的结果集是只处理bean对象， 一般返回selectKey需要的基本类型，如ID是Long，所以这里需要添加createPrimitiveResultObject()方法获取类型处理器。
在createResultObject()此方法里则需要判断是否是基本类型，如果基本类型则调用createPrimitiveResultObject()。其余类型则还按之前代码走。
5.connection，连接的更改
由于要两个语句用一个连接如果两个连接则无法返回id索引，所以需要在获取连接处判断下是否有连接，如果有就不创建，没有就创建。
3.代码
3.1 selectKey执行操作
包：package cn.bugstack.mybatis.executor.keygen;
添加接口KeyGenerator，主要是用来执行SelectKey查询操作的，此接口定义了两个方法，
processBefore：是在不支持主键需要获取序列时调用，执行insert语句前调用
processAfter：是在支持主键在执行insert语句后嗲用
public interface KeyGenerator {
/**
* 针对Sequence主键而言，在执行insert sql前必须指定一个主键值给要插入的记录，
* 如Oracle、DB2，KeyGenerator提供了processBefore()方法。
*/
void processBefore(Executor executor, MappedStatement ms, Statement stmt, Object parameter);
/**
* 针对自增主键的表，在插入时不需要主键，而是在插入过程自动获取一个自增的主键，
* 比如MySQL、PostgreSQL，KeyGenerator提供了processAfter()方法
*/
void processAfter(Executor executor, MappedStatement ms, Statement stmt, Object parameter);
}
实现类SelectKeyGenera，有selectKey时实现执行selectKey的逻辑。
// step13新增
public class SelectKeyGenerator implements KeyGenerator {
public static final String SELECT_KEY_SUFFIX = "!selectKey";
private boolean executeBefore;
private MappedStatement keyStatement;
public SelectKeyGenerator(MappedStatement keyStatement, boolean executeBefore) {
this.executeBefore = executeBefore;
this.keyStatement = keyStatement;
}
@Override
public void processBefore(Executor executor, MappedStatement ms, Statement stmt, Object parameter) {
if (executeBefore) {
processGeneratedKeys(executor, ms, parameter);
}
}
@Override
public void processAfter(Executor executor, MappedStatement ms, Statement stmt, Object parameter) {
if (!executeBefore) {
processGeneratedKeys(executor, ms, parameter);
}
}
/**
* 执行selectKey的SQL语句，执行完毕后把返回的id结果放入对应实体中。
*/
private void processGeneratedKeys(Executor executor, MappedStatement ms, Object parameter) {
try {
if (parameter != null && keyStatement != null && keyStatement.getKeyProperties() != null) {
String[] keyProperties = keyStatement.getKeyProperties();
final Configuration configuration = ms.getConfiguration();
final MetaObject metaParam = configuration.newMetaObject(parameter);
if (keyProperties != null) {
Executor keyExecutor = configuration.newExecutor(executor.getTransaction());
List<Object> values = keyExecutor.query(keyStatement, parameter, RowBounds.DEFAULT, Executor.NO_RESULT_HANDLER);
if (values.size() == 0) {
throw new RuntimeException("SelectKey returned no data.");
} else if (values.size() > 1) {
throw new RuntimeException("SelectKey returned more than one value.");
} else {
MetaObject metaResult = configuration.newMetaObject(values.get(0));
if (keyProperties.length == 1) {
if (metaResult.hasGetter(keyProperties[0])) {
setValue(metaParam, keyProperties[0], metaResult.getValue(keyProperties[0]));
} else {
setValue(metaParam, keyProperties[0], values.get(0));
}
} else {
handleMultipleProperties(keyProperties, metaParam, metaResult);
}
}
}
}
} catch (Exception e) {
throw new RuntimeException("Error selecting key or setting result to parameter object. Cause: " + e);
}
}
private void handleMultipleProperties(String[] keyProperties,
MetaObject metaParam, MetaObject metaResult) {
String[] keyColumns = keyStatement.getKeyColumns();
if (keyColumns == null || keyColumns.length == 0) {
for (String keyProperty : keyProperties) {
setValue(metaParam, keyProperty, metaResult.getValue(keyProperty));
}
} else {
if (keyColumns.length != keyProperties.length) {
throw new RuntimeException("If SelectKey has key columns, the number must match the number of key properties.");
}
for (int i = 0; i < keyProperties.length; i++) {
setValue(metaParam, keyProperties[i], metaResult.getValue(keyColumns[i]));
}
}
}
private void setValue(MetaObject metaParam, String property, Object value) {
if (metaParam.hasSetter(property)) {
metaParam.setValue(property, value);
} else {
throw new RuntimeException("No setter found for the keyProperty '" + property + "' in " + metaParam.getOriginalObject().getClass().getName() + ".");
}
}
}实现类NoKeyGenerator，在没有selectKey时的逻辑也就是不写具体的逻辑。
public class NoKeyGenerator implements KeyGenerator {
@Override
public void processBefore(Executor executor, MappedStatement ms, Statement stmt, Object parameter) {
// Do Nothing
}
@Override
public void processAfter(Executor executor, MappedStatement ms, Statement stmt, Object parameter) {
// Do Nothing
}
}3.2?builder操作部分的修改
XMLStatementBuilder修改parseStatementNode()，添加了解析selectKey的节点方法processSelectKeyNodes()；
如果有多个就遍历每个节点信息存储到MappedStatement下
public class XMLStatementBuilder extends BaseBuilder {
// 省略其他
public void parseStatementNode() {
// 省略其他
// 解析<selectKey> step-13 新增
processSelectKeyNodes(id, parameterTypeClass, langDriver);
}
/**
* 解析selectKey标签
*/
private void processSelectKeyNodes(String id, Class<?> parameterTypeClass, LanguageDriver langDriver) {
// 得到selectKey标签
List<Element> selectKeyNodes = element.elements("selectKey");
parseSelectKeyNodes(id, selectKeyNodes, parameterTypeClass, langDriver);
}
/**
* for循环遍历selectKey标签
* 取出selectKey的父id拼接select的Key标识
*/
private void parseSelectKeyNodes(String parentId, List<Element> list, Class<?> parameterTypeClass, LanguageDriver langDriver) {
for (Element nodeToHandle : list) {
String id = parentId + SelectKeyGenerator.SELECT_KEY_SUFFIX;
parseSelectKeyNode(id, nodeToHandle, parameterTypeClass, langDriver);
}
}
/**
* 开始解析每一个selectKey标签的内容,并存储MappedStatement里
* <selectKey keyProperty="id" order="AFTER" resultType="long">
* SELECT LAST_INSERT_ID()
* </selectKey>
*/
private void parseSelectKeyNode(String id, Element nodeToHandle, Class<?> parameterTypeClass, LanguageDriver langDriver) {
String resultType = nodeToHandle.attributeValue("resultType");
// 得到resultType类型
Class<?> resultTypeClass = resolveClass(resultType);
// 执行前还是执行后
boolean executeBefore = "BEFORE".equals(nodeToHandle.attributeValue("order", "AFTER"));
String keyProperty = nodeToHandle.attributeValue("keyProperty");
// default
String resultMap = null;
KeyGenerator keyGenerator = new NoKeyGenerator();
// 解析成SqlSource，DynamicSqlSource/RawSqlSource
SqlSource sqlSource = langDriver.createSqlSource(configuration, nodeToHandle, parameterTypeClass);
// SELECT标签
SqlCommandType sqlCommandType = SqlCommandType.SELECT;
// 调用助手类
builderAssistant.addMappedStatement(id,
sqlSource,
sqlCommandType,
parameterTypeClass,
resultMap,
resultTypeClass,
keyGenerator,
keyProperty,
langDriver);
// 给id加上namespace前缀
id = builderAssistant.applyCurrentNamespace(id, false);
// 存放键值生成器配置
MappedStatement keyStatement = configuration.getMappedStatement(id);
// 将KeyGenerator放入map中
configuration.addKeyGenerator(id, new SelectKeyGenerator(keyStatement, executeBefore));
}
}MapperAnnotationBuilder类，注解版的构建也是一样的，需要修改解析的语句，方法为parseStatement()
public class MapperAnnotationBuilder {
private void parseStatement(Method method) {
// 省略其他
// step-13 新增-----------------------------------------------------------
KeyGenerator keyGenerator;
String keyProperty = "id";
if (SqlCommandType.INSERT.equals(sqlCommandType) || SqlCommandType.UPDATE.equals(sqlCommandType)) {
keyGenerator = configuration.isUseGeneratedKeys() ? new Jdbc3KeyGenerator() : new NoKeyGenerator();
} else {
keyGenerator = new NoKeyGenerator();
}
// step-14 新增-----------------------------------------------------------
boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
String resultMapId = null;
if (isSelect) {
resultMapId = parseResultMap(method);
}
// step-13 部分参数新增( keyGenerator,keyProperty,)-------------------------
// 调用助手类
assistant.addMappedStatement(
mappedStatementId,
sqlSource,
sqlCommandType,
parameterTypeClass,
resultMapId,
getReturnType(method),
keyGenerator,
keyProperty,
languageDriver
);
}
}因为MappedStatement要存储数据，所以MappedStatement要加相应的字段，keyGenerator以及keyProperties和keyColumns
public class MappedStatement {
// 其余省略
// step-13 新增
private String resource;
private KeyGenerator keyGenerator;
private String[] keyProperties;
private String[] keyColumns;
public static class Builder {
public Builder(Configuration configuration, String id, SqlCommandType
sqlCommandType, SqlSource sqlSource, Class<?> resultType) {
mappedStatement.keyGenerator = configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType) ? new Jdbc3KeyGenerator() : new NoKeyGenerator();
}
public Builder resource(String resource) {
mappedStatement.resource = resource;
return this;
}
public Builder keyGenerator(KeyGenerator keyGenerator) {
mappedStatement.keyGenerator = keyGenerator;
return this;
}
public Builder keyProperty(String keyProperty) {
mappedStatement.keyProperties = delimitedStringToArray(keyProperty);
return this;
}
}
public String[] getKeyColumns() {
return keyColumns;
}
public String[] getKeyProperties() {
return keyProperties;
}
public KeyGenerator getKeyGenerator() {
return keyGenerator;
}
}MapperBuilderAssistant类：此类修改了addMappedStatement()方法需要增加几个参数，并把参数放入MappedStatement中。
public MappedStatement addMappedStatement(
String id,
SqlSource sqlSource,
SqlCommandType sqlCommandType,
Class<?> parameterType,
String resultMap,
Class<?> resultType,
KeyGenerator keyGenerator,
String keyProperty,
LanguageDriver lang
) {
// 给id加上namespace前缀：cn.bugstack.mybatis.test.dao.IUserDao.queryUserInfoById
id = applyCurrentNamespace(id, false);
MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlCommandType, sqlSource, resultType);
// step-13新增/添加三个属性
statementBuilder.resource(resource);
statementBuilder.keyGenerator(keyGenerator);
statementBuilder.keyProperty(keyProperty);
// 结果映射，给 MappedStatement#resultMaps
setStatementResultMap(resultMap, resultType, statementBuilder);
MappedStatement statement = statementBuilder.build();
// 映射语句信息，建造完存放到配置项中
configuration.addMappedStatement(statement);
return statement;
}
3,3 insert执行SQL部分修改
包：package cn.bugstack.mybatis.executor
Executor接口需要新增个query方法，SelectKeyGenerator执行查询时使用。
// step-13新增-----------------------------------
<E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;BaseExecutor：基础实现类去实现这个query方法，然后调用原有的其他的query方法，然后顺着会调用SimpleExecutor的doQuery()这里的处理没有改变，所以就不提供代码拉。这块就和查询逻辑一样。
// step-14新增-----------------------------------------
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameter);
return query(ms, parameter, rowBounds, resultHandler, boundSql);
}
在上面SimpleExecutor执行doQuery()时，需要调用到BaseStatementHandler的构造方法，此时就需要检查一下是否需要在insert前要执行，如果需要就执行SelectKey，selectKey又会调用上边的query进行查询操作，如果否则不会执行任何操作，判断则在keyGenerator.processBefore()处理。
public abstract class BaseStatementHandler implements StatementHandler {
public BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
if (boundSql == null) {
// 针对Sequence主键而言，在执行insert sql前必须指定一个主键值给要插入的记录。
generateKeys(parameterObject);
}
}
// 针对Sequence主键而言，在执行insert sql前必须指定一个主键值给要插入的记录。KeyGenerator#processBefore
protected void generateKeys(Object parameter) {
KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
keyGenerator.processBefore(executor, mappedStatement, null, parameter);
}
}然后就要修改下执行insert语句了，在Mybatis中所有的insert、del、update，都统一为update方法，所以我们需要修改下update()，修改为执行完insert操作后调用keyGenerator.processAfter()，后置处理（有主键情况下使用），修改如下：
PreparedStatementHandler类
包：package cn.bugstack.mybatis.executor.statement;
@Override
public int update(Statement statement) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
// step-13新增----------------------------------------
// 执行 selectKey 语句
int rows = ps.getUpdateCount();
Object parameterObject = boundSql.getParameterObject();
KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);
// step-13新增----------------------------------------
return rows;
}最后最重要的是，执行insert再执行查询当前插入记录的主键，必须是一个连接，如果是两个连接结果就是空，所以需要更改获取连接的操作，这里很简单，判断下就行了。
修改的包：cn.bugstack.mybatis.transaction.jdbc
修改的类：JdbcTransaction
@Override
public Connection getConnection() throws SQLException {
// step-13新增------------------------------------
// 本章节新增；多个SQL在同一个JDBC连接下，才能完成事务特性
if (connection != null) {
return connection;
}
// step-13新增------------------------------------
connection = dataSource.getConnection();
connection.setTransactionIsolation(level.getLevel());
connection.setAutoCommit(autoCommit);
return connection;
}
4.准备测试
xml如下：
<insert id="insert" parameterType="cn.bugstack.mybatis.test.po.Activity">
INSERT INTO activity
(activity_id, activity_name, activity_desc, create_time, update_time)
VALUES (#{activityId}, #{activityName}, #{activityDesc}, now(), now())
<selectKey keyProperty="id" order="AFTER" resultType="long">
SELECT LAST_INSERT_ID()
</selectKey>
</insert>单元测试如下：
private Logger logger = LoggerFactory.getLogger(ApiTest.class);
private SqlSession sqlSession;
@Before
public void init() throws IOException {
// 1. 从SqlSessionFactory中获取SqlSession
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatis-config-datasource.xml"));
sqlSession = sqlSessionFactory.openSession();
}
@Test
public void test_insert() {
// 1. 获取映射器对象
IActivityDao dao = sqlSession.getMapper(IActivityDao.class);
Activity activity = new Activity();
activity.setActivityId(10004L);
activity.setActivityName("测试活动");
activity.setActivityDesc("测试数据插入");
activity.setCreator("xdf");
// 2. 测试验证
Integer res = dao.insert(activity);
sqlSession.commit();
logger.info("测试结果：count：{} idx：{}", res, JSON.toJSONString(activity.getId()));
}执行结果：?
执行的两条都展示了正确的索引。
文章来源:https://blog.csdn.net/dfBeautifulLive/article/details/135147003
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！