复习宝典之MyBatis

查看更多宝典，请点击《金三银四，你的专属面试宝典》

第五章：MyBatis

MyBatis是一个可以自定义SQL、存储过程和高级映射的持久层框架。

1）创建sqlsession的流程

mybatis进行持久化操作时重要的几个类：

SqlSessionFactoryBuilder：build方法创建SqlSessionFactory实例。

SqlSessionFactory：创建SqlSession实例的工厂。

SqlSession：用于执行持久化操作的对象，类似于jdbc中的Connection。

SqlSessionTemplate：MyBatis提供的持久层访问模板化的工具，线程安全，可通过构造参数或依赖注入SqlSessionFactory实例。

2）配置文件相关

2.1 在mybatis配置文件中支持两种事务类型管理器，分别是：

　　①、type = "JDBC"：这个配置就是直接使用了 JDBC 的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域。

　　②、type="MANAGED"：这个配置几乎没做什么，它从来不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）， 默认情况下它会关闭连接，然而一些容器并不希望这样，因此需要将 closeConnection 属性设置为 false 来阻止它默认的关闭行为。

注意：和数据源配置一样，通常项目中我们不会单独使用 mybatis 来管理事务。比如选择框架 Spring+mybatis，这时候没有必要配置事务管理器， 因为 Spring 模块会使用自带的管理器来覆盖前面的配置。

2.2 mybatis配置文件中datasource的type类型：

POOLED：这是JDBC连接对象的数据源连接池的实现，用来避免创建新的连接实例时必要的初始连接和认证时间，这是一种当前web应用程序用来快速响应请求很流行的方法。

JNDI：这个数据源的实现是为了使用如Spring或这类的容器，容器可以集中或在外部配置数据源，然后放置一个JNDI上下文的引用。

UNPOOLED：这个数据源的实现是每次被请求时简单打开和关闭连接。它有一点慢，这是对简单应用程序的一个很好的选择，因为他不需要及时的可用连接，不同的数据库对这个的表现也是不一样的，所以对某些数据库来上配置数据源并不重要，这个配置也是闲置的。

3）SqlSessionFactory

SqlSessionFactoryBuilder：这个类可以被实例化，使用和丢弃。一旦你创建了SqlSessionFactory后，这个类就不需要存在了。因此SqlSessionFactoryBuilder实例的最佳范围是方法范围（也就是本地方法变量）。你可以重用SqlSessionFactoryBuilder来创建多个SqlSessionFactory实例，但是最好的方式是不需要保持它一直存在来保证所有XML解析资源，因为还有更重要的事情要做。

SqlSessionFactory：线程安全，一旦被创建，SqlSessionFactory应该在你的应用执行期间都存在，没有理由来处理或重新创建它。使用SqlSessionFactory的最佳实践是在应用运行期间不要重复创建多次，这样的操作将被视为是非常糟糕的，因此SqlSessionFactory的最佳范围是应用范围。有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。然而这两种方法都不认为是最佳实践。这样的话，你可以考虑依赖注入容器，比如Google Guice或spring。这样的框架允许你创建支持程序来管理单例SqlSessionFactory的生命周期。

SqlSession：每个线程都应该有它自己的SqlSession实例。SqlSession的实例不能被共享，也是线程不安全的。因此最佳的范围是请求或方法范围。绝对不能将SqlSession实例的引用放在一个类的静态字段甚至是实例字段中。也绝不能将SqlSession实例的引用放在任何类型的管理范围中，比如Serlvet架构中的HttpSession。如果你现在正用任意的Web框架，要考虑SqlSession放在一个和HTTP请求对象相似的范围内。换句话说，基于收到的HTTP请求，你可以打开了一个SqlSession，然后返回响应，就可以关闭它了。关闭Session很重要，你应该确保使用finally块来关闭它。

4）获取添加时的主键值

