1000道互联网java面试题（一）Mybatis面试题-CFANZ编程社区

打个广告，java技术交流群130031711，群里好多学习资料。欢迎各位萌新大佬踊跃加入！

我不知道别人是不是也像我这样，看过一次的题目，过不几天就忘了。尤其是一些冷门的知识点，可能转头就忘了。
算了，想说的话太多又觉得没有必要。
这又是一个记录系列。看过的东西一定要记录下来才会深刻。
然后这个资料是一个朋友传给我的，在此表示感谢。另外这个资料的名字就叫做1000道题。
因为我已经看过一半左右了，有些我觉得略有落伍的知识点或者不好理解的知识点我就不列出来了。所以不出意外我整理出来的都是我觉得被问到的几率大，好理解而且有用的知识点。个人色彩比较浓，不喜勿喷。

Mybatis面试题

1. 什么是mybatis？

Mybatis 是一个半 ORM（对象关系映射）框架，它封装了 JDBC，开发时只需要关注 SQL 语句本身，不需要处理加载驱动、创建连接、创建 statement 等繁杂的过程。程序员直接编写原生sql语句，可以严格控制 sql 执行性能，灵活度高。
MyBatis 可以使用 XML 或注解来配置和映射原生信息，将 POJO（实体对象）映射成数据库中的记录，避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。
通过 xml 文件或注解的方式将要执行的各种 statement 配置起来，并通过 java 对象和 statement 中 sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis框架执行sql并将结果映射为 java 对象并返回。（从执行 sql 到返回 result 的过程）。

简单来讲，我觉得最主要的一句话概括：就是对jdbc进行了封装，从而使得开发更加容易。另外我不知道这个书是什么时候出的，但是在2020年的现在，单纯使用mybatis的也不算很多了吧。反正我是从去年开始用mybatis plus的。在mybatis的基础上又是一层封装。不说实现的原理，反正直接使用给人的感觉和jpa越来越像了，都是有了简单sql的直接调用。比如insert，update，del，简单的select等。而且mp的条件构造器是真的好用。。哈哈！扯远了，上面的三点是书中对mybatis的介绍，都是很容易理解的，我就不多说了。

2. Mybaits的优点：

其实优点要相对用说的，我感觉这个答案适合用自己的话说。

首先，与原生jdbc相比，因为做了一层封装，所以减少了很多繁杂的操作，消除了大量冗余的代码。不需要手动开关连接。
基于sql语句编程，比较灵活。不会对应用程序或者数据库的现有设计有任何影响。而且mybatis的sql可以写在XML文件里，也算是解除了sql与程序代码的耦合。便于统一管理。支持编写动态sql语句。（ps：mybatis也支持注释上写sql。不过一般不建议这么用）
jdbc支持的数据库mybatis都支持（这个很好理解吧）。很好的数据库兼容。
能与spring很好的集成。
提供映射标签，支持对象与数据库的字段关系映射（我理解就是能把对象持久化到数据库中）。

3. Mybatis的缺点：

SQL 语句的编写工作量较大，尤其当字段多、关联表多时，对开发人员编写 SQL 语句的功底有一定要求。（感觉这个缺点其实不算是缺点。因为用jdbc还是用hibernate也都是这样的。尤其是复杂sql 的时候hibernate还不如mybatis呢）
SQL 语句依赖于数据库，导致数据库移植性差，不能随意更换数据库。（这个怎么说呢，确实是和hibernate相比这个算是一个缺点。不过也仅仅限于简单的sql。我记得我以前就说过：复杂SQL多的用mybatis。简单sql多的可以直接jpa。我现在也是这个观点。不过mp的出现，让mybatis处理简单sql也更方便了一些。现在总体上我还是喜欢mybatis）

4. Mybatis框架适用于什么场景?

MyBatis 专注于 SQL 本身，是一个足够灵活的 DAO 层解决方案。
对性能的要求很高，或者需求变化较多的项目，如互联网项目，MyBatis 将是不错的选择。

