Mybatis之#{}和${}的区别及其实现方式
简单的说#{}和${}的区别:$是String 拼接插入的#则是占位符来做处理的,写法
比如字符串类型,$需要自己添加''#就不需要添加,对于日志的差别就是$会打印在日志里面,#则显示?
大多数我们都是用#{} 因为可以防止sql注入,但是有时候${}还是很必要的,比如传入tableName,或者fieldName比如Order By id||time 就需要${}传入 #{}就无法搞定
typeHandler就无法对${}起作用
---只有明白工具是如何玩耍的,我们才能更好的使用工具
先介绍一个解析#{}和${}的类,这里${}就替换成对对应的值了,而#{}替换成?,并且在这里解析了这个属性的字段,包括判断了类型等等
public
class
GenericTokenParser {
private
final
String openToken;//这个比如#{ 或者${
private
final
String closeToken;//这里基本上就是}
private
final
TokenHandler handler;//根据#{key}或者${key}得到key的值
public
GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {
this
.openToken = openToken;
this
.closeToken = closeToken;
this
.handler = handler;
}
/**
*这个就是替换的了${key} 然后通过hanlder获取value 拼接进去
**/
public
String parse(String text) {
StringBuilder builder =
new
StringBuilder();
if
(text !=
null
&& text.length() >
0
) {
char
[] src = text.toCharArray();
int
offset =
0
;
int
start = text.indexOf(openToken, offset);
while
(start > -
1
) {
if
(start >
0
&& src[start -
1
] ==
'\\'
) {
// the variable is escaped. remove the backslash.
builder.append(src, offset, start -
1
).append(openToken);
offset = start + openToken.length();
}
else
{
int
end = text.indexOf(closeToken, start);
if
(end == -
1
) {
builder.append(src, offset, src.length - offset);
offset = src.length;
}
else
{
builder.append(src, offset, start - offset);
offset = start + openToken.length();
String content =
new
String(src, offset, end - offset);//拿到#{key}||${key}中的key
builder.append(handler.handleToken(content));//根据key获取对应的"value"
offset = end + closeToken.length();
}
}
start = text.indexOf(openToken, offset);
}
if
(offset < src.length) {
builder.append(src, offset, src.length - offset);
}
}
return
builder.toString();
}
}
其实最大的区别也就是下面的两个不同的实现类
1.${} 的解析实现类
判断一下参数的类型,然后就把value给搞定了,没有添加其他的东西,万能的Ognl
private
static
class
BindingTokenParser
implements
TokenHandler {
private
DynamicContext context;
public
BindingTokenParser(DynamicContext context) {
this
.context = context;
}
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 = OgnlCache.getValue(content, context.getBindings());
return
(value ==
null
?
""
: String.valueOf(value));
// issue #274 return "" instead of "null"
}
}
2.#{} 的解析实现类
这里就比较复杂了,判断了javaType,typeHandler,数字精度,通过hanlder,我们就可以处理一些列复杂的数据
private
static
class
ParameterMappingTokenHandler
extends
BaseBuilder
implements
TokenHandler {
private
List parameterMappings =
new
ArrayList();
private
Class parameterType;
private
MetaObject metaParameters;
public
ParameterMappingTokenHandler(Configuration configuration, Class parameterType, Map additionalParameters) {
super
(configuration);
this
.parameterType = parameterType;
this
.metaParameters = configuration.newMetaObject(additionalParameters);
}
public
List getParameterMappings() {
return
parameterMappings;
}
public
String handleToken(String content) {
parameterMappings.add(buildParameterMapping(content));
return
"?"
;
}
//这里就是把#{key}内容进行解析成一个带有一些列属性的类然后再由一些列typehanlder来setValue
private
ParameterMapping buildParameterMapping(String content) {
Map propertiesMap = parseParameterMapping(content);
String property = propertiesMap.get(
"property"
);
Class propertyType;
if
(metaParameters.hasGetter(property)) {
// issue #448 get type from additional params
propertyType = metaParameters.getGetterType(property);
}
else
if
(typeHandlerRegistry.hasTypeHandler(parameterType)) {
propertyType = parameterType;
}
else
if
(JdbcType.CURSOR.name().equals(propertiesMap.get(
"jdbcType"
))) {
propertyType = java.sql.ResultSet.
class
;
}
else
if
(property !=
null
) {
MetaClass metaClass = MetaClass.forClass(parameterType);
if
(metaClass.hasGetter(property)) {
propertyType = metaClass.getGetterType(property);
}
else
{
propertyType = Object.
class
;
}
}
else
{
propertyType = Object.
class
;
}
ParameterMapping.Builder builder =
new
ParameterMapping.Builder(configuration, property, propertyType);
Class javaType = propertyType;
String typeHandlerAlias =
null
;
for
(Map.Entry entry : propertiesMap.entrySet()) {
String name = entry.getKey();
String value = entry.getValue();
if
(
"javaType"
.equals(name)) {
javaType = resolveClass(value);
builder.javaType(javaType);
}
else
if
(
"jdbcType"
.equals(name)) {
builder.jdbcType(resolveJdbcType(value));
}
else
if
(
"mode"
.equals(name)) {
builder.mode(resolveParameterMode(value));
}
else
if
(
"numericScale"
.equals(name)) {
builder.numericScale(Integer.valueOf(value));
}
else
if
(
"resultMap"
.equals(name)) {
builder.resultMapId(value);
}
else
if
(
"typeHandler"
.equals(name)) {
typeHandlerAlias = value;
}
else
if
(
"jdbcTypeName"
.equals(name)) {
builder.jdbcTypeName(value);
}
else
if
(
"property"
.equals(name)) {
// Do Nothing
}
else
if
(
"expression"
.equals(name)) {
throw
new
BuilderException(
"Expression based parameters are not supported yet"
);
}
else
{
throw
new
BuilderException(
"An invalid property '"
+ name +
"' was found in mapping #{"
+ content +
"}. Valid properties are "
+ parameterProperties);
}
}
if
(typeHandlerAlias !=
null
) {
builder.typeHandler(resolveTypeHandler(javaType, typeHandlerAlias));
}
return
builder.build();
}
private
Map parseParameterMapping(String content) {
try
{
return
new
ParameterExpression(content);
}
catch
(BuilderException ex) {
throw
ex;
}
catch
(Exception ex) {
throw
new
BuilderException(
"Parsing error was found in mapping #{"
+ content +
"}. Check syntax #{property|(expression), var1=value1, var2=value2, ...} "
, ex);
}
}
}