查看更多宝典，请点击《金三银四，你的专属面试宝典》
第五章：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等中央缓存来代替二级缓存。