其实我觉得这个题的答案太笼统了。而且我有好多技术交流群嘛，看到过的jpa党和mybatis党吵架好多次。所以听到看到好说说法。首先什么叫对性能要求高使用mybatis？jpa性能不好？这个是一种传统的错觉。最开始我记得我学习的时候确实听说过hibernate比较重，性能略差。但是我之前一个群友较真，用两个框架分别跑一样功能的接口。hibernate偶尔性能比mybatis还好呢！jpa没用想的那么差了。
另外需求变化较多的项目。都是简单的crud，哪怕需求变化较多也应该是jpa首选吧？我觉得我的角度，是当字段多，关联表多，业务功能复杂的时候，mybatis是首选。
但是具体情况具体分析，这个又不是1+1等于2这种有确切答案的。我就不多BB了。

5. Mybatis与Hibernate有哪些不同？

Mybatis 和 hibernate 不同，它不完全是一个 ORM 框架，因为 MyBatis 需要程序员自己编写 Sql 语句。
Mybatis 直接编写原生态 sql，可以严格控制 sql 执行性能，灵活度高，非常适合对关系数据模型要求不高的软件开发，因为这类软件需求变化频繁，一但需求变化要求迅速输出成果。但是灵活的前提是 mybatis 无法做到数据库无关性，如果需要实现支持多种数据库的软件，则需要自定义多套 sql 映射文件，工作量大。
Hibernate 对象/关系映射能力强，数据库无关性好，对于关系模型要求高的软件，如果用 hibernate 开发可以节省很多代码，提高效率

又来BB了，首先其实两者最大的不同就是Mybatis是半ORM框架，要自己写sql语句。而Hibernate是全自动ORM框架，hibernate可以自动生成SQL语句，自动执行。而剩下的点是这个问题衍生出来的：

因为mybatis自己写sql，所以如果数据库换了，sql也不一样。所以要全盘更改或者一开始就写多套sql映射文件。而Hibernate不同，sql也不是我们写的，数据库换了hibernate自己就会换语句。总结起来数据库无关性不一样。
另外因为hibernate是对象/数据库直接映射的，所以如果数据库频繁改动，会对代码的改动较大（不过我觉得现在二者的高度封装，在单纯的调用上来讲已经差不多了）。而mybatis则相对灵活。

6. #{}和${}的区别是什么？

这个题我觉得蛮好的，划重点！！！

#{}是预编译处理，${}是字符串替换。

Mybatis 在处理#{}时，会将 sql 中的#{}替换为?号，调用 PreparedStatement 的 set 方法来赋值；
Mybatis 在处理{}替换成变量的值。
使用#{}可以有效的防止 SQL 注入，提高系统安全性。

7. 当实体类中的属性名和表中的字段名不一样，怎么办？

这个题怎么说呢，因为资料中是用xml实现的，
方法1：在sql语句中用别名的方法实现的。

<select id=”selectorder” parametertype=”int” resultetype=” me.gacl.domain.order”>
 select order_id id, order_no orderno ,order_price price form orders where order_id=#{id}; 
</select>

方法2：通过<resultMap>来映射字段名和实体类属性名的一一对应的关系。

<select id="getOrder" parameterType="int" resultMap="orderresultmap">
 select * from orders where order_id=#{id}
 </select>
<resultMap type=”me.gacl.domain.order” id=”orderresultmap”> 
<!–用id属性来映射主键字段–>
 <id property=”id” column=”order_id”>
<!–用result属性来映射非主键字段，property为实体类属性名，column 为数据表中的属性–> 
<result property = “orderno” column =”order_no”/>
 <result property=”price” column=”order_price” /> 
</reslutMap>

但是说真的，我感觉我快一年没写xml了。。用mybatis plus的时候，可以直接在实体对象上用注释标注出这个属性的数据库中字段名是什么（如果是下划线转驼峰是不用写的。这个是默认配置）。

8. 模糊查询like语句该怎么写?

这个题怎么说呢，我觉得是蛮水的，然后答案还不少，都是xml代码。所以我也不说了，其实就是在参数上加通配符。想怎么模糊就怎么加。另外也可以在sql语句中拼接“%”，但是我没这么用过。据说是会引入sql注入。
然后再吹一波mybatis plus。mp的条件构造器中可以直接like（字段，值）。说实话我没看过mp源码是怎么实现的。但是既然都成为框架了，我还是觉得应该很安全的。

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

