Mybatis#{}与${}的区别

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='chengcheng@163.com', 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='chengcheng@163.com', 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='chengcheng@163.com', 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='chengcheng@163.com', 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='123@ss.com'}

由结果显示，我们输入正确的用户名称和账号密码是没有问题的，用户可以查到。

那么当我们不知道密码的时候，使用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='123@ss.com'}

由结果可以看出，我们在没有密码的情况下依旧获取到了数据库的私密信息，由此可见${}存在很大的安全隐患。

那我们来看看#{}是否存在安全问题？

测试条件，参数不变，我们修改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对象，字符串拼接方式，相对不安全。