MyBatis是一款優秀的開源持久層框架，支持自定義SQL查詢、存儲過程和高級映射，相信很多小伙伴都在使用。在MyBatis中，我們可以在XML中編寫SQL語句，然后綁定到JAVA方法中，通過參數和結果集的自動映射來實現復雜的查詢邏輯。MyBatis消除了幾乎所有JDBC操作和手動綁定參數操作，使用起來非常方便！因此MyBatis也同樣是面試官常問的知識模塊之一，其中MyBatis中#{}與${}的區別就是其中經典的面試題，接下來這，我們就進行展開，詳細進行介紹其中的區別。
一、簡單解答
#{}：Mybatis中#傳遞參數底層使用PreparedStatement對象，使用占位符方式，相對安全。
${}：Mybatis中$傳遞參數底層使用Statement對象，字符串拼接方式，相對不安全。
以上就是MyBatis中#{}與${}的區別,當面試官問到時，回答以上內容一般就OK了。當然如果面試官問到PreparedStatement和Statement又什么區別，那就:
Statement：底層傳遞SQL參數時，使用拼接SQL方式，存在SQL注入安全隱患.
PreparedStatement：底層傳遞SQL參數時，使用?【占位符】方式，相對安全。
可能有人會問什么是SQL注入？我們舉一個簡單的例子，比如我們簡單的登錄注冊功能，輸入賬號和密碼，我們調用SQL語句 select count(1) from table where username = 'username' and password = 'password'。查詢到數據才可以是登錄成功，否則表示登陸失敗，但是會有這么一種情況，我們的SQL語句是由我們拼接的，如果用戶故意輸入可以讓后臺解析失敗的字符串，這就是SQL注入，例如我們輸入密碼，輸入 '''' ' or 1=1'' 這樣，他會在后臺進行拼接成select count(1) from table where username = 'username' and password = '' or 1=1;相當于后面拼接了一個恒為true的條件。因此它的查詢結果一定是成立的，不需要輸入密碼就成功了，我們會在下面的案例中詳細展示此條件。
二、區別詳情展示
上面只是簡單的對MyBatis中#{}與${}的區別一個介紹，以應付面試官為主，接下來我們詳細進行他們區別的展示，大家進行深入理解。
我們先進行環境的準備：
首先是pom的依賴：
<dependencies>
<!--導入MyBatis的jar包-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.6</version>
</dependency>
<!-- MySQL驅動包-->
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.16</version>
</dependency>
<!--junit-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!--log4j-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>
數據庫的配置信息：db.properties（以自己的實際為準）
#key=value
db.username=root
db.password=123456
db.url=jdbc:mysql://localhost:3306/could2021?serverTimezone=Asia/ShanghAI
db.driver=com.mysql.cj.jdbc.Driver
mybatis的核心配置文件：mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<properties resource="db.properties"></properties>
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"/>
<!-- 開啟延遲加載 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 設置加載的數據是按需加載-->
<setting name="aggressiveLazyLoading" value="false"/>
<!-- 開啟二級緩存-->
<setting name="cacheEnabled" value="true"/>
</settings>
<typeAliases>
<package name="ssm.pojo"/>
</typeAliases>
<environments default="development">
<!-- 設置連接數據庫環境-->
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${db.driver}"/>
<property name="url" value="${db.url}"/>
<property name="username" value="${db.username}"/>
<property name="password" value="${db.password}"/>
</dataSource>
</environment>
</environments>
<mAppers>
<!-- 設置映射文件路徑-->
<mapper resource="mapper/EmployeeMapper.xml"/>
<mapper resource="mapper/UserMapper.xml"/>
</mappers>
</configuration>
環境的準備工作我們做好了，接下來我們來探究吧。
1.1本質區別
上文說了：#{}使用占位符方式；${}是字符串的拼接，接下來我們以代碼為例，進行詳細介紹：
#{}是使用占位符的方式，用預處理的方式，如一下代碼：
SELECT id,last_name,email,salary,dept_id
FROM tbl_employee WHERE id = #{id}
最終生成的SQL語句如下：
DEBUG 02-13 11:27:12,141 ==> Preparing: SELECT id,last_name,email,salary,dept_id FROM tbl_employee WHERE id = ? (BaseJdbcLogger.java:137)
DEBUG 02-13 11:27:12,162 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:137)
DEBUG 02-13 11:27:12,179 <== Total: 1 (BaseJdbcLogger.java:137)
Employee{id=1, lastName='lalal', email='[email protected]', salary=100000.0, dept=null}
顯而易見，#{}是通過占位符的方式進行拼接的。
接下來我們再看${}，它是通過字符串拼接，將參數拼接到SQL語句中，具體如下所示：
SELECT id,last_name,email,salary,dept_id
FROM tbl_employee WHERE id = ${id}
最終生成的SQL語句如下：
DEBUG 02-13 11:34:52,158 ==> Preparing: SELECT id,last_name,email,salary,dept_id FROM tbl_employee WHERE id = 1 (BaseJdbcLogger.java:137)
DEBUG 02-13 11:34:52,179 ==> Parameters: (BaseJdbcLogger.java:137)
DEBUG 02-13 11:34:52,197 <== Total: 1 (BaseJdbcLogger.java:137)
Employee{id=1, lastName='lalal', email='[email protected]', salary=100000.0, dept=null}
顯而易見，使用${},將我們的參數拼接到了SQL語句中。
我們可以看出，當參數為整數類型時（不考慮安全問題的前提下），${}與#{}的執行效果都是一樣的，SQL語句都可以執行成功。
但是對于當參數的類型是字符時，使用${}就有問題了，我們先看一下使用#{}的代碼：
SELECT id,last_name,email,salary,dept_id
FROM tbl_employee WHERE last_name = #{lastName}
查詢結果如下所示:
DEBUG 02-13 14:21:50,285 ==> Preparing: SELECT id,last_name,email,salary,dept_id FROM tbl_employee WHERE last_name = ? (BaseJdbcLogger.java:137)
DEBUG 02-13 14:21:50,343 ==> Parameters: lalal(String) (BaseJdbcLogger.java:137)
DEBUG 02-13 14:21:50,423 <== Total: 1 (BaseJdbcLogger.java:137)
Employee{id=1, lastName='lalal', email='[email protected]', salary=100000.0, dept=null}
接下來我們再看一下${}進行操作字符的參數：
SELECT id,last_name,email,salary,dept_id
FROM tbl_employee WHERE last_name = ${lastName}
我們看一下運行此sql語句的控制臺結果：
DEBUG 02-13 14:27:48,111 ==> Preparing: SELECT id,last_name,email,salary,dept_id FROM tbl_employee WHERE last_name = lalal (BaseJdbcLogger.java:137)
DEBUG 02-13 14:27:48,132 ==> Parameters: (BaseJdbcLogger.java:137)
org.Apache.ibatis.exceptions.PersistenceException:
### Error querying database. Cause: java.sql.SQLSyntaxErrorException: Unknown column 'lalal' in 'where clause'
### The error may exist in mapper/EmployeeMapper.xml
### The error may involve defaultParameterMap
### The error occurred while setting parameters
### SQL: SELECT id,last_name,email,salary,dept_id FROM tbl_employee WHERE last_name = lalal
### Cause: java.sql.SQLSyntaxErrorException: Unknown column 'lalal' in 'where clause'
由上方內容顯示可以看出他把字符串的參數直接拼接到SQL語句中了。這樣就會導致程序報錯，因為傳遞的參數是字符類型的，而在 SQL 的語法中，如果是字符類型需要給值添加單引號，否則就會報錯。而 ${} 是直接替換，不會自動添加單引號，所以執行就報錯了。
所以，對于參數類型是字符時，#{}是沒有問題的，而${}存在問題。
2.2使用場景
由上面的測試代碼我們可知#{}使用占位符方式；${}是字符串的拼接。雖然使用 #{} 的方式可以處理任意類型的參數，然而當傳遞的參數是一個 SQL 命令或 SQL 關鍵字時 #{} 就會出問題了。例如我們做表做排序操作，而其中desc 倒序或者是 asc 正序的排序規則也以參數的形式傳遞的話，我們需要借助${}來實現，具體如下：
SELECT id,last_name,email,salary,dept_id
FROM tbl_employee order by dept_id ${sort}
以上代碼生成的執行 SQL 和運行結果如下：
DEBUG 02-13 15:31:49,041 Cache Hit Ratio [ssm.mapper.EmployeeMapper]: 0.0 (LoggingCache.java:60)
DEBUG 02-13 15:31:49,771 ==> Preparing: SELECT id,last_name,email,salary,dept_id FROM tbl_employee order by dept_id desc (BaseJdbcLogger.java:137)
DEBUG 02-13 15:31:49,798 ==> Parameters: (BaseJdbcLogger.java:137)
DEBUG 02-13 15:31:49,828 <== Total: 16 (BaseJdbcLogger.java:137)
[Employee{id=10, lastName='chengcheng8', email='[email protected]', salary=100000.0, dept=null}, Employee{id=9......
但是，如果將代碼中的 ${} 改為 #{}，那么程序執行就會報錯，#{} 的實現代碼如下：
DEBUG 02-13 15:35:20,525 Cache Hit Ratio [ssm.mapper.EmployeeMapper]: 0.0 (LoggingCache.java:60)
DEBUG 02-13 15:35:21,265 ==> Preparing: SELECT id,last_name,email,salary,dept_id FROM tbl_employee order by dept_id ? (BaseJdbcLogger.java:137)
DEBUG 02-13 15:35:21,287 ==> Parameters: desc(String) (BaseJdbcLogger.java:137)
org.apache.ibatis.exceptions.PersistenceException:
### Error querying database. Cause: java.sql.SQLSyntaxErrorException: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ''desc'' at line 2
由以上結果可以看出，當我們傳遞的是普通參數的時候，需要使用 #{}的方式，但是當傳入的參數是一個 SQL 命令或 SQL 關鍵字時，需要使用 ${} 來對 SQL 中的參數進行直接替換并執行。
2.3安全性不同
接下來我們的重點來了，對于他們兩者來說，它們兩者之間最大的區別體現在安全方面，使用${}會出現安全問題，也就是SQL的注入問題，而使用 #{} 由于是預處理的，所以不會存在安全問題。大家可能好奇怎么出現的安全隱患，我們來進行測試一下：我們以用戶的登錄功能為例，進行兩者之間的差別。
使用 ${}來實現登錄功能測試
UserMapper.xml 中的實現代碼如下：
<select id="login" resultType="user">
SELECT * FROM user where username='${param1}' and password='${param2}'
</select>
測試代碼如下：
@Test
public void login(){
User user = userMapper.login("admin","123456");
System.out.println(user);
}
控制臺運行代碼如下：
DEBUG 02-13 16:18:58,930 ==> Preparing: SELECT * FROM user where username=? and password=? (BaseJdbcLogger.java:137)
DEBUG 02-13 16:18:58,953 ==> Parameters: admin(String), 123456(String) (BaseJdbcLogger.java:137)
DEBUG 02-13 16:18:58,971 <== Total: 1 (BaseJdbcLogger.java:137)
User{id=11, userName='admin', passWord='123456', email='[email protected]'}
由結果顯示，我們輸入正確的用戶名稱和賬號密碼是沒有問題的，用戶可以查到。
那么當我們不知道密碼的時候，使用sql注入的方式也可以進行數據的讀取，如下所示：我們的SQL語句不變，我們改變傳入參數的內容。
User user = userMapper.login("admin", "' or 1='1");
System.out.println(user);
通過以上的方式傳參，進行用戶登錄測試，結果如下：
DEBUG 02-13 16:36:01,997 ==> Preparing: SELECT * FROM user where username='admin' and (password='' or 1='1') (BaseJdbcLogger.java:137)
DEBUG 02-13 16:36:02,020 ==> Parameters: (BaseJdbcLogger.java:137)
DEBUG 02-13 16:36:02,037 <== Total: 1 (BaseJdbcLogger.java:137)
User{id=11, userName='admin', passWord='123456', email='[email protected]'}
由結果可以看出，我們在沒有密碼的情況下依舊獲取到了數據庫的私密信息，由此可見${}存在很大的安全隱患。
那我們來看看#{}是否存在安全問題？
測試條件，參數不變，我們修改xml的映射文件，使用#{}進行參數的傳遞。
<select id="login" resultType="user">
SELECT * FROM user where username=#{param1} and password=#{param2}
</select>
控制臺結果顯示：
DEBUG 02-14 11:23:09,911 ==> Preparing: SELECT * FROM user where username=? and password=? (BaseJdbcLogger.java:137)
DEBUG 02-14 11:23:09,934 ==> Parameters: admin(String), ' or 1='1(String) (BaseJdbcLogger.java:137)
DEBUG 02-14 11:23:09,951 <== Total: 0 (BaseJdbcLogger.java:137)
null
如上圖結果顯示：參數的傳遞相當于password=“' or 1='1”這個整體，根據此條件查詢數據庫，查詢不到信息。因此，用時SQL注入引發的安全隱患問題，#{}是可以防止的。
總結
通過上文的講解，大概應該明白的了${}與#{}的區別：
#{}：Mybatis中#{}傳遞參數底層使用PreparedStatement對象，使用占位符方式，相對安全。
${}：Mybatis中${}傳遞參數底層使用Statement對象，字符串拼接方式，相對不安全。
