Mybatis 作為國內開發中常用到的半自動 orm 框架，相信大家都很熟悉，它提供了簡單靈活的xml映射配置，方便開發人員撰寫簡單、復雜SQL，在國內互聯網公司使用眾多，
本文針對筆者日常開發中對 Mybatis 占位符 #{} 和 ${} 使用時機結合原始碼，思考總結而來
Mybatis版本 3.5.11Spring boot版本 3.0.2mybatis-spring版本 3.0.1- github地址：https://github.com/wayn111， 歡迎大家關注，點個star
一. 啟動時，mybatis-spring 決議xml檔案流程圖
Spring 專案啟動時，mybatis-spring 自動初始化決議xml檔案核心流程
Mybatis 在 buildSqlSessionFactory() 會遍歷所有 mapperLocations（xml檔案） 呼叫 xmlMapperBuilder.parse()決議，原始碼如下
在 parse() 方法中， Mybatis 通過 configurationElement(parser.evalNode("/mapper")) 方法決議xml檔案中的各個標簽
public class XMLMapperBuilder extends BaseBuilder {
...
private final MapperBuilderAssistant builderAssistant;
private final Map<String, XNode> sqlFragments;
...
public void parse() {
if (!configuration.isResourceLoaded(resource)) {
// xml檔案決議邏輯
configurationElement(parser.evalNode("/mapper"));
configuration.addLoadedResource(resource);
bindMapperForNamespace();
}
parsePendingResultMaps();
parsePendingCacheRefs();
parsePendingStatements();
}
private void configurationElement(XNode context) {
try {
// 決議xml檔案內的namespace、cache-ref、cache、parameterMap、resultMap、sql、select、insert、update、delete等各種標簽
String namespace = context.getStringAttribute("namespace");
if (namespace == null || namespace.isEmpty()) {
throw new BuilderException("Mapper's namespace cannot be empty");
}
builderAssistant.setCurrentNamespace(namespace);
cacheRefElement(context.evalNode("cache-ref"));
cacheElement(context.evalNode("cache"));
parameterMapElement(context.evalNodes("/mapper/parameterMap"));
resultMapElements(context.evalNodes("/mapper/resultMap"));
sqlElement(context.evalNodes("/mapper/sql"));
buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
} catch (Exception e) {
throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
}
}
}
最后會把 namespace、cache-ref、cache、parameterMap、resultMap、select、insert、update、delete等標簽內容決議結果放到 builderAssistant 物件中，將sql標簽決議結果放到sqlFragments物件中，其中 由于 builderAssistant 物件會保存select、insert、update、delete標簽內容決議結果我們對 builderAssistant 物件進行深入了解
public class MapperBuilderAssistant extends BaseBuilder {
...
}
public abstract class BaseBuilder {
protected final Configuration configuration;
...
}
public class Configuration {
...
protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection")
.conflictMessageProducer((savedValue, targetValue) ->
". please check " + savedValue.getResource() + " and " + targetValue.getResource());
protected final Map<String, Cache> caches = new StrictMap<>("Caches collection");
protected final Map<String, ResultMap> resultMaps = new StrictMap<>("Result Maps collection");
protected final Map<String, ParameterMap> parameterMaps = new StrictMap<>("Parameter Maps collection");
protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<>("Key Generators collection");
protected final Set<String> loadedResources = new HashSet<>();
protected final Map<String, XNode> sqlFragments = new StrictMap<>("XML fragments parsed from previous mappers");
...
}
builderAssistant 物件繼承至 BaseBuilder，BaseBuilder 類中包含一個 configuration 物件屬性， configuration 物件中會保存xml檔案標簽決議結果至自身對應屬性mappedStatements、caches、resultMaps、sqlFragments，
這里有個問題上面提到的sql標簽結果會放到 XMLMapperBuilder 類的 sqlFragments 物件中，為什么 Configuration 類中也有個 sqlFragments 屬性？
這里回看上文 buildSqlSessionFactory() 方法最后
原來 XMLMapperBuilder 類中的 sqlFragments 屬性就來自Configuration類??
回到主題，在 buildStatementFromContext(context.evalNodes("select|insert|update|delete")) 方法中會通過如下呼叫
buildStatementFromContext(List<XNode> list, String requiredDatabaseId)
-> parseStatementNode()
-> createSqlSource(Configuration configuration, XNode script, Class<?> parameterType)
-> parseScriptNode()
-> parseDynamicTags(context)
最后通過parseDynamicTags(context) 方法決議 select、insert、update、delete 標簽內容將結果保存在 MixedSqlNode 物件中的 SqlNode 集合中
public class MixedSqlNode implements SqlNode {
private final List<SqlNode> contents;
public MixedSqlNode(List<SqlNode> contents) {
this.contents = contents;
}
@Override
public boolean apply(DynamicContext context) {
contents.forEach(node -> node.apply(context));
return true;
}
}
SqlNode 是一個介面，有10個實作類如下
可以看出我們的 select、insert、update、delete 標簽中包含的各個文本（包含占位符 #{} 和 ${}）、子標簽都有對應的 SqlNode 實作類，后續運行中， Mybatis 對于 select、insert、update、delete 標簽的 sql 陳述句處理都與這里的 SqlNode 各個實作類相關，自此我們 mybatis-spring 初始化流程中相關的重要代碼都過了一遍，
二. 運行中，sql陳述句占位符 #{} 和 ${} 的處理
這里直接給出xml檔案查詢方法標簽內容
<select id="findNewBeeMallOrderList" parameterType="Map" resultMap="BaseResultMap">
select
<include refid="Base_Column_List"/>
from tb_newbee_mall_order
<where>
<if test="orderNo!=null and orderNo!=''">
and order_no = #{orderNo}
</if>
<if test="userId!=null and userId!=''">
and user_id = #{userId}
</if>
<if test="payType!=null and payType!=''">
and pay_type = #{payType}
</if>
<if test="orderStatus!=null and orderStatus!=''">
and order_status = #{orderStatus}
</if>
<if test="isDeleted!=null and isDeleted!=''">
and is_deleted = #{isDeleted}
</if>
<if test="startTime != null and startTime.trim() != ''">
and create_time > #{startTime}
</if>
<if test="endTime != null and endTime.trim() != ''">
and create_time < #{endTime}
</if>
</where>
<if test="sortField!=null and order!=null">
order by ${sortField} ${order}
</if>
<if test="start!=null and limit!=null">
limit #{start},#{limit}
</if>
</select>
運行時 Mybatis 動態代理 MapperProxy 物件的呼叫流程，如下：
-> newBeeMallOrderMapper.findNewBeeMallOrderList(pageUtil);
-> MapperProxy.invoke(Object proxy, Method method, Object[] args)
-> MapperProxy.invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession)
-> MapperMethod.execute(SqlSession sqlSession, Object[] args)
-> MapperMethod.executeForMany(SqlSession sqlSession, Object[] args)
-> SqlSessionTemplate.selectList(String statement, Object parameter)
-> SqlSessionInterceptor.invoke(Object proxy, Method method, Object[] args)
-> DefaultSqlSession.selectList(String statement, Object parameter)
-> DefaultSqlSession.selectList(String statement, Object parameter, RowBounds rowBounds)
-> DefaultSqlSession.selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler)
-> CachingExecutor.query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler)
-> MappedStatement.getBoundSql(Object parameterObject)
-> DynamicSqlSource.getBoundSql(Object parameterObject)
-> MixedSqlNode.apply(DynamicContext context) // ${} 占位符處理
-> SqlSourceBuilder.parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) // #{} 占位符處理
Mybatis 通過 DynamicSqlSource.getBoundSql(Object parameterObject) 方法對 select、insert、update、delete 標簽內容做 sql 轉換處理，代碼如下：
@Override
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);
context.getBindings().forEach(boundSql::setAdditionalParameter);
return boundSql;
}
2.1 ${} 占位符處理
在 rootSqlNode.apply(context) -> MixedSqlNode.apply(DynamicContext context) 中會將 SqlNode 集合拼接成實際要執行的 sql 陳述句
保存在 DynamicContext 物件中，這里給出 SqlNode 集合的除錯截圖
可以看出我們的 ${} 占位符文本的 SqlNode 實作類為 TextSqlNode，apply方法相關操作如下
public class TextSqlNode implements SqlNode {
...
@Override
public boolean apply(DynamicContext context) {
GenericTokenParser parser = createParser(new BindingTokenParser(context, injectionFilter));
context.appendSql(parser.parse(text));
return true;
}
private GenericTokenParser createParser(TokenHandler handler) {
return new GenericTokenParser("${", "}", handler);
}
// 劃重點，${}占位符替換邏輯在就handleToken(String content)方法中
@Override
public String handleToken(String content) {
Object parameter = context.getBindings().get("_parameter");
if (parameter == null) {
context.getBindings().put("value", null);
} else if (SimpleTypeRegistry.isSimpleType(parameter.getClass())) {
context.getBindings().put("value", parameter);
}
Object value = https://www.cnblogs.com/wayn111/p/OgnlCache.getValue(content, context.getBindings());
String srtValue = value == null ?"" : String.valueOf(value); // issue #274 return "" instead of "null"
checkInjection(srtValue);
return srtValue;
}
}
public class GenericTokenParser {
public String parse(String text) {
...
do {
...
if (end == -1) {
...
} else {
builder.append(handler.handleToken(expression.toString()));
offset = end + closeToken.length();
}
}
...
} while (start > -1);
...
return builder.toString();
}
}
劃重點，${} 占位符處理如下
handleToken(String content) 方法中， Mybatis 會通過 ognl 運算式將 ${} 的結果直接拼接在 sql 陳述句中，由此我們得知 ${} 占位符拼接的欄位就是我們傳入的原樣欄位，有著 Sql 注入風險
2.2 #{} 占位符處理
#{} 占位符文本的 SqlNode 實作類為 StaticTextSqlNode，查看原始碼
public class StaticTextSqlNode implements SqlNode {
private final String text;
public StaticTextSqlNode(String text) {
this.text = text;
}
@Override
public boolean apply(DynamicContext context) {
context.appendSql(text);
return true;
}
}
StaticTextSqlNode 會直接將節點內容拼接在 sql 陳述句中，也就是說在 rootSqlNode.apply(context) 方法執行完畢后，此時的 sql 陳述句如下
select order_id, order_no, user_id, total_price,
pay_status, pay_type, pay_time, order_status,
extra_info, user_name, user_phone, user_address,
is_deleted, create_time, update_time
from tb_newbee_mall_order
order by create_time desc
limit #{start},#{limit}
Mybatis 會通過上面提到 getBoundSql(Object parameterObject) 方法中的
sqlSourceParser.parse() 方法完成 #{} 占位符的處理，代碼如下：
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;
if (configuration.isShrinkWhitespacesInSql()) {
sql = parser.parse(removeExtraWhitespaces(originalSql));
} else {
sql = parser.parse(originalSql);
}
return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
}
看到了熟悉的 #{ 占位符沒有，哈哈??， Mybatis 對于 #{} 占位符的處理就在 GenericTokenParser類的 parse() 方法中，代碼如下：
public class GenericTokenParser {
public String parse(String text) {
...
do {
...
if (end == -1) {
...
} else {
builder.append(handler.handleToken(expression.toString()));
offset = end + closeToken.length();
}
}
...
} while (start > -1);
...
return builder.toString();
}
}
public class SqlSourceBuilder extends BaseBuilder {
...
// 劃重點，#{}占位符替換邏輯在就SqlSourceBuilder.handleToken(String content)方法中
@Override
public String handleToken(String content) {
parameterMappings.add(buildParameterMapping(content));
return "?";
}
}
劃重點，#{} 占位符處理如下
handleToken(String content) 方法中， Mybatis 會直接將我們的傳入引數轉換成問號（就是 jdbc 規范中的問號），也就是說我們的 sql 陳述句是預處理的，能夠避免 sql 注入問題
三. 總結
由上經過原始碼分析，我們知道 Mybatis 對 #{} 占位符是直接轉換成問號，拼接預處理 sql， ${} 占位符是原樣拼接處理，有sql注入風險，最好避免由客戶端傳入此引數，
原始碼閱讀不易，歡迎大家點贊，轉發，評論，加我的qq技術討論群：862416125
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/543378.html
標籤：Java
上一篇：java中執行緒的實作方式