① mybatis 中 #{} 和 ${} 的區別及應用場景
動態 sql 是 mybatis 的主要特性之一，山李姿在 mapper 中定義的參數傳到 xml 中之後，在查詢之前 mybatis 會對其進行動態解析。
mybatis 為我們提供了兩種支持動態 sql 的語法：#{} 以及 ${} 。
如： #{} ： 根據參數的 類型 進行處理，比如傳入String類型，則會為參數加上雙引號。#{} 傳參在進行SQL預編譯時，會把參數部分用一個佔位符 ? 代替，這樣可以防止 SQL注入。
如： ${} ： 將參數取出不做任擾敏何處理，直接放入語句中，就是簡單逗絕的字元串替換，並且該參數會參加SQL的預編譯，需要手動過濾參數防止 SQL注入。
因此 mybatis 中優先使用 #{}；當需要動態傳入 表名或列名 時，再考慮使用 ${} 。
正確的寫法應該是使用 ${order_by}，這樣解析後就是一個列名，然後才能對數據進行排序，已達到業務需求。
② mybatis中的sql語句中的#佔位符和$佔位符有什麼區別
#{}，和 ${}傳參的區別如下：
使用#傳入參數是，sql語句解析是會加上"",當成字元串來解析，這樣相比於$的好處是比較明顯對的吧，#{}傳參能防止sql注入，如果你傳入的參數為 單引號'，那麼如果使用${},這種方式 那麼是會報錯的
另外一種場景是，如果要做動態的排序，比如 order by column，這個時候務必要用${}
select * from table order by 'name' ,這樣是沒用
目前來看，能用#就不要用$,
③ mybatis是如何將sql執行結果封裝為目標對象並返回的都有哪些映射形式
${}是Properties文件中的變數佔位符，它可以用於標簽屬性值和sql內部，屬於靜態文本替換，比如${driver}會被靜態替換為com.MySQL.jdbc.Driver。#{}是sql的參數佔位符，Mybatis會將sql中的#{}替換為?號，在sql執行前會使用PreparedStatement的參數設置方法，按序給sql的?號佔位符設置參數值，比如ps.setInt(0, parameterValue)，#{item.name}的取值方式為使用反射從參數對象中獲取item對象的name屬性值，相當於param.getItem().getName()。
④ mybatis通過預編譯進行參數拼接的符號
#{}佔位轎帶符:佔位使用#{}意味著使用的預編譯的語句，即在使用jdbc時的preparedStatement，sql語句中如果存在參數則會使用?作佔位符，我仔帆粗們知道這種方式可以防止sql注入，並且在使用#{}時形成的sql語句，已經帶有引號，例，select * from table1 where id=#{id} 在調用這念鎮個語句時我們可以通過後台看到列印出的sql為：select * from table1 where id=『2』 加入傳的值為2.也就是說在組成sql語句的時候把參數默認為字元串。如果傳入的是基本類型,那麼#{}中的變數名稱可以隨意寫如果傳入的參數是pojo類型,那麼#{}中的變數名稱必須是pojo中的屬性.屬性.屬性?${}拼接符:字元串原樣拼接如果傳入的是基本類型,那麼${}中的變數名必須是value如果傳入的參數是pojo類型,那麼${}中的變數名稱必須是pojo中的屬性.屬性.屬性?注意:使用拼接符有可能造成sql注入使用${}時的sql不會當做字元串處理，是什麼就是什麼，如上邊的語句：select * from table1 where id=${id} 在調用這個語句時控制台列印的為：select * from table1 where id=2 ，假設傳的參數值為2從上邊的介紹可以看出這兩種方式的區別，我們最好是能用#{}則用它，因為它可以防止sql注入，且是預編譯的，在需要原樣輸出時才使用${}，如，select * from ${tableName} order by ${id} 這里需要傳入表名和按照哪個列進行排序 ，加入傳入table1、id 則語句為：select * from table1 order by id如果是使用#{} 則變成了select * from 『table1』 order by 『id』 我們知道這樣就不對了。另，在使用以下的配置時，必須使用#{}
⑤ 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<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>();
private Class<?> parameterType;
private MetaObject metaParameters;
public ParameterMappingTokenHandler(Configuration configuration, Class<?> parameterType, Map<String, Object> additionalParameters) {
super(configuration);
this.parameterType = parameterType;
this.metaParameters = configuration.newMetaObject(additionalParameters);
}
public List<ParameterMapping> getParameterMappings() {
return parameterMappings;
}
public String handleToken(String content) {
parameterMappings.add(buildParameterMapping(content));
return "?";
}
//這里就是把#{key}內容進行解析成一個帶有一些列屬性的類然後再由一些列typehanlder來setValue
private ParameterMapping buildParameterMapping(String content) {
Map<String, String> 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<String, String> 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<String, String> 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);
}
}
}
⑥ mybatis中的#和$的區別
1. #將傳入的數據都當成一個字元串，會對自動傳入的數據加一銷隱喚個雙引號。如：order by #user_id#，如果傳入的值是111,那麼解析成sql時的值為order by "111", 如果傳入的值是id，則解析成的sql為order by "id".
2. $將傳入的數據直接顯示生成在sql中。如：order by $user_id$，如果傳入的值是111,那麼解析成sql時的值為order by user_id, 如果傳入的值是id，則解析成的sql為order by id.
3. #方式能夠很大程度防止sql注入。
4.$方式無法防止Sql注入。
5.$方式一般用於傳入資料庫對象，例如傳入表名.
6.一般能用#的就別用$.
MyBatis排序時使用order by 動態參數時需要攜老注意，用$而不虧凱是#
字元串替換
默認情況下，使用#{}格式的語法會導致MyBatis創建預處理語句屬性並以它為背景設置安全的值（比如?）。這樣做很安全，很迅速也是首選做法，有時你只是想直接在SQL語句中插入一個不改變的字元串。比如，像ORDER BY，你可以這樣來使用：
ORDER BY ${columnName}
這里MyBatis不會修改或轉義字元串。
重要：接受從用戶輸出的內容並提供給語句中不變的字元串，這樣做是不安全的。這會導致潛在的SQL注入攻擊，因此你不應該允許用戶輸入這些欄位，或者通常自行轉義並檢查。
⑦ mybatis中的$的sql注入該怎麼解決
#{ } 解析為一個 JDBC 預編譯語句（prepared statement）的參數標記符。
例如，sqlMap 中如下的 sql 語句
select * from user where name = #{name};
解析為：
select * from user where name = ?;
一個 #{ } 被解析為一個參數佔位符 ? 。
${ } 僅僅為一個純碎的 string 替換，在動態 SQL 解析階段將會進行變指塵量替換
例如，sqlMap 中如下的隱襪 sql
select * from user where name = '${name}';
當我們傳遞的參數為 "ruhua" 時，上述 sql 的解析為：
select * from user where name = "ruhua";
預編譯之前的 SQL 語句已經不包含變數 name 了。
綜上所得， ${ } 的變數的替換階段是在動態 SQL 解析階段，而 #{ }的變數的替換是在 DBMS 中。
注意：${ } 在預編譯之前已經被變灶逗激量替換了，這會存在 sql 注入問題。