<!-- 添加用户 -->
<insert id="addUser" parameterType="com.pojo.User">
   <!-- 获取最新的ID主键 -->
   <selectKey keyProperty="id" resultType="Integer" order="AFTER">
         select LAST_INSERT_ID()
   </selectKey>
   insert into user (username,birthday,address,sex)
   values (#{username},#{birthday},#{address},#{sex})
</insert>

5）statementType取值

在mapper文件中可以使用statementType标记使用什么对象操作SQL语句。

statementType：标记操作SQL的对象

取值说明：

1、STATEMENT：直接操作sql，不进行预编译，获取数据：$--Statement

2、PREPARED：预处理，参数，进行预编译，获取数据：#--PreparedStatement：默认

3、CALLABLE：执行存储过程—CallableStatement

其中如果在文件中，取值不同，那么获取参数的方式也不同

<update id="update4" statementType="STATEMENT">

　　update tb_car set price={id}

</update>

<update id="update5" statementType="PREPARED">

　　update tb_car set xh=#{xh} where id=#{id}

</update>

注意：如果只为STATEMENT，那么sql就是直接的进行字符串拼接，这样字符串需要加上引号；如果为PREARED，是使用的参数替换，也就是索引占位符，我们的#会转换为?再设置对应参数的值。

6）mybatis相关概念

'${}'：表示字符串拼接；

'#{}'：表示占位符，可以防止sql注入；

映射到另一张表的字段，如果是一对一，则使用association；

映射到另一张表的字段，如果是一对多，则使用collection；

mybatis中cache回收算法：

FIFO（First In First Out）：先进先出算法，即先放入缓存的先被移除。

LRU（Least Recently Used）：最近最少使用算法，使用时间距离现在最久的那个被移除。

LFU（Least Frequently Used）：最不常用算法，一定时间段内使用【次数（频率）】最少的那个被移除。

实际应用中基于LRU的缓存居多，如Guava Cache、Ehcache支持LRU。

mybatis中resulttype提供哪些值：

返回一般数据类型

<!--
   指定 resultType 返回值类型时 String 类型的，string 在这里是一个别名，代表的是 java.lang.String
   对于引用数据类型，都是将大写字母转小写，比如 HashMap 对应的别名是 'hashmap'
   基本数据类型考虑到重复的问题，会在其前面加上 '_'，比如 byte 对应的别名是 '_byte'
-->
<select id="getEmpNameById" resultType="string">
    select username from t_employee where id = #{id}
</select>

---

​

返回 JavaBean 类型

<!--
    通过 resultType 指定查询的结果是 Employee 类型的数据
    只需要指定 resultType 的类型，MyBatis 会自动将查询的结果映射成 JavaBean 中的属性
-->
<select id="getEmpById" resultType="employee">
    select * from t_employee where id = #{id}
</select>

---

​

返回List类型

<!--
    注意这里的 resultType 返回值类型是集合内存储数据的类型，不是 'list'
-->
<select id="getAllEmps" resultType="employee">
    select * from t_employee
</select>
​

---

返回Map类型

<!--
    注意这里的 resultType 返回值类型是 'map'
 -->
<select id="getEmpAsMapById" resultType="map">
    select * from t_employee where id = #{id}
</select>

---

​

上面返回结果的形式都是基于查询 (select) 的，其实对于增删改的操作也可以返回一定类型的数据，比如Boolean，Integer等。

7）Java中的四种引用类型

Java中的四种引用类型：

强引用(Strong References)：强引用类型是我们平时写代码的时候最常用的引用，而大部分人往往都会忽略这个概念

public static void main(String[] args) {
​
    //创建一个对象，new出来的对象都是分配在java堆中的
    Sample sample = new Sample();   //sample这个引用就是强引用
​
    sample = null;                  //将这个引用指向空指针,
                                    //那么上面那个刚new来的对象就没用任何其它有效的引用指向它了
                                    //也就说该对象对于垃圾收集器是符合条件的
                                    //因此在接下来某个时间点 GC进行收集动作的时候, 该对象将会被销毁，内存被释放
​
}

---

​

软引用(Soft References)：软引用在java.lang.ref包中有与之对应的类java.lang.ref.SoftReference。 重点： 被弱引用指向的对象不会被垃圾收集器收集(即使该对象没有强引用指向它)，除非jvm使用内存不够了，才会对这类对象进行销毁，释放内存。

public static void main(String[] args) {
​
    //创建一个对象，new出来的对象都是分配在java堆中的
    Sample sample = new Sample();   //sample这个引用就是强引用
​
    //创建一个软引用指向这个对象   那么此时就有两个引用指向Sample对象
    SoftReference<Sample> softRef = new SoftReference<Sample>(sample);
​
    //将强引用指向空指针 那么此时只有一个软引用指向Sample对象
    //注意：softRef这个引用也是强引用，它是指向SoftReference这个对象的
    //那么这个软引用在哪呢？ 可以跟一下java.lang.Reference的源码
    //private T referent; 这个才是软引用， 只被jvm使用
    sample = null;
​
    //可以重新获得Sample对象，并用一个强引用指向它
    sample = softRef.get();
}

---

​

弱引用(Weak References)：弱引用会被jvm忽略，也就说在GC进行垃圾收集的时候，如果一个对象只有弱引用指向它，那么和没有引用指向它是一样的效果，jvm都会对它就行果断的销毁，释放内存。其实这个特性是很有用的，jdk也提供了java.util.WeakHashMap这么一个key为弱引用的Map。比如某个资源对象你要释放(比如 db connection), 但是如果被其它map作为key强引用了，就无法释放，被jvm收集。

弱引用对象并不需要在jvm耗尽内存的情况下才进行回收， 是可以随时回收的。

public class Main {
    private static final List<Object> TEST_DATA = new LinkedList<>();
​
    private static final ReferenceQueue<Sample> QUEUE = new     ReferenceQueue<>();
​
    public static void main(String[] args) {
​
        //创建一个对象，new出来的对象都是分配在java堆中的
        Sample sample = new Sample();   //sample这个引用就是强引用
​
        //创建一个弱引用指向这个对象   那么此时就有两个引用指向Sample对象
        //SoftReference<Sample> softRef = new SoftReference<Sample>(sample, QUEUE);
        WeakReference<Sample> weakRef = new WeakReference<Sample>(sample, QUEUE);
        //将强引用指向空指针 那么此时只有一个弱引用指向Sample对象
        //注意：softRef这个引用也是强引用，它是指向SoftReference这个对象的
        //那么这个弱引用在哪呢？ 可以跟一下java.lang.Reference的源码
        //private T referent; 这个才是弱引用， 只被jvm使用
        sample = null;
​
        //可以重新获得Sample对象，并用一个强引用指向它
        //sample = softRef.get();
​
        new Thread(){
            @Override
            public void run() {
                while (true) {
                    System.out.println(weakRef.get());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        Thread.currentThread().interrupt();
                    }
                    TEST_DATA.add(new byte[1024 * 1024 * 5]);
                }
            }
        }.start();
​
        new Thread(){
            @Override
            public void run() {
                while (true) {
                    Reference<? extends Sample> poll = QUEUE.poll();
                    if (poll != null) {
                        System.out.println("--- 弱引用对象被jvm回收了 ---- " + poll);
                        System.out.println("--- 回收对象 ---- " + poll.get());
                    }
                }
            }
        }.start();
​
        try {
            Thread.currentThread().join();
        } catch (InterruptedException e) {
            System.exit(1);
        }
    }
}
class Sample {
    private final byte[] data;
    public Sample() {
        data = new byte[1024 * 1024 * 10];
    }
}

