参考博客

博客地址

Mybatis 生命周期和作用域

  • SqlSessionFactoryBuilder

作用在于创建 SqlSessionFactory ，创建成功后， SqlSessionFactoryBuilder 就失去了作用，所以它只能存在于创建 SqlSessionFactory 的方法中，而不是让其长期存在。
作用域：局部方法作用域

  • SqlSessionFactory

可以认为是一个数据库连接池，作用是创建 SqlSession 接口对象，生命周期存在于整个Mybatis应用之中，所以一旦创建，就要长期保存。同时， SqlSessonFactory 占用数据库的连接资源，如果创建多个，那么就存在多个数据库连接池，这样不利于对数据库的资源控制，可能会导致连接资源被消耗光，出现系统宕机的情况。
所以应该用单例模式创建 SqlSessionFactory 。
作用域： 应用作用域

  • SqlSession

相当于一个数据库连接（Connection对象），可以在一个事务里面执行多条SQL，然后通过commit、rollback等方法，提交或回滚事务。所以 SqlSession 应该存活在一个业务请求中，处理完整的请求后，应该关闭这条连接，并归还给 SqlSessionFactory ，否则数据库资源就很快被消耗光，造成系统瘫痪。可以使用 try ... catch ... finally ... 语句来保证正确关闭。
作用域：请求或方法作用域

#{} 和 ${} 的区别是什么

  • ${} 是Properties文件变量的占位符，他可以用于标签属性和sql内部，属于静态文本替换，比如${driver}会被静态替换为 com.mysql.jdbc.Driver
  • #{} 是sql参数占位符，Mybatis会将sql中 #{} 替换为?号，在sql执行前使用预编译的参数设置方法，按照顺序给sql的?号占位符设置参数值。比如 #{item.name} 的取值方式为使用反射从参数对象中获取item对象的name值。

xml映射文件中，除了常见的select|insert|update|delete标签外，还有哪些标签

  1. <resultMap></resultMap>
  3. <parameterMap></parameterMap>
  5. <sql></sql>
  7. <include />
  9. <selectKey>
  11. ### 动态sql标签
  12. <trim>
  14. <where>
  16. <set>
  18. <foreach>
  20. <if>
  22. <choose>
  24. <when>
  26. <otherwise>
  28. <bind>

通常一个xml映射文件，都会写一个Dao接口与之对应，请问，这个Dao接口的工作原理是什么，Dao接口里的方法，参数不同时，方法能重载吗？

Dao接口（Mapper接口）
接口的全限名，就是映射文件的 namespace 的值

  1. <mapper namespace="com.ly.ybg.**.*Mapper">...</mapper>

接口方法名，就是映射文件中 MappedStatement 的id值

  1. <select id="selectById"></select>

接口方法内的参数，就是传递给sql的参数。
Mapper 接口是没有实现类的，当调用接口方法时，接口全限名+方法名凭借字符串作为key，可唯一定位一个 MapperStatement 

  1. com.ly.ybg.mapper.StudentMapper.selectById 
  2. 可以唯一找到namespace为 com.ly.ybg.mapper.StudentMapper 下 id="selectById"的MappedStastment。

在Mybatis中，每一个 <select> 、 <insert> 、 update 、 <delete> 标签，都会被解析为一个MappedStatement对象。

Dao接口里的方法，是不能重载的，因为是 全限名 + 方法名的保存和寻找策略。

Dao接口的工作原理是JDK动态代理，Mybatis运行时会使用JDK动态代理为Dao接口生成代理的Proxy对象，代理对象Proxy会拦截接口方法，转而执行MappedStatement所代表的sql，然后将sql执行结果返回。

Mybatis是如何分页的？分页插件的原理是什么？

Mybatis使用 RowBounds 对象进行分页，它是针对ResultSet结果集执行的内存分页，而非物理分页，可以在sql内直接书写带有物理分页的参数来完成物理分页功能，也可以使用分页插件来完成物理分页。

分页插件的基本原理是使用Mybatis提供的插件接口，来实现自定义插件，在插件的拦截方法内拦截待执行的sql，然后重写sql，根据dialect方法，添加对应的物理分页语句和物理分页参数。

简述Mybatis的插件运行原理，以及如何编写一个插件

Mybaits仅可以编写针对 ParameterHandler 、 ResultSetHandler 、 StatementHandler 、 Executor 这4种接口的插件，Mybatis使用JDK的动态代理，为需要拦截的接口生成代理对象以实现接口方法的拦截功能，每当执行这4种接口对象的方法时，就会进入拦截方法，具体就是 InvocationHandler 的 invoke 方法，当然，只会拦截那些你指定需要拦截的方法。

