共计 42318 个字符，预计需要花费 106 分钟才能阅读完成。
-
MyBatis 是一个开源、轻量级的数据持久化框架，是 JDBC 和 Hibernate 的替代方案。MyBatis 内部封装了 JDBC，简化了加载驱动、创建连接、创建 statement 等繁杂的过程，开发者只需要关注 SQL 语句本身。
-
MyBatis 支持定制化 SQL、存储过程以及高级映射，可以在实体类和 SQL 语句之间建立映射关系，是一种半自动化的 ORM 实现。其封装性低于 Hibernate，但性能优秀、小巧、简单易学、应用广泛。
-
MyBatis 的主要思想是将程序中的大量 SQL 语句剥离出来，使用 XML 文件或注解的方式实现 SQL 的灵活配置，将 SQL 语句与程序代码分离，在不修改程序代码的情况下，直接在配置文件中修改 SQL 语句。
-
MyBatis 与其它持久性框架最大的不同是，MyBatis 强调使用 SQL，而其它框架（例如 Hibernate）通常使用自定义查询语言，即 HQL（Hibernate查询语言）或 EJB QL（Enterprise JavaBeans查询语言）。
- MyBatis 是免费且开源的。
- 与 JDBC 相比，减少了 50% 以上的代码量。
- MyBatis 是最简单的持久化框架，小巧并且简单易学。
- MyBatis 相当灵活，不会对应用程序或者数据库的现有设计强加任何影响，SQL 写在 XML 中，和程序逻辑代码分离，降低耦合度，便于同一管理和优化，提高了代码的可重用性。
- 提供 XML 标签，支持编写动态 SQL 语句。
- 提供映射标签，支持对象与数据库的 ORM 字段关系映射。
- 支持存储过程。MyBatis 以存储过程的形式封装 SQL，可以将业务逻辑保留在数据库之外，增强应用程序的可移植性、更易于部署和测试。
- 编写 SQL 语句工作量较大，对开发人员编写 SQL 语句的功底有一定要求。
- SQL 语句依赖于数据库，导致数据库移植性差，不能随意更换数据库。
每个 MyBatis 应用程序都以一个 SqlSessionFactory 对象的实例为核心。首先获取 SqlSessionFactoryBuilder 对象，可以根据 XML 配置文件或者 Configuration 类的实例构建该对象。
然后获取 SqlSessionFactory 对象，该对象实例可以通过 SqlSessionFactoryBuilder 对象来获取。
有了 SqlSessionFactory 对象之后，就可以进而获取 SqlSession 实例。SqlSession 对象中完全包含以数据库为背景的所有执行 SQL 操作的方法，用该实例可以直接执行已映射的 SQL 语句。
该类有多个build()重载方法：
- build(InputStream inputStream, String environment, Properties properties)
- build(Reader reader, String environment, Properties properties)
- build(Configuration config)
通过上述分析，发现配置信息可以以三种形式提供给 SqlSessionFactoryBuilder 的 build() 方法，分别是 InputStream（字节流）、Reader（字符流）、Configuration（类）。
构建一个 SqlSessionFactory 有两种方式 ：
以上 xml 配置文件方式可以通过读取字节流或字符流创建，也可以是编写类的方式创建。
SqlSessionFactoryBuilder的生命周期和作用域
SqlSessionFactoryBuilder 的最大特点就是用过即丢。创建 SqlSessionFactory 对象之后，这个类就不存在了，因此 SqlSessionFactoryBuilder 的最佳范围就是存在于方法体内，也就是局部变量。
SqlSessionFactory 是工厂接口而不是现实类，它的任务就是创建 SqlSession。
所有的 MyBatis 应用都以 SqlSessionFactory 实例为中心，SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 对象来获取。有了它以后，顾名思义，就可以通过 SqlSession 提供的 openSession() 方法来获取 SqlSession 实例。 源码如下：
public interface SqlSessionFactory {
SqlSession openSession();
SqlSession openSession(boolean autoCommit);
SqlSession openSession(Connection connection);
SqlSession openSession(TransactionIsolationLevel level);
SqlSession openSession(ExecutorType execType);
SqlSession openSession(ExecutorType execType, boolean autoCommit);
SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
SqlSession openSession(ExecutorType execType, Connection connection);
Configuration getConfiguration();
}
SqlSessionFactory的生命周期和作用域
SqlSessionFactory 对象一旦创建，就会在整个应用程序过程中始终存在。没有理由去销毁或再创建它，并且在应用程序运行中也不建议多次创建 SqlSessionFactory。因此 SqlSessionFactory 的最佳作用域是 Application，即随着应用程序的生命周期一直存在。这种“存在于整个应用运行期间，并且只存在一个对象实例”的模式就是所谓的单例模式（指在运行期间有且仅有一个实例）。
SqlSession 是用于执行持久化操作的对象，类似于 JDBC 中的 Connection。它提供了面向数据库执行 SQL 命令所需的所有方法，可以通过 SqlSession 实例直接运行已映射的 SQL 语句。
SqlSession 的用途主要有两种：
- 获取映射器。让映射器通过命名空间和方法名称找到对应的 SQL，并发送给数据库，执行后返回结果。
- 直接通过“命名空间（namespace）+SQL id”的方式执行 SQL，不需要获取映射器。这是 iBatis 版本留下的方式。
SqlSession生命周期和作用域
SqlSession 对应一次数据库会话。由于数据库会话不是永久的，因此 SqlSession 的生命周期也不是永久的，每次访问数据库时都需要创建 SqlSession 对象。
需要注意的是：每个线程都有自己的 SqlSession 实例，SqlSession 实例不能被共享，也不是线程安全的。因此 SqlSession 的作用域范围是 request 作用域或方法体作用域内。
MyBatis 配置文件的结构如下 ：
<?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 /><!-- 属性 -->
<settings /><!-- 设置 -->
<typeAliases /><!-- 类型命名 -->
<typeHandlers /><!-- 类型处理器 -->
<objectFactory /><!-- 对象工厂 -->
<plugins /><!-- 插件 -->
<environments><!-- 配置环境 -->
<environment><!-- 环境变量 -->
<transactionManager /><!-- 事务管理器 -->
<dataSource /><!-- 数据源 -->
</environment>
</environments>
<databaseIdProvider /><!-- 数据库厂商标识 -->
<mappers /><!-- 映射器 -->
</configuration>
<!-- mybatis-config.xml 文件中的元素节点是有一定顺序的，节点位置必须按以上位置排序，否则会编译错误。 -->
properties 标签可以通过 resource 属性指定外部 properties 文件（database.properties），也可以通过 properties 子元素配置。
1.指定文件
<properties resource="mybatisDemo/resources/database.properties"/>
database.properties 用于描述数据库连接的相关配置，例如数据库驱动、连接数据库的 url、数据库用户名、数据库密码等。
2.properties子元素配置
通过 properties 子元素 property 配置 username 和 password 变量，然后在 environments 节点中引用这些变量，代码如下:
<properties>
<property name="username" value="root"/>
<property name="password" value="root"/>
</properties>
在 environments 节点中引用 username 和 password 变量：
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
也可以不使用 properties 标签，直接将属性值写在 value 中。
settings 标签用于配置 MyBatis 的运行时行为，它能深刻的影响 MyBatis 的底层运行，一般不需要大量配置，大部分情况下使用其默认值即可。
settings 的配置项很多，但是真正用到的不会太多。settings 配置项说明如下表所示（表中加粗的配置项为常用配置项）。
| 配置项 |
作用 |
配置选项 |
默认值 |
| cacheEnabled |
该配置影响所有映射器中配置缓存的全局开关 |
true|false |
true |
| lazyLoadingEnabled |
延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。在特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态 |
true|false |
false |
| aggressiveLazyLoading |
当启用时，对任意延迟属性的调用会使带有延迟加载属性的对象完整加载；反之，每种属性将会按需加载 |
true|false |
版本3.4.1 （不包含） 之前默认值为 true，之后为 false |
| multipleResultSetsEnabled |
是否允许单一语句返回多结果集（需要兼容驱动） |
true|false |
true |
| useColumnLabel |
使用列标签代替列名。不同的驱动会有不同的表现，具体可参考相关驱动文档或通过测试这两种不同的模式来观察所用驱动的结果 |
true|false |
true |
| useGeneratedKeys |
允许JDBC 支持自动生成主键，需要驱动兼容。如果设置为 true，则这个设置强制使用自动生成主键，尽管一些驱动不能兼容但仍可正常工作（比如 Derby） |
true|false |
false |
| autoMappingBehavior |
指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示取消自动映射。 PARTIAL 表示只会自动映射，没有定义嵌套结果集和映射结果集。 FULL 会自动映射任意复杂的结果集（无论是否嵌套） |
NONE、PARTIAL、FULL |
PARTIAL |
| autoMappingUnkno wnColumnBehavior |
指定自动映射当中未知列（或未知属性类型）时的行为。 默认是不处理，只有当日志级别达到 WARN 级别或者以下，才会显示相关日志，如果处理失败会抛出 SqlSessionException 异常 |
NONE、WARNING、FAILING |
NONE |
| defaultExecutorType |
配置默认的执行器。SIMPLE 是普通的执行器；REUSE 会重用预处理语句（prepared statements）；BATCH 执行器将重用语句并执行批量更新 |
SIMPLE、REUSE、BATCH |
SIMPLE |
| defaultStatementTimeout |
设置超时时间，它决定驱动等待数据库响应的秒数 |
任何正整数 |
Not Set (null) |
| defaultFetchSize |
设置数据库驱动程序默认返回的条数限制，此参数可以重新设置 |
任何正整数 |
Not Set (null) |
| safeRowBoundsEnabled |
允许在嵌套语句中使用分页（RowBounds）。如果允许，设置 false |
true|false |
false |
| safeResultHandlerEnabled |
允许在嵌套语句中使用分页（ResultHandler）。如果允许，设置false |
true|false |
true |
| mapUnderscoreToCamelCase |
是否开启自动驼峰命名规则映射，即从经典数据库列名 A_COLUMN 到经典 Java 属性名 aColumn 的类似映射 |
true|false |
false |
| localCacheScope |
MyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速联复嵌套査询。 默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlScssion 的不同调用将不会共享数据 |
SESSION|STATEMENT |
SESSION |
| jdbcTypeForNull |
当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。某些驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER |
NULL、VARCHAR、OTHER |
OTHER |
| lazyLoadTriggerMethods |
指定哪个对象的方法触发一次延迟加载 |
— |
equals、clone、hashCode、toString |
| defaultScriptingLanguage |
指定动态 SQL 生成的默认语言 |
— |
org.apache.ibatis .script.ing.xmltags .XMLDynamicLanguageDriver |
| callSettersOnNulls |
指定当结果集中值为 null 时，是否调用映射对象的 setter（map 对象时为 put）方法，这对于 Map.kcySet() 依赖或 null 值初始化时是有用的。注意，基本类型（int、boolean 等）不能设置成 null |
true|false |
false |
| logPrefix |
指定 MyBatis 增加到日志名称的前缀 |
任何字符串 |
Not set |
| loglmpl |
指定 MyBatis 所用日志的具体实现，未指定时将自动査找 |
SLF4J|LOG4J|LOG4J2|JDK_LOGGING |COMMONS_LOGGING |ST DOUT_LOGGING|NO_LOGGING |
Not set |
| proxyFactory |
指定 MyBatis 创建具有延迟加栽能力的对象所用到的代理工具 |
CGLIB|JAVASSIST |
JAVASSIST （MyBatis 版本为 3.3 及以上的） |
| vfsImpl |
指定 VFS 的实现类 |
提供 VFS 类的全限定名，如果存在多个，可以使用逗号分隔 |
Not set |
| useActualParamName |
允许用方法参数中声明的实际名称引用参数。要使用此功能，项目必须被编译为 Java 8 参数的选择。（从版本 3.4.1 开始可以使用） |
true|false |
true |
为了不在任何地方都指定类的全限定名，我们可以使用 typeAliases 标签定义一个别名。
例如，在 net.bianchengbang.po 包中有一个 Student 类，则该类的全限定名称为 net.bianchengbang.po.Student。使用 typeAliases 标签定义别名，这样就不用每次都书写类的全限定名称了，代码如下：
<typeAliases>
<typeAlias alias = "Student" type = "net.bianchengbang.po.Student"/>
</typeAliases>
如果需要对同一个包下的多个类定义别名，则可以定义为：
<typeAliases>
<package name="net.biancheng.po"/>
</typeAliases>
这样 MyBatis 将扫描 net.biancheng.po 包里面的类，将其第一个字母变为小写作为其别名，例如 Student 别名为 student，User 别名为 user。
typeHandlers 主要将获取的值合理地转化为 Java 类型。在 typeHandler 中，分为 jdbcType 和 javaType，其中 jdbcType 用于定义数据库类型，而 javaType 用于定义 Java 类型，typeHandler 的作用就是承担 jdbcType 和 javaType 之间的相互转换。
MyBatis 支持自定义处理类型，在自定义处理类型时，需要实现 org.apache.ibatis.type.TypeHandler 接口或继承 org.apache.ibatis.type.BaseTypeHandle 类。
在 environments 标签中，可以配置 MyBatis 的多套运行环境，将 SQL 映射到多个不同的数据库上。
environment 是 environments 的子标签，用来配置 MyBatis 的一套运行环境，需指定运行环境 ID、事务管理、数据源配置等相关信息。
可以通过配置多个 environment 标签来连接多个数据库，需要注意的是必须指定其中一个为默认运行环境（通过default指定）。
environment 标签提供了两个子标签，即 transactionManager 和 dataSource。
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
mappers 标签用于指定 MyBatis SQL 映射文件的路径。
mapper 是 mappers 的子标签，mapper 中的 resource 属性用于指定 SQL 映射文件的路径（类资源路径）
例如，SQL 映射文件的名称是 Student.xml，它位于名为 net.biancheng.mapper 的包中，那么可以这样配置：
<mappers>
<mapper resource="net/biancheng/mapper/Student.xml"/>
</mappers>
映射器是 MyBatis 中最重要的文件，文件中包含一组 SQL 语句（例如查询、添加、删除、修改），这些语句称为映射语句或映射 SQL 语句。
映射器由 Java 接口和 XML 文件（或注解）共同组成，它的作用如下：
- 定义参数类型
- 配置缓存
- 提供 SQL 语句和动态 SQL
- 定义查询结果和 POJO 的映射关系
映射器有以下两种实现方式。
-
通过 XML 文件方式实现，比如我们在 mybatis-config.xml 文件中描述的 XML 文件，用来生成 mapper。
-
通过注解的方式实现，使用 Configuration 对象注册 Mapper 接口。
如果 SQL 语句存在动态 SQL 或者比较复杂，使用注解写在 Java 文件里可读性差，且增加了维护的成本。所以一般建议使用 XML 文件配置的方式，避免重复编写 SQL 语句。
XML 定义映射器分为两个部分：接口和XML。
定义接口 WebsiteMapper ：
package net.biancheng.mapper;
import java.util.List;
import net.biancheng.po.Website;
public interface WebsiteMapper {
public List<Website> selectAllWebsite();
}
WebsiteMapper.xml 代码：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="net.biancheng.mapper.WebsiteMapper">
<!-- 查询所有网站信息 -->
<select id="selectAllWebsite"
resultType="net.biancheng.po.Website">
select * from website
</select>
</mapper>
下面对上述 XML 文件进行讲解。
在 MyBatis 配置文件中添加以下代码 :
<mapper resource="net/biancheng/mapper/WebsiteMapper.xml" />
该语句用来引入 XML 文件，MyBatis 会读取 WebsiteMapper.xml 文件，生成映射器。
使用注解的方式实现映射器，只需要在接口中使用 Java 注解，注入 SQL 即可。如下所示 ：
package net.biancheng.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Select;
import net.biancheng.po.Website;
public interface WebsiteMapper2 {
@Select(value = "select * from website")
public List<Website> selectAllWebsite();
}
这里使用了 @Select 注解，并且注入了和 XML 中相同的 select 语句。
注意： 如果使用注解和 XML 文件两种方式同时定义，那么 XML 方式将覆盖掉注解方式。
虽然这里注解的方式看起来比 XML 简单，但是现实中我们遇到的 SQL 会比该例子复杂得多。如果 SQL 语句中有多个表的关联、多个查询条件、级联、条件分支等，显然这条 SQL 就会复杂的多。
此外，XML 可以相互引入，而注解是不可以的，所以在一些比较复杂的场景下，使用 XML 方式会更加灵活和方便。因此大部分的企业都以 XML 为主，本教程也会保持一致，以 XML 方式来创建映射器。当然在一些简单的表和应用中使用注解方式也会比较简单。
在 MyBatis 配置文件中添加以下代码 :
<mapper resource="com/mybatis/mapper/WebsiteMapper2" />
MyBatis 映射器的主要元素
| 元素名称 |
描述 |
备注 |
| mapper |
映射文件的根节点，只有 namescape 一个属性 |
namescape 作用如下：用于区分不同的 mapper，全局唯一绑定DAO接口，即面向接口编程。当 namescape 绑定某一接口后，可以不用写该接口的实现类，MyBatis 会通过接口的完整限定名查找到对应的 mapper 配置来执行 SQL 语句。因此 namescape 的命名必须要跟接口同名。 |
| select |
查询语句，最常用、最复杂的元素之一 |
可以自定义参数，返回结果集等 |
| insert |
插入语句 |
执行后返回一个整数，代表插入的条数 |
| update |
更新语句 |
执行后返回一个整数，代表更新的条数 |
| delete |
删除语句 |
执行后返回一个整数，代表删除的条数 |
| parameterMap |
定义参数映射关系 |
即将被删除的元素，不建议使用 |
| sql |
允许定义一部分的 SQL，然后在各个地方引用它 |
例如，一张表列名，我们可以一次定义，在多个 SQL 语句中使用 |
| resultMap |
用来描述数据库结果集与对象的对应关系，它是最复杂、最强大的元素 |
提供映射规则 |
| cache |
配置给定命名空间的缓存 |
– |
| cache-ref |
其它命名空间缓存配置的引用 |
– |
在 MyBatis 中，select 标签是最常用也是功能最强大的 SQL 语言，用于执行查询操作 。
执行 SQL 语句时可以定义参数，参数可以是一个简单的参数类型，例如 int、float、String；也可以是一个复杂的参数类型，例如 JavaBean、Map 等。MyBatis 提供了强大的映射规则，执行 SQL 后，MyBatis 会将结果集自动映射到 JavaBean 中 。
为了使数据库的查询结果和返回值类型中的属性能够自动匹配，通常会对 MySQL 数据库和 JavaBean 采用同一套命名规则，即 Java 命名驼峰规则，这样就不需要再做映射了（数据库表字段名和属性名不一致时需要手动映射）。
常用属性：
| 属性名称 |
描 述 |
备注 |
| id |
它和 Mapper 的命名空间组合起来使用，是唯一标识符，供 MyBatis 调用 |
如果命名空间+id不唯一，那么 MyBatis 抛出异常 |
| parameterType |
表示传入 SQL 语句传入参数类型的全限定名或别名。它是一个可选属性，MyBatis 能推断出具体传入语句的参数 |
支持基本数据类型和 JavaBean、Map 等复杂数据类型 |
| resultType |
SQL 语句执行后返回的类型（全限定名或者别名）。如果是集合类型，返回的是集合元素的类型，返回时可以使用 resultType 或 resultMap 之一 |
– |
| resultMap |
它是映射集的引用，与 元素一起使用，返回时可以使用 resultType 或 resultMap 之一
|
是 MyBatis 最复杂的元素，可以配置映射规则、级联、typeHandler 等 |
| flushCache |
用于设置在调用 SQL 语句后是否要求 MyBatis 清空之前查询的本地缓存和二级缓存 |
默认值为 false，如果设置为 true，则任何时候只要 SQL 语句被调用都将清空本地缓存和二级缓存 |
| useCache |
启动二级缓存的开关，默认值为 true，表示将査询结果存入二级缓存中 |
– |
| timeout |
用于设置超时参数，单位是秒（s），超时将抛出异常 |
– |
| fetchSize |
获取记录的总条数设定 |
默认值是数据库厂商提供的 JDBC 驱动所设置的条数 |
| statementType |
告诉 MyBatis 使用哪个 JDBC 的 Statement 工作，取值为 STATEMENT（Statement）、 PREPARED（PreparedStatement）、CALLABLE（CallableStatement） |
– |
| resultSetType |
这是针对 JDBC 的 ResultSet 接口而言，其值可设置为 FORWARD_ONLY（只允许向前访问）、SCROLL_SENSITIVE（双向滚动，但不及时更新）、SCROLLJNSENSITIVE（双向滚动，及时更新） |
– |
传递多个参数
现在需要根据 id 和 name 来模糊查询网站信息，显然这涉及到了两个参数。给映射器传递多个参数分为以下三种方法。
-
使用Map传递参数
-
使用注解传递参数
-
使用JavaBean传递参数
1 使用 Map 传递参数
使用 MyBatis 提供的 Map 接口作为参数实现，如下所示 ：
<!-- 根据name和url模糊查询网站信息 -->
<select id="selectWebsiteByMap" resultType="net.biancheng.po.Website" parameterType="map">
SELECT id,NAME,url FROM website
WHERE name LIKE CONCAT ('%',#{name},'%')
AND url LIKE CONCAT ('%',#{url},'%')
</select>
在 WebsiteMapper 接口中，方法如下
public List<Website> selectWebsiteByMap(Map<String, String> params);
测试代码如下 :
Map<String,String> paramsMap = new HashMap<String,String>();
paramsMap.put("name","编程");
paramsMap.put("url","biancheng");
websiteMapper.selectWebsiteByMap(paramsMap);
2 使用注解传递参数
使用 MyBatis 的注解 @Param() 传递参数，如下所示：
<!-- 根据name和url模糊查询网站信息 -->
<select id="selectWebsiteByAn" resultType="net.biancheng.po.Website">
SELECT id,NAME,url FROM website
WHERE name LIKE CONCAT ('%',#{name},'%')
AND url LIKE CONCAT ('%',#{url},'%')
</select>
WebsiteMapper 接口中方法如下：
public List<Website> selectWebsiteByAn(@Param("name") String name, @Param("url") String url);
当我们把参数传递给后台时，MyBatis 通过 @Param 提供的名称就会知道 #{name} 代表 name 参数，提高了参数可读性。但是如果这条 SQL 拥有 10 个参数的查询，就会造成可读性下降，增强了代码复杂性。
3 使用JavaBean传递参数
在参数过多的情况下，MyBatis 允许组织一个 JavaBean，通过简单的 setter 和 getter 方法设置参数，提高可读性。如下所示 ：
<!-- 根据name和url模糊查询网站信息 -->
<select id="selectWebsiteByAn" resultType="net.biancheng.po.Website">
SELECT id,NAME,url FROM website
WHERE name LIKE CONCAT ('%',#{name},'%')
AND url LIKE CONCAT ('%',#{url},'%')
</select>
WebsiteMapper 接口中方法如下：
public List<Website> selectWebsiteByAn(Website website);
以上 3 种方式的区别如下：
- 使用 Map 传递参数会导致业务可读性的丧失，继而导致后续扩展和维护的困难，所以在实际应用中我们应该果断废弃该方式。
- 使用 @Param 注解传递参数会受到参数个数的影响。当 n≤5 时，它是最佳的传参方式，因为它更加直观；当 n>5 时，多个参数将给调用带来困难。
- 当参数个数大于 5 个时，建议使用 JavaBean 方式。
MyBatis insert 标签用来定义插入语句，执行插入操作。当 MyBatis 执行完一条插入语句后，就会返回其影响数据库的行数。
常用属性：
| 属性名称 |
描述 |
备注 |
| id |
它和 Mapper 的命名空间组合起来使用，是唯一标识符，供 MyBatis 调用 |
如果命名空间+ id 不唯一，那么 MyBatis 抛出异常 |
| parameterType |
传入 SQL 语句的参数类型的全限定名或别名，它是一个可选属性。 |
支持基本数据类型和 JavaBean、Map 等复杂数据类型 |
| keyProperty |
该属性的作用是将插入操作的返回值赋给 PO 类的某个属性，通常为主键对应的属性。如果是联合主键，可以将多个值用逗号隔开。 |
– |
| useGeneratedKey |
该属性用来设置，是否使用 JDBC 提供的 getGenereatedKeys() 方法，获取数据库内部产生的主键并赋值到 keyProperty 属性设置的请求对象的属性中，例如 MySQL、SQL Server 等自动递增的字段，其默认值为 false。 |
该属性值设置为 true 后，会将数据库生成的主键回填到请求对象中，以供其他业务使用。 |
| flushCache |
该属性用于设置执行该操作后，是否会清空二级缓存和本地缓存，默认值为 true。 |
– |
| timeout |
该属性用于设置执行该操作的最大时限，如果超时，就抛异常。 |
– |
| databaseId |
取值范围 oracle、mysql 等，表示数据库厂家；元素内部可通过 来为特定数据库指定不同的 sql 语句。
|
MyBatis 可以根据不同的数据库厂商执行不同的语句，这种多厂商的支持是基于映射语句中的 databaseId 属性。 MyBatis 会加载不带 databaseId 属性和带有匹配当前数据库 databaseId 属性的所有语句。 如果同时找到带有 databaseId 和不带 databaseId 的相同语句，则后者会被舍弃。 |
| keyColumn |
该属性用于设置第几列是主键，当主键列不是表中的第 1 列时，就需要设置该属性。如果是联合主键，可以将多个值用逗号隔开。 |
– |
注意：insert 标签中没有 resultType 属性，只有查询操作才需要对返回结果类型进行相应的指定。
传递多个参数
在实际的开发过程中，我们的插入语句往往需要使用多个参数，Mybatis 为我们提供以下 3 种方式，来实现给映射器传递多个参数：
- 使用 Map 传递参数
- 使用注解传递参数
- 使用 JavaBean 传递参数
1 使用 Map 传递参数java
可以将参数封装到一个 Map 对象中，然后传递给 MyBatis 的映射器。在 WebsiteMapper 接口中，定义一个 addWebsiteByMap() 方法，并使用 Map 传递参数，方法如下 ：
int addWebsiteByMap(Map<String, String> params);
在 WebsiteMapper.xml 中，使用 insert 标签定义一条插入语句，并接收通过 Map 传递的参数，配置如下 ：
<!--接收 Map 参数-->
<insert id="addWebsiteByMap" parameterType="map">
insert into Website (name, url) values (#{name}, #{url})
</insert>
测试代码如下 :
Map<String, String> params = new HashMap<>();
params.put("name", "编程帮");
params.put("url", "https://www.biancheng.net/");
int i = websiteMapper.addWebsiteByMap(params);
System.out.println("通过 Map 成功向数据库中添加了 " + i + " 条记录");
2 使用注解传递参数
还可以使用 MyBatis 提供的 @Param 注解给注解器传递参数， 在 WebsiteMapper 接口中，定义一个 addWebsiteByParam() 方法，并使用 @Param 注解传递参数，方法如下 ：
int addWebsiteByParam(@Param("name") String name, @Param("url") String url);
在 WebsiteMapper.xml 使用 insert 标签定义一条插入语句，并接收通过 @Param 注解传递的参数，配置如下 ：
<!--接收 @Param 注解传递的参数-->
<insert id="addWebsiteByParam">
insert into Website (name, url) values (#{name}, #{url})
</insert>
3 使用JavaBean传递参数
在参数过多的情况下，我们可以将参数通过 setter 方法封装到 JavaBean（实体类）对象中 ，传递给映射器 。 在 WebsiteMapper 接口中,定义一个 addWebsiteByJavaBean() 方法，并使用 JavaBean 传递参数 ，如下所示 ：
int addWebsiteByJavaBean(Website website);
在 WebsiteMapper.xml 中使用 insert 标签定义一条插入语句，并接收通过 JavaBean 传递的参数，配置如下 ：
<!--接收通过 JavaBean 传递的参数-->
<insert id="addWebsiteByJavaBean" parameterType="net.biancheng.www.po.Website">
insert into Website (name, url) values (#{name}, #{url})
</insert>
以上 3 种方式的区别如下：
- 使用 Map 传递参数会导致业务可读性的丧失，继而导致后续扩展和维护的困难，所以在实际应用中我们应该果断废弃该方式。
- 使用 @Param 注解传递参数会受到参数个数的影响。当 n≤5 时，它是最佳的传参方式，因为它更加直观；当 n>5 时，多个参数将给调用带来困难。
- 当参数个数大于 5 个时，建议使用 JavaBean 方式。
MyBatis update 标签用于定义更新语句，执行更新操作。当 MyBatis 执行完一条更新语句后，会返回一个整数，表示受影响的数据库记录的行数。
常用属性：
| 属性名称 |
描述 |
备注 |
| id |
它和 Mapper 的命名空间组合起来使用，是唯一标识符，供 MyBatis 调用 |
如果命名空间+ id 不唯一，那么 MyBatis 抛出异常 |
| parameterType |
传入 SQL 语句的参数类型的全限定名或别名，它是一个可选属性。 |
支持基本数据类型和 JavaBean、Map 等复杂数据类型 |
| flushCache |
该属性用于设置执行该操作后，是否会清空二级缓存和本地缓存，默认值为 true。 |
– |
| timeout |
该属性用于设置 SQL 执行的超时时间，如果超时，就抛异常。 |
– |
| statementType |
执行 SQL 时使用的 statement 类型, 默认为 PREPARED，可选值：STATEMENT，PREPARED 和 CALLABLE。 |
– |
MyBatis delete 标签用于定义 delete 语句，执行删除操作。当 MyBatis 执行完一条更新语句后，会返回一个整数，表示受影响的数据库记录的行数 。
常用属性：
| 属性名称 |
描述 |
备注 |
| id |
它和 Mapper 的命名空间组合起来使用，是唯一标识符，供 MyBatis 调用 |
如果命名空间+ id 不唯一，那么 MyBatis 抛出异常 |
| parameterType |
传入 SQL 语句的参数类型的全限定名或别名，它是一个可选属性。 |
支持基本数据类型和 JavaBean、Map 等复杂数据类型 |
| flushCache |
该属性用于设置执行该操作后，是否会清空二级缓存和本地缓存，默认值为 true。 |
– |
| timeout |
该属性用于设置 SQL 执行的超时时间，如果超时，就抛异常。 |
– |
| statementType |
执行 SQL 时使用的 statement 类型, 默认为 PREPARED，可选值：STATEMENT，PREPARED 和 CALLABLE。 |
– |
resultMap 是 MyBatis 中最复杂的元素，主要用于解决实体类属性名与数据库表中字段名不一致的情况，可以将查询结果映射成实体对象。
现有的 MyBatis 版本只支持 resultMap 查询，不支持更新或者保存，更不必说级联的更新、删除和修改。
resultMap 元素还可以包含以下子元素，代码如下：
<resultMap id="" type="">
<constructor><!-- 类再实例化时用来注入结果到构造方法 -->
<idArg/><!-- ID参数，结果为ID -->
<arg/><!-- 注入到构造方法的一个普通结果 -->
</constructor>
<id/><!-- 用于表示哪个列是主键 -->
<result/><!-- 注入到字段或JavaBean属性的普通结果 -->
<association property=""/><!-- 用于一对一关联 -->
<collection property=""/><!-- 用于一对多、多对多关联 -->
<discriminator javaType=""><!-- 使用结果值来决定使用哪个结果映射 -->
<case value=""/><!-- 基于某些值的结果映射 -->
</discriminator>
</resultMap>
其中：
-
元素的 type 属性表示需要的 POJO，id 属性是 resultMap 的唯一标识。
- 子元素 用于配置构造方法。当一个 POJO 没有无参数构造方法时使用。
- 子元素 用于表示哪个列是主键。允许多个主键，多个主键称为联合主键。
- 子元素 用于表示 POJO 和 SQL 列名的映射关系。
- 子元素 、 和 用在级联的情况下。
id 和 result 元素都有以下属性 ：
| 元素 |
说明 |
| property |
映射到列结果的字段或属性。如果 POJO 的属性和 SQL 列名（column元素）是相同的，那么 MyBatis 就会映射到 POJO 上 |
| column |
对应 SQL 列 |
| javaType |
配置 Java 类型。可以是特定的类完全限定名或 MyBatis 上下文的别名 |
| jdbcType |
配置数据库类型。这是 JDBC 类型，MyBatis 已经为我们做了限定，基本支持所有常用数据库类型 |
| typeHandler |
类型处理器。允许你用特定的处理器来覆盖 MyBatis 默认的处理器。需要指定 jdbcType 和 javaType 相互转化的规则 |
一条 SQL 查询语句执行后会返回结果集，结果集有两种存储方式，即使用 Map 存储和使用 POJO 存储 。
任何 select 语句都可以使用 Map 存储，代码如下：
<!-- 查询所有网站信息存到Map中 -->
<select id="selectAllWebsite" resultType="map">
select * from website
</select>
在 WebsiteMapper 接口中添加以下方法：
public List<Map<String,Object>> selectAllWebsite();
Map 的 key 是 select 语句查询的字段名（必须完全一样），而 Map 的 value 是查询返回结果中字段对应的值，一条记录映射到一个 Map 对象中。
使用 Map 存储结果集很方便，但可读性稍差，所以一般推荐使用 POJO 的方式。
因为 MyBatis 提供了自动映射，所以使用 POJO 存储结果集是最常用的方式。但有时候需要更加复杂的映射或级联，这时就需要使用 select 元素的 resultMap 属性配置映射集合。
package net.biancheng.po;
import java.util.Date;
public class Website {
private int id;
private String uname;
private String url;
private int age;
private String country;
private Date createtime;
/* setter和getter方法*/
@Override
public String toString() {
return "Website[id=" + id + ",uname=" + uname + ",url=" + url + ",age=" + age + ",country=" + country
+ ",createtime=" + createtime + "]";
}
}
WebsiteMapper.xml 代码如下：
<!--使用自定义结果集类型 -->
<resultMap type="net.biancheng.po.Website" id="myResult">
<!-- property 是 net.biancheng.po.Website 类中的属性 -->
<!-- column是查询结果的列名，可以来自不同的表 -->
<id property="id" column="id" />
<result property="uname" column="name" />
</resultMap>
resultMap 元素的属性 id 代表这个 resultMap 的标识，type 标识需要映射的 POJO。我们可以使用 MyBatis 定义好的类的别名或自定义类的全限定名。
这里使用 property 元素指定 Website 的属性名称 uname，column 表示数据库中 website 表的 SQL 列名 name，将 POJO 和 SQL 的查询结果一 一对应。
WebsiteMapper.xml 中 select 元素配置代码如下：
<select id="selectAllWebsite" resultMap="myResult">
select id,name,url from website
</select>
可以发现 SQL 语句的列名和 myResult 中的 column 一一对应。
MyBatis 的每一个查询映射的返回类型都是 resultMap，只是当我们提供的返回类型是 resultType 时，MyBatis 会自动把对应的值赋给 resultType 所指定对象的属性，而当我们提供的返回类型是 resultMap 时，MyBatis 会将数据库中的列数据复制到对象的相应属性上，可用于复制查询。
需要注意的是，resultMap 和 resultType 不能同时使用。
@Insert("insert into user(id,name) values(#{id},#{name})")
public int insert(User user);
@Select("Select * from user")
List<User> queryAllUser();
以 MySQL 为例，MySQL 在插入一条数据后，使用 select last_insert_id() 可以获取到自增 id 的值
@Insert("insert into user(id,name) values(#{id},#{name})")
@SelectKey(statement = "select last_insert_id()", keyProperty = "id", keyColumn = "id", resultType = int,before = false)
public int insert(User user);
@SelectKey 各个属性含义如下：
- statement：表示要运行的 SQL 语句；
- keyProperty：可选项，表示将查询结果赋值给代码中的哪个对象；
- keyColumn：可选项，表示将查询结果赋值给数据表中的哪一列；
- resultType：指定 SQL 语句的返回值；
- before：默认值为 true，在执行插入语句之前，执行 select last_insert_id()。值为 flase，则在执行插入语句之后，执行 select last_insert_id()。
@Update("update user set name= #{name},sex = #{sex},age =#{age} where id = #{id}")
void updateUserById(User user);
@Delete("delete from user where id =#{id}")
void deleteById(Integer id);
@Param 用于在 Mapper 接口中映射多个参数
int saveUser(@Param(value="user") User user,@Param("name") String name,@Param("age") Int age);
@Param 中的 value 属性可省略，用于指定参数的别名
@Result、@Results、@ResultMap 是结果集映射的三大注解
声明结果集映射关系代码：
@Select({"select id, name, class_id from student"})
@Results(id="studentMap", value={
@Result(column="id", property="id", jdbcType=JdbcType.INTEGER, id=true),
@Result(column="name", property="name", jdbcType=JdbcType.VARCHAR),
@Result(column="class_id ", property="classId", jdbcType=JdbcType.INTEGER)
})
List<Student> selectAll();
下面为 @Results 各个属性的含义：
- id：表示当前结果集声明的唯一标识；
- value：表示结果集映射关系；
- @Result：代表一个字段的映射关系。其中，column 指定数据库字段的名称，property 指定实体类属性的名称，jdbcType 数据库字段类型，id 为 true 表示主键，默认 false。
可使用 @ResultMap 来引用映射结果集，其中 value 可省略：
@Select({"select id, name, class_id from student where id = #{id}"})
@ResultMap(value="studentMap")
Student selectById(Integer id);
@Select("select * from student")
@Results({
@Result(id=true,property="id",column="id"),
@Result(property="name",column="name"),
@Result(property="age",column="age"),
@Result(property="address",column="address_id",one=@One(select="net.biancheng.mapper.AddressMapper.getAddress"))
})
public List<Student> getAllStudents();
@Select("select * from t_class where id=#{id}")
@Results({
@Result(id=true,column="id",property="id"),
@Result(column="class_name",property="className"),
@Result(property="students", column="id", many=@Many(select="net.biancheng.mapper.StudentMapper.getStudentsByClassId"))
})
public Class getClass(int id);
级联关系是一个数据库实体的概念，有 3 种级联关系，分别是一对一级联、一对多级联以及多对多级联。
在级联中存在 3 种对应关系。
-
一对一的关系。每个软件工程师都有一个编号（ID），这是他在公司的标识，它与工程师是一对一的关系。
-
一对多的关系，如角色和用户的关系。通俗的理解就是，一家软件公司会存在许多软件工程师，公司和软件工程师就是一对多的关系。
-
多对多的关系，有些公司一个角色可以对应多个用户，但是一个用户可以兼任多个角色。通俗的说，一个人既可以是总经理，同时也是技术总监，而技术总监这个职位可以对应多个人，这就是多对多的关系。
级联的优点是获取关联数据十分便捷。但是级联过多会增加系统的复杂度，同时降低系统的性能，此增彼减。所以记录超过 3 层时，就不要考虑使用级联了，因为这样会造成多个对象的关联，导致系统的耦合、负载和难以维护。
一对一级联关系在现实生活中是十分常见的，例如一个大学生只有一个学号，一个学号只属于一个学生。同样，人与身份证也是一对一的级联关系。
在 MyBatis 中，通过 元素的子元素 处理一对一级联关系。示例代码如下 ：
<association property="studentCard" column="cardId"
javaType="net.biancheng.po.StudentCard"
select="net.biancheng.mapper.StudentCardMapper.selectStuCardById" />
在 元素中通常使用以下属性：
- property：指定映射到实体类的对象属性
- column：指定表中对应的字段（即查询返回的列名）
- javaType：指定映射到实体对象属性的类型
- select：指定引入嵌套查询的子 SQL 语句，该属性用于关联映射中的嵌套查询
一对一关联查询可采用以下两种方式：
- 单步查询，通过关联查询实现
- 分步查询，通过两次或多次查询，为一对一关系的实体 Bean 赋值
示例：
创建数据表
创建 student（学生）和 studentcard（学号）数据表，SQL 语句如下：
CREATE TABLE `student` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(20) CHARACTER SET utf8 COLLATE utf8_unicode_ci DEFAULT NULL,
`sex` tinyint(4) DEFAULT NULL,
`cardId` int(20) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `cardId` (`cardId`),
CONSTRAINT `student_ibfk_1` FOREIGN KEY (`cardId`) REFERENCES `studentcard` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
insert into `student`(`id`,`name`,`sex`,`cardId`) values (1,'C语言中文网',0,1),(2,'编程帮',0,2),(3,'赵小红',1,3),(4,'李晓明',0,4),(5,'李紫薇',1,5),(6,'钱百百',0,NULL);
DROP TABLE IF EXISTS `studentcard`;
CREATE TABLE `studentcard` (
`id` int(20) NOT NULL AUTO_INCREMENT,
`studentId` int(20) DEFAULT NULL,
`startDate` date DEFAULT NULL,
`endDate` date DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `studentId` (`studentId`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;
insert into `studentcard`(`id`,`studentId`,`startDate`,`endDate`) values (1,20200311,'2021-03-01','2021-03-11'),(2,20200314,'2021-03-01','2021-03-11'),(3,20200709,'2021-03-01','2021-03-11'),(4,20200508,'2021-03-01','2021-03-11'),(5,20207820,'2021-03-01','2021-03-11');
创建持久化类
在 myBatisDemo 应用的 net.biancheng.po 包下创建数据表对应的持久化类 Student 和 StudentCard
Student 的代码如下：
package net.biancheng.po;
public class Student {
private int id;
private String name;
private int sex;
private StudentCard studentCard;
/*省略setter和getter方法*/
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", sex=" + sex + ", studentCard=" + studentCard + "]";
}
}
StudentCard 的代码如下：
package net.biancheng.po;
import java.util.Date;
public class StudentCard {
private int id;
private int studentId;
private Date startDate;
private Date endDate;
/*省略setter和getter方法*/
@Override
public String toString() {
return "StudentCard [id=" + id + ", studentId=" + studentId + "]";
}
}
分步查询：
新建 StudentCardMapper 类，代码如下 ：
package net.biancheng.mapper;
import net.biancheng.po.StudentCard;
public interface StudentCardMapper {
public StudentCard selectStuCardById(int id);
}
StudentCardMapper.xml 对应映射 SQL 语句代码如下 ：
<mapper namespace="net.biancheng.mapper.StudentCardMapper">
<select id="selectStuCardById"
resultType="net.biancheng.po.StudentCard">
SELECT * FROM studentCard WHERE id = #{id}
</select>
</mapper>
StudentMapper 类方法代码如下 ：
package net.biancheng.mapper;
import net.biancheng.po.Student;
public interface StudentMapper {
public Student selectStuById1(int id);
public Student selectStuById2(int id);
}
StudentMapper.xml 代码如下：
<mapper namespace="net.biancheng.mapper.StudentMapper">
<!-- 一对一根据id查询学生信息：级联查询的第一种方法（嵌套查询，执行两个SQL语句） -->
<resultMap type="net.biancheng.po.Student" id="cardAndStu1">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="sex" column="sex" />
<!-- 一对一级联查询 -->
<association property="studentCard" column="cardId"
javaType="net.biancheng.po.StudentCard"
select="net.biancheng.mapper.StudentCardMapper.selectStuCardById" />
</resultMap>
<select id="selectStuById1" parameterType="Integer"
resultMap="cardAndStu1">
select * from student where id=#{id}
</select>
</mapper>
单步查询：
在 StudentMapper.xml 中添加以下代码：
<resultMap type="net.biancheng.po.Student" id="cardAndStu2">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="sex" column="sex" />
<!-- 一对一级联查询 -->
<association property="studentCard"
javaType="net.biancheng.po.StudentCard">
<id property="id" column="id" />
<result property="studentId" column="studentId" />
</association>
</resultMap>
<select id="selectStuById2" parameterType="Integer"
resultMap="cardAndStu2">
SELECT s.*,sc.studentId FROM student s,studentCard sc
WHERE
s.cardId = sc.id AND s.id=#{id}
</select>
在 StudentMapper 中添加以下方法：
public Student selectStuById2(int id);
在实际生活中也有许多一对多级联关系，例如一个用户可以有多个订单，而一个订单只属于一个用户。同样，国家和城市也属于一对多级联关系。
在 MyBatis 中，通过 元素的子元素 处理一对多级联关系，collection 可以将关联查询的多条记录映射到一个 list 集合属性中。示例代码如下：
<collection property="orderList"
ofType="net.biancheng.po.Order" column="id"
select="net.biancheng.mapper.OrderMapper.selectOrderById" />
在 元素中通常使用以下属性：
- property：指定映射到实体类的对象属性
- column：指定表中对应的字段（即查询返回的列名）
- ofType：指定映射到实体对象属性的类型
- select：指定引入嵌套查询的子 SQL 语句，该属性用于关联映射中的嵌套查询
一对多关联查询可采用以下两种方式：
- 分步查询，通过两次或多次查询，为一对多关系的实体 Bean 赋值
- 单步查询，通过关联查询实现
示例
1）创建数据表
本实例需要两张数据表，一张是用户表 user，一张是订单表 order，这两张表具有一对多的级联关系。SQL 语句如下：
CREATE TABLE `order` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`ordernum` int(25) DEFAULT NULL,
`userId` int(11) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `userId` (`userId`),
CONSTRAINT `order_ibfk_1` FOREIGN KEY (`userId`) REFERENCES `user` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;
insert into `order`(`id`,`ordernum`,`userId`) values (1,20200107,1),(2,20200806,2),(3,20206702,3),(4,20200645,1),(5,20200711,2),(6,20200811,2),(7,20201422,3),(8,20201688,4);
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(20) DEFAULT NULL,
`pwd` varchar(20) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
insert into `user`(`id`,`name`,`pwd`) values (1,'编程帮','123'),(2,'C语言中文网','456'),(3,'赵小红','123'),(4,'李晓明','345'),(5,'杨小胤','123'),(6,'谷小乐','789');
2）创建持久化类
创建持久化类 User 和 Order，代码分别如下：
package net.biancheng.po;
import java.util.List;
public class User {
private int id;
private String name;
private String pwd;
private List<Order> orderList;
/*省略setter和getter方法*/
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", orderList=" + orderList + "]";
}
}
Order 类代码如下：
package net.biancheng.po;
public class Order {
private int id;
private int ordernum;
/*省略setter和getter方法*/
@Override
public String toString() {
return "Order [id=" + id + ", ordernum=" + ordernum + "]";
}
}
分步查询：
OrderMapper 类代码如下：
public List<Order> selectOrderById(int id);
OrderMapper.xml 中相应的映射 SQL 语句如下：
<!-- 根据id查询订单信息 -->
<select id="selectOrderById" resultType="net.biancheng.po.Order"
parameterType="Integer">
SELECT * FROM `order` where userId=#{id}
</select>
UserMapper 类代码如下：
public User selectUserOrderById1(int id);
UserMapper.xml 中相应的映射 SQL 语句如下：
<!-- 一对多 根据id查询用户及其关联的订单信息：级联查询的第一种方法（分步查询） -->
<resultMap type="net.biancheng.po.User" id="userAndOrder1">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="pwd" column="pwd" />
<!-- 一对多级联查询，ofType表示集合中的元素类型，将id传递给selectOrderById -->
<collection property="orderList"
ofType="net.biancheng.po.Order" column="id"
select="net.biancheng.mapper.OrderMapper.selectOrderById" />
</resultMap>
<select id="selectUserOrderById1" parameterType="Integer"
resultMap="userAndOrder1">
select * from user where id=#{id}
</select>
测试代码如下：
public class Test {
public static void main(String[] args) throws IOException {
InputStream config = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory ssf = new SqlSessionFactoryBuilder().build(config);
SqlSession ss = ssf.openSession();
User us = ss.getMapper(UserMapper.class).selectUserOrderById1(1);
System.out.println(us);
}
}
单步查询：
该种方式实现一对多关联查询需要修改 Order 持久化类，因为 Order 中的 id 不能和 User 中的 id 重复
package net.biancheng.po;
public class Order {
private int oId;
private int ordernum;
/*省略setter和getter方法*/
@Override
public String toString() {
return "Order [id=" + oId+ ", ordernum=" + ordernum + "]";
}
}
UserMapper 类代码如下：
public User selectUserOrderById2(int id)
UserMapper.xml 中相关映射 SQL 语句如下：
<!-- 一对多 根据id查询用户及其关联的订单信息：级联查询的第二种方法（单步查询） -->
<resultMap type="net.biancheng.po.User" id="userAndOrder2">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="pwd" column="pwd" />
<!-- 一对多级联查询，ofType表示集合中的元素类型 -->
<collection property="orderList"
ofType="net.biancheng.po.Order">
<id property="oId" column="oId" />
<result property="ordernum" column="ordernum" />
</collection>
</resultMap>
<select id="selectUserOrderById2" parameterType="Integer"
resultMap="userAndOrder2">
SELECT u.*,o.id as oId,o.ordernum FROM `user` u,`order` o
WHERE
u.id=o.`userId` AND u.id=#{id}
</select>
测试代码修改调用方法，如下：
public class Test {
public static void main(String[] args) throws IOException {
InputStream config = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory ssf = new SqlSessionFactoryBuilder().build(config);
SqlSession ss = ssf.openSession();
User us = ss.getMapper(UserMapper.class).selectUserOrderById2(1);
System.out.println(us);
}
}
实际应用中，由于多对多的关系比较复杂，会增加理解和关联的复杂度，所以应用较少。MyBatis 没有实现多对多级联，推荐通过两个一对多级联替换多对多级联，以降低关系的复杂度，简化程序。
例如，一个订单可以有多种商品，一种商品可以对应多个订单，订单与商品就是多对多的级联关系。可以使用一个中间表（订单记录表）将多对多级联转换成两个一对多的关系。
示例
下面以订单和商品（实现“查询所有订单以及每个订单对应的商品信息”的功能）为例讲解多对多关联查询
创建 order（订单），product（商品）和 order_details（订单和商品中间表），SQL 语句如下：
CREATE TABLE `order` (
`oid` int(11) NOT NULL AUTO_INCREMENT,
`ordernum` int(25) DEFAULT NULL,
`userId` int(11) DEFAULT NULL,
PRIMARY KEY (`oid`),
KEY `userId` (`userId`),
CONSTRAINT `order_ibfk_1` FOREIGN KEY (`userId`) REFERENCES `user` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
insert into `order`(`oid`,`ordernum`,`userId`) values (1,20200107,1),(2,20200806,2),(3,20206702,3),(4,20200645,1),(5,20200711,2),(6,20200811,2),(7,20201422,3),(8,20201688,4),(9,NULL,5);
DROP TABLE IF EXISTS `orders_detail`;
CREATE TABLE `orders_detail` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`orderId` int(11) DEFAULT NULL,
`productId` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
insert into `orders_detail`(`id`,`orderId`,`productId`) values (1,1,1),(2,1,2),(3,1,3),(4,2,3),(5,2,1),(6,3,2);
DROP TABLE IF EXISTS `product`;
CREATE TABLE `product` (
`pid` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(25) DEFAULT NULL,
`price` double DEFAULT NULL,
PRIMARY KEY (`pid`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
insert into `product`(`pid`,`name`,`price`) values (1,'Java教程',128),(2,'C语言教程',138),(3,'Python教程',132.35);
Order 类代码如下：
package net.biancheng.po;
import java.util.List;
public class Order {
private int oid;
private int ordernum;
private List<Product> products;
/*省略setter和getter方法*/
@Override
public String toString() {
return "Order [id=" + oid + ", ordernum=" + ordernum + ", products=" + products + "]";
}
}
Product 类方法如下：
package net.biancheng.po;
import java.util.List;
public class Product {
private int pid;
private String name;
private Double price;
// 多对多中的一个一对多
private List<Order> orders;
/*省略setter和getter方法*/
@Override
public String toString() {
return "Product [id=" + pid + ", name=" + name + ", price=" + price + "]";
}
}
OrderMapper 接口代码如下：
package net.biancheng.mapper;
import java.util.List;
import net.biancheng.po.Order;
public interface OrderMapper {
public List<Order> selectAllOrdersAndProducts();
}
OrderMapper.xml 代码如下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="net.biancheng.mapper.OrderMapper">
<resultMap type="net.biancheng.po.Order" id="orderMap">
<id property="oid" column="oid" />
<result property="ordernum" column="ordernum" />
<collection property="products"
ofType="net.biancheng.po.Product">
<id property="pid" column="pid" />
<result property="name" column="name" />
<result property="price" column="price" />
</collection>
</resultMap>
<select id="selectAllOrdersAndProducts" parameterType="Integer"
resultMap="orderMap">
SELECT o.oid,o.`ordernum`,p.`pid`,p.`name`,p.`price` FROM
`order` o
INNER JOIN orders_detail od ON o.oid=od.`orderId`
INNER JOIN
product p
ON p.pid = od.`productId`
</select>
</mapper>
测试类代码如下：
package net.biancheng.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import net.biancheng.mapper.OrderMapper;
import net.biancheng.po.Order;
public class Test {
public static void main(String[] args) throws IOException {
InputStream config = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory ssf = new SqlSessionFactoryBuilder().build(config);
SqlSession ss = ssf.openSession();
List<Order> orderList = ss.getMapper(OrderMapper.class).selectAllOrdersAndProducts();
for (Order or : orderList) {
System.out.println(or);
}
}
}
动态 SQL 是 MyBatis 的强大特性之一。在 JDBC 或其它类似的框架中，开发人员通常需要手动拼接 SQL 语句。根据不同的条件拼接 SQL 语句是一件极其痛苦的工作。例如，拼接时要确保添加了必要的空格，还要注意去掉列表最后一个列名的逗号。而动态 SQL 恰好解决了这一问题，可以根据场景动态的构建查询。
MyBatis 的动态 SQL 包括以下几种元素，如下表所示：
| 元素 |
作用 |
备注 |
| if |
判断语句 |
单条件分支判断 |
| choose（when、otherwise） |
相当于 Java 中的 switch case 语句 |
多条件分支判断 |
|
trim、where
|
辅助元素 |
用于处理一些SQL拼装问题 |
| foreach |
循环语句 |
在in语句等列举条件常用 |
| bind |
辅助元素 |
拼接参数 |
if 语句使用方法简单，常常与 test 属性联合使用。语法如下：
<if test="判断条件">
SQL语句
</if>
当判断条件为 true 时，才会执行所包含的 SQL 语句。
if 语句中包含 where 子句，例如：
<select id="selectAllWebsite" resultMap="myResult">
select id,name,url from website
<if test="name != null">
where name like #{name}
</if>
</select>
多个 if 语句同时使用，例如：
<select id="selectAllWebsite" resultMap="myResult">
select id,name,url from website where 1=1
<if test="name != null">
AND name like #{name}
</if>
<if test="url!= null">
AND url like #{url}
</if>
</select>
MyBatis 中动态语句 choose-when-otherwise 类似于 Java 中的 switch-case-default 语句。由于 MyBatis 并没有为 if 提供对应的 else 标签，如果想要达到…… 的效果，可以借助 、、 来实现
动态语句 choose-when-otherwise 语法如下：
<choose>
<when test="判断条件1">
SQL语句1
</when >
<when test="判断条件2">
SQL语句2
</when >
<when test="判断条件3">
SQL语句3
</when >
<otherwise>
SQL语句4
</otherwise>
</choose>
choose 标签按顺序判断其内部 when 标签中的判断条件是否成立，如果有一个成立，则执行相应的 SQL 语句，choose 执行结束；如果都不成立，则执行 otherwise 中的 SQL 语句。这类似于 Java 的 switch 语句，choose 为 switch，when 为 case，otherwise 则为 default。
以下示例要求：
- 当网站名称不为空时，只用网站名称作为条件进行模糊查询；
- 当网站名称为空，而网址不为空时，则用网址作为条件进行模糊查询；
- 当网站名称和网址都为空时，则要求网站年龄不为空。
示例：
<mapper namespace="net.biancheng.mapper.WebsiteMapper">
<select id="selectWebsite"
parameterType="net.biancheng.po.Website"
resultType="net.biancheng.po.Website">
SELECT id,name,url,age,country
FROM website WHERE 1=1
<choose>
<when test="name != null and name !=''">
AND name LIKE CONCAT('%',#{name},'%')
</when>
<when test="url != null and url !=''">
AND url LIKE CONCAT('%',#{url},'%')
</when>
<otherwise>
AND age is not null
</otherwise>
</choose>
</select>
</mapper>
在上面的使用多个 if 标签时，SQL语句中加入了一个条件“1=1”，如果没有加入这个条件，那么可能就会变成下面这样一条错误的语句：
SELECT id,name,url,age,country FROM website AND name LIKE CONCAT('%',#{name},'%')
显然以上语句会出现 SQL 语法异常，但加入“1=1”这样的条件又非常奇怪，所以 MyBatis 提供了 where 标签。
where 标签主要用来简化 SQL 语句中的条件判断，可以自动处理 AND/OR 条件，语法如下：
<where>
<if test="判断条件">
AND/OR ...
</if>
</where>
示例：
<select id="selectWebsite" resultType="net.biancheng.po.Website">
select id,name,url from website
<where>
<if test="name != null">
AND name like #{name}
</if>
<if test="url!= null">
AND url like #{url}
</if>
</where>
</select>
这是对使用多个 if 标签的优化。
在 Mybatis 中，update 语句可以使用 set 标签动态更新列。set 标签可以为 SQL 语句动态的添加 set 关键字，剔除追加到条件末尾多余的逗号。不为空才更新，能够精确更新修改的地方。
示例：
根据 id 修改网站名称或网址：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="net.biancheng.mapper.WebsiteMapper">
<!--使用set元素动态修改一个网站记录 -->
<update id="updateWebsite"
parameterType="net.biancheng.po.Website">
UPDATE website
<set>
<if test="name!=null">name=#{name}</if>
<if test="url!=null">url=#{url}</if>
</set>
WHERE id=#{id}
</update>
</mapper>
对于一些 SQL 语句中含有 in 条件，需要迭代条件集合来生成的情况，可以使用 foreach 来实现 SQL 条件的迭代。
Mybatis foreach 标签用于循环语句，它很好的支持了数据和 List、set 接口的集合，并对此提供遍历的功能。语法格式如下：
<foreach item="item" index="index" collection="list|array|map key" open="(" separator="," close=")">
参数值
</foreach>
foreach 标签主要有以下属性，说明如下：
- item：表示集合中每一个元素进行迭代时的别名
- index：指定一个名字，表示在迭代过程中每次迭代到的位置
- open：表示该语句以什么开始（既然是 in 条件语句，所以必然以
(开始）
- separator：表示在每次进行迭代之间以什么符号作为分隔符（既然是 in 条件语句，所以必然以
,作为分隔符）
- close：表示该语句以什么结束（既然是 in 条件语句，所以必然以
)开始）
使用 foreach 标签时，最关键、最容易出错的是 collection 属性，该属性是必选的，但在不同情况下该属性的值是不一样的，主要有以下 3 种情况：
- 如果传入的是单参数且参数类型是一个 List，collection 属性值为 list。
- 如果传入的是单参数且参数类型是一个 array 数组，collection 的属性值为 array。
- 如果传入的参数是多个，需要把它们封装成一个 Map，当然单参数也可以封装成 Map。Map 的 key 是参数名，collection 属性值是传入的 List 或 array 对象在自己封装的 Map 中的 key。
示例：
现有 website 表包含以下记录：
WebsiteMapper.xml 中代码如下：
<select id="selectWebsite"
parameterType="net.biancheng.po.Website"
resultType="net.biancheng.po.Website">
SELECT id,name,url,age,country
FROM website WHERE age in
<foreach item="age" index="index" collection="list" open="("
separator="," close=")">
#{age}
</foreach>
</select>
每个数据库的拼接函数或连接符号都不同，例如 MySQL 的 concat 函数、Oracle 的连接符号“||”等。这样 SQL 映射文件就需要根据不同的数据库提供不同的实现，显然比较麻烦，且不利于代码的移植。幸运的是，MyBatis 提供了 bind 标签来解决这一问题。
比如，按照网站名称进行模糊查询，SQL 映射文件如下：
<select id="selectWebsite" resultType="net.biancheng.po.Website">
<bind name="pattern" value="'%'+_parameter+'%'" />
SELECT id,name,url,age,country
FROM website
WHERE name like #{pattern}
</select>
bind 元素属性如下。
- value：对应传入实体类的某个字段，可以进行字符串拼接等特殊处理
- name：给对应参数取的别名
以上代码中的 “_parameter” 代表传递进来的参数，它和通配符连接后，赋给了 pattern，然后就可以在 select 语句中使用这个变量进行模糊查询，不管是 MySQL 数据库还是 Oracle 数据库都可以使用这样的语句，提高了可移植性。
多参数传递：
<select id="selectWebsite" resultType="net.biancheng.po.Website">
<bind name="pattern_name" value="'%'+name+'%'" />
<bind name="pattern_url" value="'%'+url+'%'" />
SELECT id,name,url,age,country
FROM website
WHERE name like #{pattern_name}
AND url like #{pattern_url}
</select>
MyBatis 中除了使用 where + if 实现多条件查询，还有一个更为灵活的元素 trim 能够替代之前的做法。
trim 一般用于去除 SQL 语句中多余的 AND 关键字、逗号，或者给 SQL 语句前拼接 where、set 等后缀，可用于选择性插入、更新、删除或者条件查询等操作。trim 语法格式如下：
<trim prefix="前缀" suffix="后缀" prefixOverrides="忽略前缀字符" suffixOverrides="忽略后缀字符">
SQL语句
</trim>
属性说明：
| 属性 |
描述 |
| prefix |
给SQL语句拼接的前缀，为 trim 包含的内容加上前缀 |
| suffix |
给SQL语句拼接的后缀，为 trim 包含的内容加上后缀 |
| prefixOverrides |
去除 SQL 语句前面的关键字或字符，该关键字或者字符由 prefixOverrides 属性指定。 |
| suffixOverrides |
去除 SQL 语句后面的关键字或者字符，该关键字或者字符由 suffixOverrides 属性指定。 |
示例
<select id="selectWebsite" resultType="net.biancheng.po.Website">
SELECT id,name,url,age,country
FROM website
<trim prefix="where" prefixOverrides="and">
<if test="name != null and name !=''">
AND name LIKE CONCAT ('%',#{name},'%')
</if>
<if test="url!= null">
AND url like concat ('%',#{url},'%')
</if>
</trim>
</select>
缓存可以将数据保存在内存中，是互联网系统常常用到的。目前流行的缓存服务器有 MongoDB、Redis、Ehcache 等。缓存是在计算机内存上保存的数据，读取时无需再从磁盘读入，因此具备快速读取和使用的特点。
和大多数持久化框架一样，MyBatis 提供了一级缓存和二级缓存的支持。默认情况下，MyBatis 只开启一级缓存。
-
一级缓存是基于 PerpetualCache（MyBatis自带）的 HashMap 本地缓存，作用范围为 session 域内。当 session flush（刷新）或者 close（关闭）之后，该 session 中所有的 cache（缓存）就会被清空。
-
在参数和 SQL 完全一样的情况下，使用同一个 SqlSession 对象调用同一个 mapper 的方法，往往只执行一次 SQL。因为使用 SqlSession 第一次查询后，MyBatis 会将其放在缓存中，再次查询时，如果没有刷新，并且缓存没有超时的情况下，SqlSession 会取出当前缓存的数据，而不会再次发送 SQL 到数据库。
-
由于 SqlSession 是相互隔离的，所以如果你使用不同的 SqlSession 对象，即使调用相同的 Mapper、参数和方法，MyBatis 还是会再次发送 SQL 到数据库执行，返回结果。
示例
在 WebsiteMapper 类中添加 selectWebsiteById 方法，代码如下：
public Website selectWebsiteById(int id);
WebsiteMapper.xml 中添加相应的映射 SQL 语句，代码如下：
<select id="selectWebsiteById"
resultType="net.biancheng.po.Website">
SELECT * FROM website
WHERE id=#{id}
</select>
测试代码如下：
package net.biancheng.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.log4j.Logger;
import net.biancheng.po.Website;
public class Test {
public static Logger logger = Logger.getLogger(Test.class);
public static void main(String[] args) throws IOException {
InputStream config = Resources.getResourceAsStream("mybatis-config.xml"); // 根据配置文件构建
SqlSessionFactory ssf = new SqlSessionFactoryBuilder().build(config);
SqlSession ss = ssf.openSession();
Website site = ss.selectOne("net.biancheng.mapper.WebsiteMapper.selectWebsiteById", 1);
logger.debug("使用同一个sqlsession再执行一次");
Website site2 = ss.selectOne("net.biancheng.mapper.WebsiteMapper.selectWebsiteById", 1);
// 请注意，当我们使用二级缓存的时候，sqlSession调用了 commit方法后才会生效
ss.commit();
logger.debug("现在创建一个新的SqlSeesion对象在执行一次");
SqlSession ss2 = ssf.openSession();
Website site3 = ss2.selectOne("net.biancheng.mapper.WebsiteMapper.selectWebsiteById", 1);
// 请注意，当我们使用二级缓存的时候，sqlSession调用了 commit方法后才会生效
ss2.commit();
}
}
运行结果如下：
DEBUG [main] - ==> Preparing: SELECT * FROM website WHERE id=?
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <== Total: 1
DEBUG [main] - 使用同一个sqlsession再执行一次
DEBUG [main] - 现在创建一个新的SqlSeesion对象在执行一次
DEBUG [main] - ==> Preparing: SELECT * FROM website WHERE id=?
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <== Total: 1
从运行结果可以看出，第一个 SqlSession 实际只发生过一次查询，而第二次查询就从缓存中取出了，也就是 SqlSession 层面的一级缓存。为了克服这个问题，我们往往需要配置二级缓存，使得缓存在 SqlSessionFactory 层面上能够提供给各个 SqlSession 对象共享。
二级缓存是全局缓存，作用域超出 session 范围之外，可以被所有 SqlSession 共享。
一级缓存缓存的是 SQL 语句，二级缓存缓存的是结果对象。
二级缓存的配置
1）MyBatis 的全局缓存配置需要在 mybatis-config.xml 的 settings 元素中设置，代码如下：
<settings>
<setting name="cacheEnabled" value="true" />
</settings>
2）在 mapper 文件（如 WebMapper.xml）中设置缓存，默认不开启缓存。需要注意的是，二级缓存的作用域是针对 mapper 的 namescape 而言，即只有再次在 namescape 内（net.biancheng.WebsiteMapper）的查询才能共享这个缓存，代码如下：
<mapper namescape="net.biancheng.WebsiteMapper">
<!-- cache配置 -->
<cache
eviction="FIFO"
flushInterval="60000"
size="512"
readOnly="true" />
...
</mapper>
以上属性说明如下：
| 属性 |
说明 |
| eviction |
代表的是缓存回收策略，目前 MyBatis 提供以下策略。LRU：使用较少，移除最长时间不用的对象；FIFO：先进先出，按对象进入缓存的顺序来移除它们；SOFT：软引用，移除基于垃圾回收器状态和软引用规则的对象；WEAK：弱引用，更积极地移除基于垃圾收集器状态和弱引用规则的对象。 |
| flushInterval |
刷新间隔时间，单位为毫秒，这里配置的是 100 秒刷新，如果省略该配置，那么只有当 SQL 被执行的时候才会刷新缓存。 |
| size |
引用数目，正整数，代表缓存最多可以存储多少个对象，不宜设置过大。设置过大会导致内存溢出。这里配置的是 1024 个对象。 |
| readOnly |
只读，默认值为 false，意味着缓存数据只能读取而不能修改，这样设置的好处是可以快速读取缓存，缺点是没有办法修改缓存。 |
3）在 mapper 文件配置支持 cache 后，如果需要对个别查询进行调整，可以单独设置 cache，代码如下：
<select id="getWebsiteList" resultType="net.biancheng.po.Website" usecache="true">
...
</select>
对于 MyBatis 缓存仅作了解即可，因为面对一定规模的数据量，内置的 Cache 方式就派不上用场了，并且对查询结果集做缓存并不是 MyBatis 所擅长的，它专心做的应该是 SQL 映射。对于缓存，采用 OSCache、Memcached 等专门的缓存服务器来做更为合理。
提醒：本文发布于630天前，文中所关联的信息可能已发生改变，请知悉！