Dao 接口即 Mapper 接口。接口的全限名，就是映射文件中的 namespace 的值；接口的方法名，就是映射文件中 Mapper 的 Statement 的 id 值；接口方法内的参数就是传递给 sql 的参数。
Mapper 接口是没有实现类的，当调用接口方法时，接口全限名+方法名拼接字符串作为 key 值，可唯一定位一个 MapperStatement。在 Mybatis 中，每一个 <select>、<insert>、<update>、<delete>标签，都会被解析为一个 MapperStatement 对象。
Mapper 接口里的方法，是不能重载的，因为是使用全限名+方法名的保存和寻找策略。Mapper 接口的工作原理是 JDK 动态代理，Mybatis 运行时会使用 JDK 动态代理为 Mapper 接口生成代理对象proxy，代理对象会拦截接口方法,转而执行 MapperStatement 所代表的 sql，然后将 sql 执行结果返回。

这个说的比较长。然后我长话短说总结下：首先mybatis每个方法对应的是一个sql。key是接口全限名+方法名，value是对应的sql。然后如果重载的话会破坏这种一对一的对应关系。所以不能重载！

10. Mybatis是如何进行分页的？分页插件的原理是什么？

Mybatis 使用 RowBounds 对象进行分页，它是针对 ResultSet 结果集执行的内存分页，而非物理分页。（简单来说一次都查出来，然后再把查出来的结果分页）
也可以在 sql 内直接书写带有物理分页的参数来完成物理分页功能，也可以使用分页插件来完成物理分页。

分页插件的基本原理是使用 Mybatis 提供的插件接口，实现自定义插件，在插件的拦截方法内拦截待执行的 sql，然后重写sql，根据 dialect 方言，添加对应的物理分页语句和物理分页参数。
简单说分页分两种：
1.查询出来的就是想要的页数。（物理分页）
2.查询全部再代码处理给想要的页数（内存分页）
分页插件的基本实现都是把sql拦截添加上物理分页后再执行。

再次不要脸的安利mybatis plus中已经封装好了一个分页的实现。代码如下（10是默认每页条数，page是页数）：

其实还有好多现成的分页插件，我就不多说了，百度一大堆。甚至知道原理了自己也可以做个分页的封装类。

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

第一种是使用<resultMap>标签，逐一定义数据库列名和对象属性名之间的映射关系。
第二种是使用 sql 列的别名功能，将列的别名书写为对象属性名。

这个其实可以参考上面说的实体类的属性和列的名字不一样时怎么处理。不过我之前就说过现在很少用xml做映射了，而是直接entity和表映射。如果名字是一样的（下划线转驼峰算是默认的，可以算作是一样的）直接映射。如果属性名和列名不一样是有注解可以表示当前属性对应哪个列名的。
有了列名与属性名的映射关系后，Mybatis通过反射创建对象，同时使用反射给对象的属性逐一赋值并返回，那些找不到映射关系的属性，是无法完成赋值的。

12. 如何执行批量插入？

其实这个批量插入和批量删除，一次一调用肯定是性能不太好，所以批量操作就显得很重要了。简单说下。有两种实现方式：

第一种：xml标签实现。我忘了上面有没有介绍xml的9种动态标签了。。没介绍下面也会介绍到的。这里简单说一下。可以用foreach标签实现。如下代码：
在dao层配置方法：

void batchInsert(@Param("orderItemList") List<User> user);

然后在xml中写sql：

<!--批量插入-->
  <insert id="batchInsert" parameterType="list">
    insert into  tb_order_item(id,user_name,password,nick_name,create_time,update_time)
    values
    <foreach collection="orderItemList" index="index" item="item" separator=",">
      (
        #{item.id},#{item.userName},#{item.password},#{item.nickName}},now(),now()
      )
    </foreach>
  </insert>

如上代码，这样就实现了一个批量插入的功能（批量删除差不多也是同理，只不过不用是集合而是数组就行了）

第二种就是使用ExecutorType.BATCH方式执行批量操作。
Mybatis内置的ExecutorType有3种，默认的是simple，该模式下它为每个语句的执行创建一个新的预处理语句，单条提交sql；而batch模式重复使用已经预处理的语句，并且批量执行所有更新语句，显然batch性能将更优；
但batch模式也有自己的问题，比如在Insert操作时，在事务没有提交之前，是没有办法获取到自增的id，这在某型情形下是不符合业务要求的。
下面是代码示例：
首先是创建一个简单的单条插入的方法（我就不创建了），然后代码中用batch的方法插入：

        SqlSessionFactory factory = MyBatisTools.getInstance().getSessionFactory();
        SqlSession sqlSession = factory.openSession(ExecutorType.BATCH, false);
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        for(User user : users) {
            userDao.save(user);
            }
        }
        sqlSession.flushStatements();
        sqlSession.commit();//真正插入操作。
        sqlSession.close();