---

​

虚幻引用(Phantom References)：虚幻引用和弱引用的回收机制差不多，都是可以被随时回收的。但是不同的地方是，它的构造方法必须强制传入ReferenceQueue，因为在jvm回收前(重点： 对，就是回收前，软引用和弱引用都是回收后)，会将PhantomReference对象加入ReferenceQueue中; 还有一点就是PhantomReference.get()方法永远返回空，不管对象有没有被回收。

public class Main {
    private static final List<Object> TEST_DATA = new LinkedList<>();
​
    private static final ReferenceQueue<Sample> QUEUE = new ReferenceQueue<>();

    public static void main(String[] args) {
​
        Sample sample = new Sample();
​
        PhantomReference<Sample> phantomRef = new PhantomReference<>(sample, QUEUE);
        sample = null;
​
        new Thread(){
            @Override
            public void run() {
                while (true) {
                    System.out.println(phantomRef.get());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        Thread.currentThread().interrupt();
                    }
                    TEST_DATA.add(new byte[1024 * 1024 * 5]);
                }
            }
        }.start();
​
        new Thread(){
            @Override
            public void run() {
                while (true) {
                    Reference<? extends Sample> poll = QUEUE.poll();
                    if (poll != null) {
                        System.out.println("--- 虚幻引用对象被jvm回收了 ---- " + poll);
                        System.out.println(poll.isEnqueued());
                        System.out.println("--- 回收对象 ---- " + poll.get());
                    }
                }
            }
        }.start();
​
        try {
            Thread.currentThread().join();
        } catch (InterruptedException e) {
            System.exit(1);
        }
    }
}
class Sample {
    private final byte[] data;
​
    public Sample() {
        data = new byte[1024 * 1024 * 10];
    }
}

扩展：mybatis的缓存与redis结合使用

https://www.cnblogs.com/springlight/p/6374372.html

8）mybatis注解

@Options(useCache = true, flushCache = false, timeout = 10000) ： 一些查询的选项开关，比如useCache = true表示本次查询结果被缓存以提高下次查询速度，flushCache = false表示下次查询时不刷新缓存，timeout = 10000表示查询结果缓存10000秒。