实现Mybatis的 Interceptor 接口并重写 intercept 方法，然后再给插件编写注解，指定要拦截哪一个接口的哪些方法即可。

Mybaits动态sql是做什么的？都有那些动态sql？能简述一下动态sql的执行原理吗？

Mybaits动态sql可以让我们在xml映射文件内，以标签的形式编写动态sql，完成逻辑判断和动态拼接sql的功能。提供了9种sql标签 trim|where|set|foreach|if|choose|when|otherwise|bind

执行原理为，使用OGNL从sql参数对象中计算表达式的值，根据表达式的值动态拼接sql，以此来完成动态sql的功能。

  1. # if
  2. <select id="queryBlogIf" parameterType="map" resultType="blog">
  3.   select * from blog where
  4.    <if test="title != null">
  5.       title = #{title}
  6.    </if>
  7.    <if test="author != null">
  8.       and author = #{author}
  9.    </if>
  10. </select>
  12. # where
  13. <select id="queryBlogIf" parameterType="map" resultType="blog">
  14.   select * from blog
  15.    <where>
  16.        <if test="title != null">
  17.           title = #{title}
  18.        </if>
  19.        <if test="author != null">
  20.           and author = #{author}
  21.        </if>
  22.    </where>
  23. </select>
  25. # set
  26. <update id="updateBlog" parameterType="map">
  27.   update blog
  28.      <set>
  29.          <if test="title != null">
  30.             title = #{title},
  31.          </if>
  32.          <if test="author != null">
  33.             author = #{author}
  34.          </if>
  35.      </set>
  36.   where id = #{id};
  37. </update>
  39. # choose when otherwise 类似java中的switch语句
  40. <select id="queryBlogChoose" parameterType="map" resultType="blog">
  41.   select * from blog
  42.    <where>
  43.        <choose>
  44.            <when test="title != null">
  45.                 title = #{title}
  46.            </when>
  47.            <when test="author != null">
  48.               and author = #{author}
  49.            </when>
  50.            <otherwise>
  51.               and views = #{views}
  52.            </otherwise>
  53.        </choose>
  54.    </where>
  55. </select>
  57. # sql
  58. <sql id="if-title-author">
  59.    <if test="title != null">
  60.       title = #{title}
  61.    </if>
  62.    <if test="author != null">
  63.       and author = #{author}
  64.    </if>
  65. </sql>
  67. <select id="queryBlogIf" parameterType="map" resultType="blog">
  68.   select * from blog
  69.    <where>
  70.        <!-- 引用 sql 片段，如果refid 指定的不在本文件中，那么需要在前面加上 namespace -->
  71.        <include refid="if-title-author"></include>
  72.        <!-- 在这里还可以引用其他的 sql 片段 -->
  73.    </where>
  74. </select>
  76. # foreach
  77. <select id="queryBlogForeach" parameterType="map" resultType="blog">
  78.   select * from blog
  79.    <where>
  80.        <!--
  81.        collection:指定输入对象中的集合属性
  82.        item:每次遍历生成的对象
  83.        open:开始遍历时的拼接字符串
  84.        close:结束时拼接的字符串
  85.        separator:遍历对象之间需要拼接的字符串
  86.        select * from blog where 1=1 and (id=1 or id=2 or id=3)
  87.      -->
  88.        <foreach collection="ids"  item="id" open="and (" close=")" separator="or">
  89.           id=#{id}
  90.        </foreach>
  91.    </where>
  92. </select>

Mybatis缓存，一级缓存，一级缓存失效情况，二级缓存工作机制

缓存是存在内存中的临时数据。 将用户经常查的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据库数据文件）查询，从缓存中查询，从而提高查询效率，解决高并发系统的性能问题。
使用缓存可以减少和数据库的交互次数，减少系统开销，提高系统效率。
通常那些经常查询且不经常改变的数据都可以使用缓存。

Mybatis定义了两级缓存， 一级缓存和二级缓存。

  • 默认情况下，只有一级缓存开启（SqlSession级别的缓存，也称为本地缓存）
  • 二级缓存需要手动开启和配置，是基于namespace级别的缓存

一级缓存
与数据库同义词会话期间查询到的数据会存放在本地缓存中。
以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库。

一级缓存失效的四种情况

  • sqlSession不同
  • sqlSession相同，查询条件不同
  • sqlSession相同，两次查询寻之间执行了增删改的操作
  • sqlSession相同，手动清除了一级缓存

