mybatis中#{}与${}的区别详解
mybatis中#{}与${}的区别详解
版本
此处分析基于mybatis-3.4.6完成。
介绍-猜想
网上的很多资料都表示，#{}表达式写入参数时将表达式替换为？，而＄{}表达式写入参数时是直接写入。本来以为#{}利用的是jdbc中PreparedStatement的方式，而＄{}是直接使用Statement，其实不然。开发同学都知道PreparedStatement其预编译的特性可以在操作大量SQL时有显著的性能提升，并且可以防止SQL注入安全问题。Statement相比更加简单，少了预编译和SQL注入安全防范，因此在少量的SQL执行上，其性能要更高，只是这点性能一般来说忽略不计了，因此开发中往往都是只会使用#{}。实际官网上也表明了，#{}使用PreparedStatement操作，但是没明确说＄{}使用的Statement，只是表示＄{}表达式中的参数会被直接替换，下图为截选自mybatis官网。
验证-源码分析
回到主题，猜想了#{}与＄{}的区别后，现在开始从源码方面验证一下。
更新流程分析阶段
要了解#{}与＄{}的区别需要知道mybatis的初始化与SQL的执行阶段逻辑，下面会简单介绍一下。
mybatis的初始化入口如下：
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
下面是mybatis的更新执行流程图：
可以从流程图中发现，mybatis的更新操作在Executor#doUpdate()处执行。
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
Statement stmt = null;
int var6;
try {
Configuration configuration = ms.getConfiguration();
StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, (ResultHandler)null, (BoundSql)null);
stmt = this.prepareStatement(handler, ms.getStatementLog());
var6 = handler.update(stmt);
} finally {
this.closeStatement(stmt);
}
return var6;
}
跟踪源码可以发现，在Executor执行操作时，SQL已经被初始化了（#{}表达式标识的参数已经被替换为了？），而往上跟踪可以发现初始化操作在SQLSessionFactory初始化阶段，那么回到初始化阶段。
mybatis初始化阶段
XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
var5 = this.build(parser.parse());
在初始化时，mybatis会parse我们的配置文件和mapper文件。XmlConfigBuilder#mapperElement()做映射构建、XMLMapperBuilder#parse()解析mapper、#configurationElement()配置mapper元素、#buildStatementFromContext()配置select|insert|update|delete语句、XmlStatementBuilder#parseStatementNode()语句构建，直到开始解析SQL语句。
//解析语句(select|insert|update|delete)
//<select
// id="selectPerson"
// parameterType="int"
// parameterMap="deprecated"
// resultType="hashmap"
// resultMap="personResultMap"
// flushCache="false"
// useCache="true"
// timeout="10000"
// fetchSize="256"
// statementType="PREPARED"
// resultSetType="FORWARD_ONLY">
// SELECT * FROM PERSON WHERE ID = #{id}
//</select>
public void parseStatementNode() {
//...忽略一系列逻辑
//官网可以查到，这里的langDriver默认为：XMLLanguageDriver。
LanguageDriver langDriver = getLanguageDriver(lang);
//注意，此处为显示指定PreParedStatement、Statement或者是CallableStatement的地方，默认情况下为PreparedStatement。
StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
//Mapper中的SQL映射初始化，#{}表达式被替换为？，${}表达式不变化
// Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
}
那么接下来进入到XmlLanguageDriver中，XMLScriptBuilder#parseScriptNode()，通过调用parseDynamicTags() 来根据当前xml的tag拿到childTag(也就是select中包含的SQL语句)，通过isDynamic方法来判断。跟踪到isDynamic方法中可以看到，new了一个GenericTokenParser默认以＄{}解析方式，而判断在parse方法中，以String.indexOf判断拿到的SQL语句中是否存在＄{，最后确认是否为DynamicSqlSource(#{})或者RawSqlSource(＄{})，而如果是RawSQLSource，则在初始化中通过SqlSourceBuilder#parse()中，将SQL参数替换为了?。
//isDynamic的判断
public boolean isDynamic() {
DynamicCheckerTokenParser checker = new DynamicCheckerTokenParser();
GenericTokenParser parser = createParser(checker);
parser.parse(text);
return checker.isDynamic();
}
//非isDynamic情况下，#{}解析。
public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
String sql = parser.parse(originalSql);
return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
}
更新操作执行阶段
在SQLSource初始化完毕后，#{}的方法会替换为"?"，而${}的方式SQL语句不变，在后面具体执行时才会动态设置参数。这个结果可以在SQLSessionFactory.configuration.mappedStatements中看到。
再次来到Executor#doUpdate()#prepareStatement()，在这里#{}设置参数的核心方法入口为DefaultParameterHandler -> setParameters，其实就是原生jdbc中PreparedStatement的setParameter。
/**
* BaseTypeHandler的抽象方法，其中在此处可以看到，mybatis对不同的类型封装了不同的typeHandler来做。
*/
public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
//...省略部分逻辑
try {
setNonNullParameter(ps, i, parameter, jdbcType);
} catch (Exception e) {
throw new TypeException("Error setting non null for parameter #" + i + " with JdbcType " + jdbcType + " . " +
"Try setting a different JdbcType for this parameter or a different configuration property. " +
"Cause: " + e, e);
}
}
}
而关于＄{}设置参数，在parameterize()会发现其已经设置完成了，那么回到构建doUpdate()方法中。在这里newStatementHandler()完成的statementHandler的构建与SQL参数的注入。
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
//可以看到其new了一个RoutingStatementHandler
StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
return statementHandler;
}
RoutingStatementHandler的构造：
public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
//这里的statementType为Prepared，这个在SQLSessionFactory中完成初始化
switch (ms.getStatementType()) {
case STATEMENT:
delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
case PREPARED:
delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
case CALLABLE:
delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
default:
throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
}
}
往下跟踪会发现其调用super的构造器，因此来到BaseStatementHandler：
protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
this.configuration = mappedStatement.getConfiguration();
this.executor = executor;
this.mappedStatement = mappedStatement;
this.rowBounds = rowBounds;
this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
this.objectFactory = configuration.getObjectFactory();
//前面在doUpdate中，boundSQL传入的为null，因此进入getBoundSql中
if (boundSql == null) { // issue #435, get the key before calculating the statement
generateKeys(parameterObject);
boundSql = mappedStatement.getBoundSql(parameterObject);
}
this.boundSql = boundSql;
this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
}
mappedStatement.getBoundSql代码如下：
public BoundSql getBoundSql(Object parameterObject) {
//SQL的初始化逻辑入口，这里的SQLSource为DynamicSqlSource，这是在mybatis初始化时构建的，回想一下isDynamic就明白了。
BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
//...忽略其他逻辑
return boundSql;
}
DynamicSqlSource#getBoundSql代码如下：
public BoundSql getBoundSql(Object parameterObject) {
DynamicContext context = new DynamicContext(configuration, parameterObject);
//这里就是初始化的方法了
rootSqlNode.apply(context);
SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
for (Map.Entry<String, Object> entry : context.getBindings().entrySet()) {
boundSql.setAdditionalParameter(entry.getKey(), entry.getValue());
}
return boundSql;
}
结论
自此，#{}与＄{}的分析完毕，可以发现#{}与＄{}的具体操作都是通过PreparedStatement来执行的，只是#{}与＄{}的参数注入上，一个是动态注入，一个是静态注入。具体Statement的类型由开发者手动配置，默认情况下为PreparedStatement。但是要注意，如果使用#{}表达式是不能配置statementType为：Statement的，这里个prepareStatement()方法中就能体现出来，最终结果会去执行一个带有?的SQL语句导致语法错误。