@Results(value = { @Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR), @Result(property = "testText", column = "test_text", javaType = String.class, jdbcType = JdbcType.VARCHAR) }) ： 表示sql查询返回的结果集，@Results是以@Result为元素的数组，@Result表示单条属性-字段的映射关系，如：@Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR)可以简写为：@Result(id = true, property = "id", column = "test_id")，id = true表示这个test_id字段是个PK，查询时mybatis会给予必要的优化，应该说数组中所有的@Result组成了单个记录的映射关系，而@Results则单个记录的集合。

@Param("id") ：全局限定别名，定义查询参数在sql语句中的位置不再是顺序下标0,1,2,3....的形式，而是对应名称，该名称就在这里定义。

@ResultMap(value = "getByTestText") ：重要的注解，可以解决复杂的映射关系，包括resultMap嵌套，鉴别器discriminator等等。注意一旦你启用该注解，你将不得不在你的映射文件中配置你的resultMap，而value = "getByTestText"即为映射文件中的resultMap ID(注意此处的value = "getByTestText"，必须是在映射文件中指定命名空间路径)。@ResultMap在某些简单场合可以用@Results代替，但是复杂查询，比如联合、嵌套查询@ResultMap就会显得解耦方便更容易管理。

9）mybatis中的OGNL

OGNL表达式(对象视图导航语言)，支持比EL表达式更丰富的语法。

MyBatis中可以使用OGNL的地方有两处：

动态SQL表达式中

