还不会Mybatis？看完这篇就无敌！

什么是 MyBatis？

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

学习文档：https://mybatis.org/mybatis-3/zh/index.html

使用步骤

1. Maven依赖

<dependency>  
<groupId>org.mybatisgroupId>  <artifactId>mybatisartifactId> 
<version>x.x.xversion>
dependency>

使用mysql的driver。

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>8.0.22version>
dependency>

2. XML中构建 SqlSessionFactory

XML 配置文件中包含了对 MyBatis 系统的核心设置，包括获取数据库连接实例的数据源（DataSource）以及决定事务作用域和控制方式的事务管理器（TransactionManager）。

<configuration>
    <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>
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    mappers>
configuration>

3. 编写工具类

这就可以根据config.xml文件中数据库的连接配置来创建SqlSessionFactory，并编写提供sqlSession的方法。

public class MybatisUtils {
     
    private static  SqlSessionFactory sqlSessionFactory;
    static {
     
        try {
     
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
     
            e.printStackTrace();
        }
    }
    public static SqlSession getSqlSession(){
     
        return sqlSessionFactory.openSession();
    }
}

4. 编写实体类

根据数据库中的数据编写。

public class User {
     
    private int id;
    private String name;
    private String pwd;

    public User() {
     
    }

    public User(int id, String name, String pwd) {
     
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
     
        return id;
    }

    public void setId(int id) {
     
        this.id = id;
    }

    public String getName() {
     
        return name;
    }

    public void setName(String name) {
     
        this.name = name;
    }

    public String getPwd() {
     
        return pwd;
    }

    public void setPwd(String pwd) {
     
        this.pwd = pwd;
    }

    @Override
    public String toString() {
     
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

5. 编写DAO层

public interface UserDao {
     
    List<User> getUserList();
}

原本的JDBC中需要编写具体的实现类，从而执行SQL语句。但是Mybatis通过使用XML定义的方式取代了编写实现类，并取名为Mapper，其中namespace实现接口绑定，select中的id属性就是接口中的方法，resultType表示了返回值的类型，就是我们编写的实体类。

    
    select * from mybatis.test
  

此时还需要在Mybatis的config.xml中配置，指定mapper的路径。

6. 编写测试类

通过工具类MybatisUtils获取SqlSession，getmapper执行mapper中的配置，相当于构建接口的实现类，最后调用了getUserList，执行getUserList方法，返回查询的结果，最后一定记得将资源关闭。

@Test
public void test() {
     
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    List<User> userList = userDao.getUserList();
    for(User user : userList){
     
        System.out.println(user);
    }
    sqlSession.close();
}

生命周期和作用域

SqlSessionFactoryBuilder

这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。 你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但最好还是不要一直保留着它，以保证所有的 XML 解析资源可以被释放给更重要的事情。

SqlSessionFactory

SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

SqlSession

每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。 如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。 下面的示例就是一个确保 SqlSession 关闭的标准模式：

try (SqlSession session = sqlSessionFactory.openSession()) {
       
// 你的应用逻辑代码
}

如果不及时关闭，会造成大量的资源浪费。

映射器实例

映射器是一些绑定映射语句的接口。映射器接口的实例是从 SqlSession 中获得的。虽然从技术层面上来讲，任何映射器实例的最大作用域与请求它们的 SqlSession 相同。但方法作用域才是映射器实例的最合适的作用域。 也就是说，映射器实例应该在调用它们的方法中被获取，使用完毕之后即可丢弃。 映射器实例并不需要被显式地关闭。尽管在整个请求作用域保留映射器实例不会有什么问题，但是你很快会发现，在这个作用域上管理太多像 SqlSession 的资源会让你忙不过来。 因此，最好将映射器放在方法作用域内。就像下面的例子一样：

try (SqlSession session = sqlSessionFactory.openSession()) {
       BlogMapper mapper = session.getMapper(BlogMapper.class);  
// 你的应用逻辑代码
}

XML配置

enviroments

mybatis可以配置多种环境，这种机制有助于SQL映射到多种数据库中， 现实情况下有多种理由需要这么做。例如，开发、测试和生产环境需要有不同的配置；或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。还有许多类似的使用场景。

但是每个sqlsessionfactory只能对应一个环境，而每个数据库对应一个sqlsessionfactory。

为了指定创建哪种环境，只要将它作为可选的参数传递给 SqlSessionFactoryBuilder 即可。可以接受环境配置的两个方法签名是：

SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment, properties);

如果没有写明指定的环境，就会使用默认环境，default=环境id，就是默认的环境。

事务管理器（transactionManager）

在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）

● JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。
● MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。例如:

<transactionManager type="MANAGED">  
<property name="closeConnection" value="false"/>
transactionManager>

数据源（dataSource）

dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。

有三种内建的数据源类型（也就是 type="[UNPOOLED|POOLED|JNDI]"）：

• UNPOOLED–这个数据源的实现会每次请求时打开和关闭连接。虽然有点慢，但对那些数据库连接可用性要求不高的简单应用程序来说，是一个很好的选择。
• POOLED– 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。这种处理方式很流行，能使并发 Web 应用快速响应请求。
• JNDI – 这个数据源实现是为了能在如 EJB或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的数据源引用。

属性（properties）

property可以通过编写.properties文件来配置，或者直接在environment中声明，如果使用.properties就需要在properties的resource中指明路径，然后在环境中使用properties时，使用如下形式，${}里面对应的就是.properties文件中属性名。

如果同时.properties和在xml文件配置，那么就会优先使用.properties。

类型别名（typeAliases）

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。两种声明方式：

给每一个类起一个具体的别名，这种方式的好处是可以自己指定。

扫描包下的类，自动给类起别名，别名默认为这个类的首字母小写的名字。比如com.blog.User的别名为user，可以在类上添加Alias注解也可以实现自定义别名。

@Alias("author")
public class Author {
     
