复习宝典之MyBatis

时间  2019-12-13
标签 复习 宝典 mybatis 栏目 MyBatis 繁體版
原文   原文链接

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

第五章：MyBatis

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

 

1）建立sqlsession的流程

mybatis进行持久化操做时重要的几个类： SqlSessionFactoryBuilder：build方法建立SqlSessionFactory实例。 SqlSessionFactory：建立SqlSession实例的工厂。 SqlSession：用于执行持久化操做的对象，相似于jdbc中的Connection。 SqlSessionTemplate：MyBatis提供的持久层访问模板化的工具，线程安全，可经过构造参数或依赖注入SqlSessionFactory实例。web

 

2）配置文件相关

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

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

　　②、type="MANAGED"：这个配置几乎没作什么。它历来不提交或回滚一个链接，而是让容器来管理事务的整个生命周期（好比 JEE 应用服务器的上下文）。 默认状况下它会关闭链接，然而一些容器并不但愿这样，所以须要将 closeConnection 属性设置为 false 来阻止它默认的关闭行为。算法

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

 

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

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的对象

取值说明：

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

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

三、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结合使用

http://www.javashuo.com/article/p-sintyuyy-ht.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关键字和{}声明的代码块：

public` `class` `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 普通代码块

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

public` `void` `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结果。

不一样点：

一、hibernate要比ibatis功能强大不少。由于hibernate自动生成sql语句。

二、ibatis须要咱们本身在xml配置文件中写sql语句，hibernate咱们没法直接控制该语句，咱们就没法去写特定的高效率的sql。对于一些不太复杂的sql查询，hibernate能够很好帮咱们完成，可是，对于特别复杂的查询，hibernate就很难适应了，这时候用ibatis就是不错的选择，由于ibatis仍是由咱们本身写sql语句。

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

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

 

12）hibernate的缓存机制

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

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

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

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

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

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

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

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

4) 常量数据

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

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程