<select id="xxx" ...>
    select id,name,... from country
    <where>
        <if test="name != null and name != ''">
            name like concat('%', #{name}, '%')
        </if>
    </where>
</select>

上面代码中test的值会使用OGNL计算结果。

<select id="xxx" ...>
    select id,name,... from country
    <bind name="nameLike" value="'%' + name + '%'"/>
    <where>
        <if test="name != null and name != ''">
            name like #{nameLike}
        </if>
    </where>
</select>

这里<bind>的value值会使用OGNL计算。

${param}参数中

<select id="xxx" ...>
    select id,name,... from country
    <where>
        <if test="name != null and name != ''">
            name like '${'%' + name + '%'}'
        </if>
    </where>
</select>

这里注意写的是${'%' + name + '%'}，而不是%${name}%，这两种方式的结果一样，但是处理过程不一样。

在MyBatis中处理${}的时候，只是使用OGNL计算这个结果值，然后替换SQL中对应的${xxx}，OGNL处理的只是${这里的表达式}。

这里表达式可以是OGNL支持的所有表达式，可以写的很复杂，可以调用静态方法返回值，也可以调用静态的属性值。

10）java代码块

10.1 静态代码块

在java类中（方法中不能存在静态代码块）使用static关键字和{}声明的代码块：

publicclass CodeBlock {
    static{
        System.out.println("静态代码块");
    }
}

---

​

执行时机：静态代码块在类被加载的时候就运行了，而且只运行一次，并且优先于各种代码块以及构造函数。如果一个类中有多个静态代码块，会按照书写顺序依次执行。

静态代码块的作用：一般情况下，如果有些代码需要在项目启动的时候就执行，这时候就需要静态代码块。比如一个项目启动需要加载的很多配置文件等资源，我们就可以都放入静态代码块中。

静态代码块不能存在任何方法体中：这个应该很好理解，首先我们要明确静态代码块是在类加载的时候就要运行了。我们分情况讨论：

　　对于普通方法，由于普通方法是通过加载类，然后new出实例化对象，通过对象才能运行这个方法，而静态代码块只需要加载类之后就能运行了。

　　对于静态方法，在类加载的时候，静态方法也已经加载了，但是我们必须要通过类名或者对象名才能访问，也就是说相比于静态代码块，静态代码块是主动运行的，而静态方法是被动运行的。

　　不管是哪种方法，我们需要明确静态代码块的存在在类加载的时候就自动运行了，而放在不管是普通方法还是静态方法中，都是不能自动运行的。

静态代码块不能访问普通变量：这个理解思维同上，普通变量只能通过对象来调用，是不能放在静态代码块中的。

10.2 构造代码块

在java类中使用{}声明的代码块（和静态代码块的区别是少了static关键字）:

public class CodeBlock {
    static{
        System.out.println("静态代码块");
    }
    {
        System.out.println("构造代码块");
    }
}

---

​

执行时机：构造代码块在创建对象时被调用，每次创建对象都会调用一次，但是优先于构造函数执行。需要注意的是，听名字我们就知道，构造代码块不是优先于构造函数执行，而是依托于构造函数，也就是说，如果你不实例化对象，构造代码块是不会执行的。

构造代码块的作用：和构造函数的作用类似，都能对对象进行初始化，并且只要创建一个对象，构造代码块都会执行一次。但是反过来，构造函数则不一定每个对象建立时都执行（多个构造函数情况下，建立对象时传入的参数不同则初始化使用对应的构造函数）。利用每次创建对象的时候都会提前调用一次构造代码块特性，我们可以做诸如统计创建对象的次数等功能。

10.3 构造函数

1.构造函数的命名必须和类名完全相同。在java中普通函数可以和构造函数同名，但是必须带有返回值；

2.构造函数的功能主要用于在类的对象创建时定义初始化的状态。它没有返回值，也不能用void来修饰。这就保证了它不仅什么也不用自动返回，而且根本不能有任何选择。而其他方法都有返回值，即使是void返回值。尽管方法体本身不会自动返回什么，但仍然可以让它返回一些东西，而这些东西可能是不安全的；

3.构造函数不能被直接调用，必须通过new运算符在创建对象时才会自动调用；而一般的方法是在程序执行到它的时候被调用的；

4.当定义一个类的时候，通常情况下都会显示该类的构造函数，并在函数中指定初始化的工作也可省略，不过Java编译器会提供一个默认的构造函数.此默认构造函数是不带参数的。而一般的方法不存在这一特点；

10.4 普通代码块

普通代码块和构造代码块的区别是，构造代码块是在类中定义的，而普通代码块是在方法体中定义的。且普通代码块的执行顺序和书写顺序一致。

publicvoid sayHello(){
    {
        System.out.println("普通代码块");
    }
}

10.5 执行顺序

静态代码块>构造代码块>构造函数>普通代码块　

父类与子类：

首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，当子类的静态内容执行完毕之后，再去看父类有没有构造代码块，如果有就执行父类的构造代码块，父类的构造代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有构造代码块，如果有就执行子类的构造代码块。子类的构造代码块执行完毕再去执行子类的构造方法。

总之一句话，静态代码块内容先执行，接着执行父类构造代码块和构造方法，然后执行子类构造代码块和构造方法。

11）mybatis与hibernate的区别

相同点：

都是java中orm框架、屏蔽jdbc api的底层访问细节，使用我们不用与jdbc api打交道，就可以完成对数据库的持久化操作。jdbc api编程流程固定，还将sql语句与java代码混杂在了一起，经常需要拼凑sql语句，细节很繁琐。

mybatis的好处：屏蔽jdbc api的底层访问细节；将sql语句与java代码进行分离;提供了将结果集自动封装称为实体对象和对象的集合的功能.queryForList返回对象集合，用queryForObject返回单个对象；提供了自动将实体对象的属性传递给sql语句的参数。

Hibername的好处：Hibernate是一个全自动的orm映射工具，它可以自动生成sql语句，并执行并返回java结果。

不同点：

1、hibernate要比ibatis功能强大很多。因为hibernate自动生成sql语句。

2、ibatis需要我们自己在xml配置文件中写sql语句，hibernate我们无法直接控制该语句，我们就无法去写特定的高效率的sql。对于一些不太复杂的sql查询，hibernate可以很好帮我们完成，但是，对于特别复杂的查询，hibernate就很难适应了，这时候用ibatis就是不错的选择，因为ibatis还是由我们自己写sql语句。

ibatis可以出来复杂语句，而hibernate不能。

3、ibatis要比hibernate简单的多。ibatis是面向sql的，不同考虑对象间一些复杂的映射关系。

12）hibernate的缓存机制

Hibernate中的缓存分一级缓存和二级缓存。

一级缓存就是Session级别的缓存，在事务范围内有效是，内置的不能被卸载。二级缓存是SesionFactory级别的缓存，从应用启动到应用结束有效。是可选的，默认没有二级缓存，需要手动开启。

保存数据库后，在内存中保存一份，如果更新了数据库就要同步更新。

什么样的数据适合存放到第二级缓存中？　

1) 很少被修改的数据    帖子的最后回复时间　

2) 经常被查询的数据    电商的地点

2) 不是很重要的数据，允许出现偶尔并发的数据 　　

3) 不会被并发访问的数据 　　

4) 常量数据

扩展：hibernate的二级缓存默认是不支持分布式缓存的。使用memcahe，redis等中央缓存来代替二级缓存。