    ...
}

设置（settings）

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。 下表描述了设置中各项设置的含义、默认值等。

主要掌握：


log4j

Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

使用步骤：
第一步：在maven中导入jar包

<dependency>
    <groupId>log4jgroupId>
    <artifactId>log4jartifactId>
    <version>1.2.17version>
dependency>

第二步：编写log4j.properties文件

log4j.rootLogger=DEBUG,console,file

log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern = [%c]-%m%n

log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File = ./log/zzy.log
log4j.appender.file.MaxFileSize = 10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

log4j.appender.org.mybatis=DEBUG
log4j.appender.java.sql=DEBUG
log4j.appender.java.sql.Statement=DEBUG
log4j.appender.java.sql.ResultSet=DEBUG
log4j.appender.java.sql.PreparedStatement=DEBUG

第三步：配置

注意要完全一样，大小写、空格等不同都会导致错误。

第四步：获取当前使用类的对象。

static Logger logger = Logger.getLogger(xxx.class);

效果：

映射器（mappers）

既然 MyBatis 的行为已经由上述元素配置完了，我们现在就要来定义 SQL 映射语句了。 但首先，我们需要告诉 MyBatis 到哪里去找到这些语句。

XML映射文件

参数映射

鉴于参数类型（parameterType）会被自动设置为int，这个参数可以随意命名。

如果 User 类型的参数对象传递到了语句中，会查找 id、username 和 password 属性，然后将它们的值传入预处理语句的参数中。

<insert id="insertUser" parameterType="User">  
insert into users (id, username, password)  
values (#{id}, #{username}, #{password})
insert>

提示 ：JDBC 要求，如果一个列允许使用 null 值，并且会使用值为 null 的参数，就必须要指定 JDBC 类型（jdbcType）。

尽管上面这些选项很强大，但大多时候，你只须简单指定属性名，顶多要为可能为空的列指定jdbcType，其他的事情交给 MyBatis 自己去推断就行了。

#{firstName}
#{middleInitial,jdbcType=VARCHAR}
#{lastName}

使用@Param 可以指定mapper接收的参数名。

@Select("select * from user where ${column} = #{value}")
User findByColumn(@Param("column") String column,
@Param("value") String value);

结果映射

MyBatis 的真正强大在于它的语句映射，这是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 致力于减少使用成本，让用户能更专注于SQL代码。

resultMap

resultmap元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC resultset数据提取代码中解放出来，并在一些情形下允许你进行一些 JDBC 不支持的操作。实际上，在为一些比如连接的复杂语句编写映射代码的时候，一份 resultmap 能够代替实现同等功能的数千行代码。ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

<select id="selectUsers" resultMap="userResultMap">  
select user_id, user_name, hashed_password  from some_table  where id = #{id}
select>

<resultMap id="userResultMap" type="User">  
<id property="id" column="user_id" />  
<result property="username" column="user_name"/>  
<result property="password" column="hashed_password"/>
resultMap>

ResultMap的优秀之处——你完全可以不用显式地配置它们，当实体类的属性名和数据库的列名一样时，就完全不需要使用（自动映射），只需要在不相同的时候配置即可。

动态SQL

if

使用动态 SQL 最常见情景是根据条件包含 where 子句的一部分。比如：

<select id="findActiveBlogWithTitleLike" resultType="Blog">  SELECT * FROM BLOG  WHERE state = ‘ACTIVE’  
    <if test="title != null">    
      AND title like #{title}  
    if>
select>

如果希望通过 “title” 和 “author” 两个参数进行可选搜索该怎么办呢？首先，我想先将语句名称修改成更名副其实的名称；接下来，只需要加入另一个条件即可。

<select id="findActiveBlogLike" resultType="Blog">  
SELECT * FROM BLOG WHERE state = ‘ACTIVE’  
   <if test="title != null">    
   AND title like #{title}  
   if>  
   <if test="author != null and author.name != null">    
   AND author_name like #{author.name}  
   if>
select>

choose、when、otherwise

有时候，我们不想使用所有的条件，而只是想从多个条件中选择一个使用。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句。

<select id="findActiveBlogLike" resultType="Blog">  
SELECT * FROM BLOG WHERE state = ‘ACTIVE’  
<choose>    
   <when test="title != null">      
   AND title like #{title}    
   when>    
   <when test="author != null and author.name != null"> 
   AND author_name like #{author.name}    
   when>    
   <otherwise>      
   AND featured = 1    
   otherwise>  
choose>
select>

trim、where、set

现在看下面这个列子，当没有一个匹配时，sql就为：select * from blog where；这种显然时错误的语句，那么如果第二个语句成立时，语句变为：select * from blog where and title like #{title}；显然也是错误的语句。

<select id="findActiveBlogLike" resultType="Blog">  
SELECT * FROM BLOG  WHERE  
    <if test="state != null">    
    state = #{state}  
    if>  
    <if test="title != null">    
    AND title like #{title}  
    if>  
    <if test="author != null and author.name != null">    
    AND author_name like #{author.name}  
    if>
select>

MyBatis 有一个简单且适合大多数场景的解决办法。而在其他场景中，可以对其进行自定义以符合需求。而这，只需要一处简单的改动：

<select id="findActiveBlogLike" resultType="Blog">  
SELECT * FROM BLOG  
<where>    
   <if test="state != null">         
   state = #{state}    
   if>    
   <if test="title != null">        
   AND title like #{title}    
   if>    
   <if test="author != null and author.name != null">        
   AND author_name like #{author.name}    
   if> 
where>
select>

where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

如果 where 元素与你期望的不太一样，你也可以通过自定义 trim 元素来定制 where 元素的功能。比如，和 where 元素等价的自定义 trim 元素为：

<trim prefix="WHERE" prefixOverrides="AND |OR ">  
...
trim>

prefixOverrides 属性会忽略通过管道符分隔的文本序列（注意此例中的空格是必要的）。上述例子会移除所有 prefixOverrides 属性中指定的内容，并且插入 prefix 属性中指定的内容。

用于动态更新语句的类似解决方案叫做 set。set 元素可以用于动态包含需要更新的列，忽略其它不更新的列。比如：

<update id="updateAuthorIfNecessary">  
update Author    
<set>      
  <if test="username != null">username=#{username},
  if>      
  <if test="password != null">password=#{password},
  if>      
  <if test="email != null">email=#{email},
  if>      
  <if test="bio != null">bio=#{bio}
  if>    
set>  
where id=#{id}
update>

这个例子中，set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。

来看看与 set 元素等价的自定义 trim 元素吧：

<trim prefix="SET" suffixOverrides=",">  
...
trim>

foreach

动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 IN 条件语句的时候）。比如：

<select id="selectPostIn" resultType="domain.blog.Post">  SELECT *  FROM POST P WHERE ID in  
<foreach item="item" index="index" collection="list"     open="(" separator="," close=")">  

   #{item}  
   
foreach>
select>

foreach 元素的功能非常强大，它允许你指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误地添加多余的分隔符，看它多智能！

提示：你可以将任何可迭代对象（如 List、Set 等）、Map 对象或者数组对象作为集合参数传递给 foreach。当使用可迭代对象或者数组时，index 是当前迭代的序号，item 的值是本次迭代获取到的元素。当使用 Map 对象（或者 Map.Entry 对象的集合）时，index 是键，item 是值。

bind

<select id="selectBlogsLike" resultType="Blog">  
<bind name="pattern" value="'%' + _parameter.getTitle() + '%'" />  
SELECT * FROM BLOG  WHERE title LIKE #{pattern}
select>

缓存

基本概念

MyBatis 内置了一个强大的事务性查询缓存机制，它可以非常方便地配置和定制。 为了使它更加强大而且易于配置，我们对 MyBatis 3 中的缓存实现进行了许多改进。

默认情况下，只启用了本地的会话缓存，它仅仅对一个会话中的数据进行缓存。 要启用全局的二级缓存，只需要在你的 SQL 映射文件中添加一行：

<cache/>

同时还需要在settings中声明cacheEnable，虽然是默认为true的。

基本上就是这样。这个简单语句的效果如下:

• 映射语句文件中的所有 select 语句的结果将会被缓存。
• 映射语句文件中的所有 insert、update 和 delete语句会刷新缓存。
• 缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
• 缓存不会定时进行刷新（也就是说，没有刷新间隔）。
• 缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
• 缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

提示：缓存只作用于 cache 标签所在的映射文件中的语句。如果你混合使用 Java API 和 XML 映射文件，在共用接口中的语句将不会被默认缓存。你需要使用 @CacheNamespaceRef 注解指定缓存作用域。

这些属性可以通过 cache 元素的属性来修改。

<cache  eviction="FIFO"  flushInterval="60000"  size="512"  readOnly="true"/>

这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。

可用的清除策略有：

默认的清除策略是 LRU。

flushInterval（刷新间隔）属性可以被设置为任意的正整数，设置的值应该是一个以毫秒为单位的合理时间量。 默认情况是不设置，也就是没有刷新间隔，缓存仅仅会在调用语句时刷新。

size（引用数目）属性可以被设置为任意正整数，要注意欲缓存对象的大小和运行环境中可用的内存资源。默认值是 1024。

readOnly（只读）属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。 因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。 速度上会慢一些，但是更安全，因此默认值是 false。

工作流程

二级缓存脏读

由于二级缓存作用于namesace级别，也就是说不同mapper有自己独立一套的缓存，那么当不同mapper对同一表进行操作时，就会出现脏读。

比如mapper A 查询了 M 表 ，然后mapper B 对 M表修改并提交事务，只要mapper A这段时间内没有执行update、delete、insert操作，mapper A的缓存就不会被刷新，当mapper A再次select时，由于Mybatis缓存工作机制，会先从二级缓存中拿取数据，此时mapper A select出的数据就是脏数据。

因此在开启二级缓存后，所有的对同一表的增删改查应该在同一mapper下。

【MyBatis源码解析】MyBatis一二级缓存

Mybatis执行流程

1. resource读取配置文件
   
2. 解析配置文件流XML
   
   
3. Configuration
   
   
4. 实列化SqlSessionFactory
   
5. transactionManager
   
6. executor
   
7. 创建SqlSession
   
8. 实现CRUD