二级缓存
二级缓存也成为全局缓存，一级缓存作用域太低了，所以诞生了二级缓存。
基于namespace级别的缓存，一个名称空间，对应一个二级缓存。

工作机制：

  • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中。
  • 如果当前会话关闭了，一级缓存中的数据会保存在二级缓存中。
  • 新的会话查询信息，就可以从二级缓存中获取内容。
  • 不同的mapper查询的数据都会放在自己对应的缓存（map）中。

配置

  1. <setting name="cacheEnabled" value="true"/>

只要开启二级缓存，我们在同一个Mapper中的查询，都可以在二级缓存中拿到数据。
查出来的数据都会默认先放在一级缓存中
只有会话提交或者关闭以后，一级缓存中的数据才会转到二级缓存。

Mybaits是如何将sql执行结果封装为目标对象并返回的？都有哪些映射形式

  • 使用 <resultMap> 标签，逐一定义列名和对象属性名之间的映射关系
  • 使用sql列的别名功能，将列别名书写为对象的属性名， 例如 T_NAME as NAME, 对象属性名一般为小写，但是列名不区分大小写，mybatis会忽略列名大小写，智能找到对应对象属性名。

有了列名与属性的映射关系后，Mybatis通过反射创建对象，同时使用反射给对象的属性逐一赋值并返回，那些找不到映射关系的属性，是无法完成赋值的。

Mybatis能执行一对一，一对多的关联查询吗？ 都有哪些实现方式，以及他们的区别?

Mybaits 可以执行一对一，一对多，多对一，多对多的关联查询。

关联对象查询，有两种实现方式。一种是单独发送一个sql去查询关联对象，写给主对象，然后返回主对象。
另外一种是使用嵌套查询，嵌套查询的含义为使用join查询，一部分列是A对象的属性值，另外一部分列是关联对象B的属性值，好处是只发一个sql查询，就可以把主对象和关联对象查出来。

  1. // 一对一, 多对一
  2. <assocation></assocation>
  4. # 数据表
  5. student表
  6. id  | name | tid
  8. teacher表
  9. id  | name
  11. # 学生对应一个老师，即从学生这边关联一个老师
  12. public class Student {
  13.     private String id;
  14.     private String name;
  15.     private Teacher teacher;
  16. }
  17. private class Teacher {
  18.     private String id;
  19.     private String name;
  20. }
  22. # Mapper接口
  23. public interface StudentMapper {
  24. }
  26. public interface TeacherMapper {
  27. }
  29. # mapper.xml配置
  30. <?xml version="1.0" encoding="UTF-8" ?>
  31. <!DOCTYPE mapper
  32.        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  33.        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  34. <mapper namespace="com.ly.ybg.mapper.StudentMapper">
  36. </mapper>
  38. <?xml version="1.0" encoding="UTF-8" ?>
  39. <!DOCTYPE mapper
  40.        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  41.        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  42. <mapper namespace="com.ly.ybg.mapper.TeacherMapper">
  44. </mapper>
  46. #mapper.xml sql语句
  47. <resultMap id="StudentTeacher" type="Student">
  48.   // property Student属性名
  49.   // column 在多的一方的表中的列名
  50.   // javaType 属性类型
  51.   <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
  52. </resultMap>
  54. <select id="getStudents" resultMap="StudentTeacher">
  55.     select * from student
  56. </select>
  58. <select id="getTeacher" resultType="teacher">
  59.       select * from teacher where id = #{id}
  60. </select>
  1. // 一对多
  2. <collection></collection>
  4. # 数据表
  5. student表
  6. id  | name | tid
  8. teacher表
  9. id  | name
  11. # 学生对应一个老师，即从学生这边关联一个老师
  12. public class Student {
  13.     private String id;
  14.     private String name;
  15.     private Teacher teacher;
  16. }
  17. private class Teacher {
  18.     private String id;
  19.     private String name;
  20. }
  22. # Mapper接口
  23. public interface StudentMapper {
  24. }
  26. public interface TeacherMapper {
  27. }
  29. # mapper.xml配置
  30. <?xml version="1.0" encoding="UTF-8" ?>
  31. <!DOCTYPE mapper
  32.        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  33.        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  34. <mapper namespace="com.ly.ybg.mapper.StudentMapper">
  36. </mapper>
  38. <?xml version="1.0" encoding="UTF-8" ?>
  39. <!DOCTYPE mapper
  40.        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  41.        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  42. <mapper namespace="com.ly.ybg.mapper.TeacherMapper">
  44. </mapper>
  46. #mapper.xml sql语句
  47. <resultMap id="TeacherStudent" type="Teacher">
  48.   <result  property="name" column="tname"/>
  49.   // 集合
  50.   // property Teacher属性
  51.   // ofType 指定映射到list集合属性中的pojo对象
  52.   <collection property="students" ofType="Student">
  53.     <result property="id" column="sid" />
  54.     <result property="name" column="sname" />
  55.     <result property="tid" column="tid" />
  56.   </collection>
  57. </resultMap>
  59.  <select id="getTeacher" resultMap="TeacherStudent">
  60.    select s.id sid, s.name sname , t.name tname, t.id tid
  61.    from student s,teacher t
  62.    where s.tid = t.id and t.id=#{id}
  63.  </select>
  65. <resultMap id="TeacherStudent2" type="Teacher">
  66.    <!--column是一对多的外键 , 写的是一(Teacher)的主键的列名-->
  67.    <collection property="students" javaType="ArrayList" ofType="Student" 
  68.                column="id" select="getStudentByTeacherId"/>
  69. </resultMap>
  71. <select id="getTeacher2" resultMap="TeacherStudent2">
  72.     select * from teacher where id = #{id}
  73. </select>    
  75. <select id="getStudentByTeacherId" resultType="Student">
  76.   select * from student where tid = #{id}
  77. </select>