这段代码实际写的时候可能是有异常的，反正我是整个扔出去了，正常该try-catch还是要catch下的。记得sqlSession最后要关闭。

13. 如何获取自动生成的(主)键值?

insert 方法总是返回一个 int 值，这个值代表的是插入的行数。
如果采用自增长策略，自动生成的键值在 insert 方法执行完后可以被设置到传入的参数对象中。如果是mybatis的话，在xml中配置下就行。
insert 标签中中加入 usegeneratedkeys=”true” keyproperty=”id”。如下：

<insert id=”insertname” usegeneratedkeys=”true” keyproperty=”id”>
    insert into names (name) values (#{name})
</insert>

然后在我们调用的时候如insert完，之前的哪个实体对象的id会自动被传入，直接获取就行了。

name name = new name();
name.setname(“fred”);
int rows = mapper.insertname(name);
// 完成后,id 已经被设置到对象中
system.out.println(“generated key value = ” + name.getid());

继续和实际联系，一直我都说的mybatis plus其实这块做的更好。如果在entity的主键上设置了id自增，那么插入后会自动传id到实体，不用做额外的配置操作。

14. 在mapper中如何传递多个参数?

其实这个题怎么说呢，我觉得真的蛮老了。。简单来说三种方式：

dao层直接传多个，用0，1，2，3获取。
用注解的方式为每一个参数确定名字。到时候根据名字获取。
封装成map。然后从map中取对应key的值。

总体来说现在常用的我感觉是第二种方式的更简版。就是不非要写注解了。但是也可以直接用#{变量名}来获取。不过这个变量名非要一模一样应该都可以理解。然后我就不贴代码了。这个题理解就得了。

Mybatis动态sql有什么用？执行原理？有哪些动态sql？

16. Xml映射文件中，除了常见的select|insert|updae|delete标签之外，还有哪些标签？

<resultMap>、<parameterMap>、<sql>、<include>、 <selectKey>，加上动态 sql 的 9 个标签，其中<sql>为 sql 片段标签，通过 <include>标签引入 sql 片段，<selectKey>为不支持自增的主键生成策略标签。另外之前主键自增获取主键的那两个。

17. Mybatis 的 Xml 映射文件中，不同的 Xml 映射文件，id 是否可以重复？

这个题其实和dao方法不能重载是一样的。namespace不一样可以重复，否则不可以。不多说了。

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

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

19. 一对一、一对多的关联查询？

就是在xml文件中配置子集。我随便网上找了个demo：

 <resultMap type="sol.erms.model.entity.process.use.ErmsUseMainExport" id="useMainResult">
        <result column="USE_NO" property="useNo" />
        <result column="ERMS_LENDER" property="ermsLender" />
        <result column="ERMS_LENDINGPURPOSE" property="ermsLendingpurpose" />
        <collection property="archList" ofType="sol.erms.model.entity.process.use.ERMSUseExport" column="id">
            <result column="ARCH_NAME" jdbcType="TIMESTAMP" property="archName" />
            <result column="ARCH_NO" jdbcType="VARCHAR" property="archNo" />
            <result column="ERMS_APPLYMODE" property="ermsApplymode" />
            <result column="START_USE_DATE" property="startUseDate" />
            <result column="ERMS_LENDHANDLER" property="ermsLendhandler" />
            <result column="ERMS_BORROW_REVIEWER" property="ermsBorrowReviewer" />
            <result column="ERMS_RETURNTIME" property="ermsReturntime" />
            <result column="ERMS_RETURNER" property="ermsReturner" />
            <result column="ERMS_RETURN_HANDLER" property="ermsReturnhandler" />
            <result column="ERMS_RETURN_REVIEWER" property="ermsReturnReviewer" />
        </collection>
    </resultMap>
 
<!--条件查询借阅+档案(集合)数据-->
    <select id="getMainListUseCollectionByCondition" resultMap="useMainResult">
        SELECT
            m.`USE_NO`,
            m.`ERMS_LENDER`,
            m.`ERMS_LENDINGPURPOSE`,
            m.ERMS_APPLYMODE,
            u.START_USE_DATE,
            u.ERMS_LENDHANDLER,
            u.ERMS_BORROW_REVIEWER,
            u.ERMS_RETURNTIME,
            u.ERMS_RETURNER,
            u.ERMS_RETURN_HANDLER,
            u.ERMS_RETURN_REVIEWER,
            a.ARCH_NO,
            a.ARCH_NAME
        FROM
            erms_use_main m
            LEFT JOIN erms_use u ON m.ID = u.ERMS_USE_MAIN_ID
            LEFT JOIN erms_archived_arch_ru a ON u.ERMS_ARCH_FORM_ID = a.ID
        <where>
            <if test="DEL_STATUS!=null and DEL_STATUS!=''">
                m.DEL_STATUS = #{DEL_STATUS}
            </if>
            <if test="ids!=null and ids.size()>0">
                m.ID IN
                <foreach collection="ids" item="id" open="(" close=")" separator="," >
                    #{id}
                </foreach>
            </if>
        </where>
    </select>

差不多就这样。但是我个人的话习惯于分两次查询。。不过也要酌情使用吧。

20. MyBatis实现一对一，一对多有几种方式?具体怎么操作的？

有联合查询和嵌套查询,联合查询是几个表联合查询,只查询一次, 通过在 resultMap 里面配置 association 节点配置一对一的类就可以完成；
嵌套查询是先查一个表，根据这个表里面的结果的外键 id，去再另外一个表里面查询数据,也是通过 association 配置，但另外一个表的查询通过 select 属性配置。
简单的贴两个例子：
一对一：

<mapper namespace="com.mapper.TeacherMapper">
    <resultMap type="Teacher" id="teacherPositionResultMap">
        <id property="id" column="id"/>
        <result property="no" column="t_no"/>
        <result property="name" column="t_name"/>
        <!-- association：配置的一对一属性 -->
        <!-- property：名字
             javaType：类型
         -->
        <association property="pos" javaType="Position">
            <id property="id" column="id"/>
            <result property="name" column="t_pos_name"/>
        </association>
    </resultMap>
    
    <!-- 一对一关联查询，查询老师及其对应的职位 -->
    <!-- 注意：id不能相同，当多个值传入，比如包装类的时候，我们才能够用SQL片段的形式来做if判断，单个值是不行的 -->
    <select id="queryTeacherPositionResultMapById" resultMap="teacherPositionResultMap" parameterType="Integer">
        SELECT *
        FROM tb_teacher t
        LEFT JOIN tb_position p
        ON t.position_id = p.id
        where t.id = #{id}
    </select>
 
    <select id="queryTeacherPositionResultMap" resultMap="teacherPositionResultMap">
        SELECT *
        FROM tb_teacher t
        LEFT JOIN tb_position p
        ON t.`position_id` = p.id
    </select> 
</mapper>

如上图，因为是一对一的关系，所以结果集的封装用association来表示。下面的查询语句正常，结果集用我们之前定义的格式接收。
一对多：

<mapper namespace="com.mapper.PositionMapper"> 
    <resultMap type="Position" id="positionTeacherResultMap">
        <id property="id" column="id"/>
        <result property="name" column="t_pos_name"/> <!-- t_name -->
        <!-- 
        property同association中的一样是属性名称(javaBean中的)；
        javaType也同association中的是类型，
        最后多了一个OfType，因为一对多，不像一对一是单个的！我们这里是List集合，list和List都可以。
        一对多其中是放的一个集合所以这个是集合的泛型的类型，这里我们的list中放的是Teacher：
        所以这里是Teacher。
         -->
        <collection property="teacherList" javaType="list" ofType="Teacher" >
            <!-- 
                一对多出现的问题：
                    当数据库表中，主表的主键id和明细表的 ...
                    当表中的字段名相同时怎么办？多表联查？
                    
                    注意：Mybatis中做多表联查的时候，不管是
                    一对一、一对多、一对多对多：多对多：
                    都不能有字段重名的情况：不管是主键还是普通字段。
                    一旦字段重名的话，就会造成数据少自动赋值，或者覆盖，甚至重复赋值！
                    规避和解决此类问题的方法：
                        1.尽量不要表间重名，mybatis里处理起来很麻烦！id和普通字段都是。
                        但是在表多的时候，很难不会出现字段重名的情况。主键id最容易重名！
                        那么就要用以下的办法了！
                        
                        2.在mybatis中写原生SQL进行查询的时候，查的字段尽可能的少，这
                        也影响速率，强烈禁止使用*，用多少查多少！这样也能及时发现字段重
                        名的情况！
                        
                        3.最后如果真的需要查出重名的字段，并且修改数据库字段名造成的更改
                        过大，这里推荐的方式是给字段取别名，在写resultMap映射的时候，其
                        中的column属性就填写SQL语句中查出字段取的别名，这样就能解决重复
                        问题了！
             -->
            <id property="id" column="t_id"/>
            <result property="no" column="t_no"/>
            <result property="name" column="t_name"/>   
        </collection>
    </resultMap>
    
    <select id="queryPositionTeacherResultMapById" resultMap="positionTeacherResultMap" 
        parameterType="Integer">
        SELECT 
        p.*, 
        t.id t_id,
        t.t_name,
        t.t_no
        FROM tb_position p
        LEFT JOIN tb_teacher t
        ON p.id = t.position_id
        WHERE p.id = #{id}
    </select>
    
    <select id="queryPositionTeacherResultMap" resultMap="positionTeacherResultMap" >
        SELECT 
        p.*, 
        t.id t_id,
        t.t_name,
        t.t_no
        FROM tb_position p
        LEFT JOIN tb_teacher t
        ON p.id = t.position_id
        
    </select>
</mapper>

上面是我百度中找到的注释写的贼全的一个记录。在此表白作者大大。顺便附上传送门Mybatis一对一、一对多、多对多查询。+MYSQL
如果看了我这简单的两个例子不懂可以点过去看看原文。
然后这个关联查询就到这里。重点代码片段中说了，尽量不要字段名重复。

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

Mybatis 仅支持 association 关联对象和 collection 关联集合对象的延迟加载，association 指的就是一对一，collection 指的就是一对多查询。在 Mybatis配置文件中，可以配置是否启用延迟加载 lazyLoadingEnabled=true|false。
它的原理是，使用 CGLIB 创建目标对象的代理对象，当调用目标方法时，进入拦截器方法，比如调用 a.getB().getName()，拦截器 invoke()方法发现a.getB()是null 值，那么就会单独发送事先保存好的查询关联 B 对象的 sql，把 B 查询上来，然后调用 a.setB(b)，于是 a 的对象 b 属性就有值了，接着完成 a.getB().getName()方法的调用。这就是延迟加载的基本原理。
当然了，不光是 Mybatis，几乎所有的包括 Hibernate，支持延迟加载的原理都
是一样的。
这个我觉得叙述的挺清楚的。就是在调用的时候判断是不是null，是null则把子查询的结果set进来。之前我有个疑问就是如果获取到对象不做任何处理直接返回给前端这个关联查询会不会是null、问了大佬之后发现发送给前端的时候json序列化会自动调用get方法。。所以说其实方法也是调用了个。也就是说返回的对象是有关联查询的东西的。

22. Mybatis 的一级、二级缓存？

1）一级缓存: 基于 PerpetualCache 的 HashMap 本地缓存，其存储作用域为Session，当 Session flush 或 close 之后，该 Session 中的所有 Cache 就将清空，默认打开一级缓存。
2）二级缓存与一级缓存其机制相同，默认也是采用 PerpetualCache，HashMap存储，不同在于其存储作用域为 Mapper(Namespace)，并且可自定义存储源，如 Ehcache。默认不打开二级缓存，要开启二级缓存，使用二级缓存属性类需要实现 Serializable 序列化接口(可用来保存对象的状态),可在它的映射文件中配置<cache/> ；
3）对于缓存数据更新机制，当某一个作用域(一级缓存 Session/二级缓存Namespaces)的进行了 C/U/D 操作后，默认该作用域下所有 select 中的缓存将被 clear。
关于这个题其实是真的涉及到了我的知识盲区，真的是用的贼少。我觉得正常逻辑都用不到这个玩意。
简单的说一下：在一个方法中，如果进行了查询操作。在没有ud的情况下，再次进行这个操作就会直接从缓存拿数据。这个就是一级缓存。不过如果中间进行了ud操作，则会清空缓存，第二次缓存中没数据还会再去数据库查询。
二级缓存是mapper级别的缓存，多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession去操作数据库得到数据会存在二级缓存区域，多个SqlSession可以共用二级缓存，二级缓存是多个SqlSession共享的。
UserMapper有一个二级缓存区域（按namespace分，如果namespace相同则使用同一个相同的二级缓存区），其它mapper也有自己的二级缓存区域（按namespace分）。
也是就是说拥有相同的namespace的UserMapper共享一个二级缓存。
同理一个说的很清楚的帖子传送门：mybatis中一级缓存和二级缓存

23. 什么是 MyBatis 的接口绑定？有哪些实现方式？

接口绑定，就是在 MyBatis 中任意定义接口,然后把接口里面的方法和 SQL 语句绑定, 我们直接调用接口方法就可以,这样比起原来了 SqlSession 提供的方法我们可以有更加灵活的选择和设置。
接口绑定有两种实现方式,一种是通过注解绑定，就是在接口的方法上面加上@Select、@Update 等注解，里面包含 Sql 语句来绑定；另外一种就是通过 xml里面写 SQL 来绑定, 在这种情况下,要指定 xml 映射文件里面的 namespace 必须为接口的全路径名。当 Sql 语句比较简单时候,用注解绑定, 当 SQL 语句比较复杂时候,用 xml 绑定,一般用 xml 绑定的比较多。
这个怎么说呢，是很基础的东西。所谓的接口绑定就是怎么把接口全限定名+方法名和 sql语句对应起来。xml和接口上注释两种方法。
然后xml 的好处就是和代码分离。我记得上文我就说过用mybatis 的话使用注释写sql会挨骂。。反正用法就这两个。没啥好说的，这个题目越往下其实都有点重复了。

24. 使用 MyBatis 的 mapper 接口调用时有哪些要求？

Mapper 接口方法名和 mapper.xml 中定义的每个 sql 的 id 相同；
Mapper 接口方法的输入参数类型和 mapper.xml 中定义的每个 sql 的
parameterType 的类型相同；
Mapper 接口方法的输出参数类型和 mapper.xml 中定义的每个 sql 的
resultType 的类型相同；
Mapper.xml 文件中的 namespace 即是 mapper 接口的类路径。

25. Mapper 编写有哪几种方式?

这个题其实我最近几乎没啥应用了，所以简单的概述下得了。毕竟我现在项目中都是mybatisplus然后直接继承BaseMapper了然后用@Mapper注解实现了。有点类似于下面的第三种方法。
三种方式：

接口实现类继承 SqlSessionDaoSupport：使用此种方法需要编写mapper 接口，mapper 接口实现类、mapper.xml 文件。
使用org.mybatis.spring.mapper.MapperFactoryBean 此方法需要在SqlMapConfig.xml中配置mapper.xml的位置，还需定义mapper接口。
使用mapper扫描器需要编写mapper.xml文件，需要mapper接口，配置mapper扫描器，使用扫描器从spring容器中获取mapper的实现对象。

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

答：Mybatis 仅可以编写针对 ParameterHandler、ResultSetHandler、StatementHandler、Executor 这 4 种接口的插件，Mybatis 使用 JDK 的动态代理，为需要拦截的接口生成代理对象以实现接口方法拦截功能，每当执行这 4 种接口对象的方法时，就会进入拦截方法，具体就是 InvocationHandler 的 invoke()方法，当然，只会拦截那些你指定需要拦截的方法。
编写插件：实现 Mybatis 的 Interceptor 接口并复写 intercept()方法，然后在给
插件编写注解，指定要拦截哪一个接口的哪些方法即可，记住，别忘了在配置文件中配置你编写的插件。
其实这个题可以想象上面说的延迟加载的题目。就是A中有B。B是什么时候被插入到A的一个属性中的？就是在方法调用的时候拦截器发现是null则会set进去。
这个我只能说看了一些理论的技术贴，但是切切实实的没有实践过。尤其是现在习惯了用mybatis plus的我来说，这些底层的实现真的有点遥远。
但是学到既得到。这二十几道题我是分了好多天才算是整理完的。一点一点细品，竟然也觉得对mybatis甚至对orm框架对mybatis和jpa的区别等认识都清晰了不少。有时候一个清楚的认知可能对暂时的使用没有什么太大的影响，但是我觉得对于眼界的开拓和逻辑思维的理解都是有好处的。
剩下的面试题还很多，容我一点点整理发出来。

这篇笔记就记到这里，如果稍微帮到你了记得点个喜欢点个关注。也祝大家工作顺顺利利！另外这本书的原文件在群里有，欢迎各位萌新大佬踊跃加群！群号130031711