Mybaits是否支持延迟加载？如果支持，它的实现原理是什么

Mybatis仅支持 assocation 关联对象和 collection 关联集合对象的延迟加载， assocation 指的就是一对一， collection 指的就是一对多的查询，在Mybaits配置文件中，可以配置是否启用延迟加载 lazyLoadingEnabled=true|false

原理：使用 CGLIB 创建目标对象的代理对象，当调用目标方法时，进入拦截器方法，比如调用 a.getB().getName() ，拦截器 invoke() 方法发现 a.getB() 是null值，那么就会单独发送事先保存好的查询关联B对象的sql，把B查询上来，然后调用a.setB(b)，于是a的对象b属性就有值了，接着完成a.getB().getName()方法的调用。这就是延迟加载的本质。

Mybatis的xml映射文件中，不同的xml映射文件，id是否可以重复

不同的xml映射文件，如果配置了namespace，那么id可以重复；如果没有配置namespace，那么id不能重复。
原因是 namepace+id 是作为 Map<String, MappedStatement> 的key使用的，如果没有namespace，只有id，那么id重复会导致数据互相覆盖，有了namespace，自然id就可以重复，namespace不同，namespace+id自然就不同。

Mybatis中如何执行批处理？

使用BatchExecutor完成批处理。

Mybatis都有哪些Executor执行器？他们之间的区别是什么？

Mybaits有三种基本的Executor执行器， SimpleExecutor 、 ReuseExecutor 、 BatchExecutor

SimpleExecutor： 每次执行一次update 或 select， 就开启一个Statement对象，用完立即关闭Statement对象。

ReuseExecutor： 执行 update 或 select， 以sql作为key查找Statement对象，存在就使用，不存在就创建，用完后，不关闭Statement对象，而是放置于Map 内，供下一次使用。就是重复使用Statement对象。

BatchExecutor： 执行update（没有select， JDBC批处理不支持select），将所有的sql都添加到批处理（addBatch()），等地啊统一执行（executeBatch()）,它缓存了多个Statement对象，每个Statement对象都是addBatch() 完毕后，等待逐一执行executeBatch() 批处理。与JDBC批处理相同。

Mybatis中如何指定使用哪一种Executor执行器？

在Mybatis配置文件中，可以指定默认的ExecutorType执行器类型，也可以手动给 DefaultSqlSessionFactory 的创建SqlSession的方法传递ExecutorType类型。

简述Mybatis的xml映射文件和Mybatis内部数据结构之间的映射关系？

Mybaits将所有的xml配置信息都封装在All-In-One重量级对象Configuration内部。
在xml映射文件中， <parameterMap> 标签被解析为 ParameterMap 对象， 其每个子元素都会被解析为 ParameterMapping 对象。
resultMap 标签会被解析为 ResultMap 对象，其每个子元素都会被解析为 ResultMapping 对象。
每一个 select 、 insert 、 update 、 delete 标签均会被解析为 MappedStatement 对象，标签内的sql会被解析为 BoundSql 对象。

为什么说Mybatis是半自动ORM映射工具？它与全自动的区别在哪里？

Hibernate属于全自动ORM映射工具，使用Hibernate查询关联对象或者关联集合对象时，可以根据对象关系模型直接获取，所以它全自动的。而Mybatis在查询关联对象或关联结合时，需要手动编写sql来完成，所以称之为半自动ORM映射工具。