1，大于号、小于号在sql语句中的转换

使用 mybatis 时 sql 语句是写在 xml 文件中,如果 sql 中有一些特殊的字符的话,比如< ，<=，>，>=等符号，会引起 xml 格式的错误，需要替换掉，或者不被转义。 有两种方法可以解决：转义字符和标记 CDATA 块。

方式一：转义字符

<select id="searchByPrice" parameterType="Map" resultType="Product">    <!-- 方式1、转义字符 -->    select * from Product where price >= #{minPrice} and price <= #{maxPrice} </select>

方式二：标记CDATA

<select id="searchByPrice" parameterType="Map" resultType="Product">   <!-- 方式2、CDATA -->  <![CDATA[select * from Product where price >= #{minPrice} and price <= #{maxPrice} ]]> </select>

转义字符表

2.传入参数时参数为0查询条件失效

场景案例

场景是这样的，需要做一个对账单查询，可以按金额范围进行查询，页面参数写完之后进行条件，输入0测试了无数次均失效。

原因解析

当页面参数为0，传入到mybatis的xml中后，如果不是字符串，需指定数据类型，否则会被误认为null

<if test="data.tatalAmount != null and data.totalAmount !='' ">and total_Amount=#{data.totalAmount}</if>

这种情况如果totalAmount为0时将被误认为是null，里面的条件不会被执行。

解决方案

1，添加0判断

<if test="data.tatalAmount != null and data.totalAmount !='' or tatalAmount==0 ">and total_Amount=#{data.totalAmount}</if>

2，规定传入参数的类型

<if test="data.tatalAmount != null and data.totalAmount !='' ">and total_Amount=#{data.totalAmount,jdbc.Type=DECIMAL}</if>

3，Mybatis中#{}和${}区别

#{}是预编译处理，像传进来的数据会加个" "(#将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号)

${}就是字符串拼接。直接替换掉占位符。$方式一般用于传入数据库对象，例如传入表名。

使用${}的话会导致sql注入。什么是sql注入呢？比如select * from user where id = #{value}

value本应该是一个数值。然后如果对方传过来的是 001 and name = tom.这样不就相当于多加了一条sql语句进去。

把SQL语句直接写进来了。如果是攻击性的语句呢？001；drop table user，直接把表给删了

所以为了防止 SQL 注入，能用 #{} 的不要去用 ${}

如果非要用 ${} 的话，那要注意防止 SQL 注入问题，可以手动判定传入的变量，进行过滤，一般 SQL 注入会输入很长的一条 SQL 语句

4，Mybatis动态sql语句（OGNL语法）

1、if

解决当要查询的多个条件有一个为空而导致的查询结果为空的情况

<select id="select" resultType="Blog">  SELECT * FROM BLOG  WHERE state = ‘ACTIVE’  <if test="title != null">    AND title like #{title}  </if>  <if test="name!= null">    AND name like #{title}  </if></select>

2、where

像上面的那种情况，如果where后面没有条件，然后需要直接写if判断（开头如果是 and / or 的话，会去除掉）

<select id="select" resultType="Blog">  SELECT * FROM BLOG  <where>      <if test="title != null">        AND title like #{title}      </if>      <if test="name!= null">        AND name like #{title}      </if>  <where></select>

3、choose（when、otherwise）

choose 相当于 java 里面的 switch 语句。otherwise（其他情况）

<select id="findActiveBlogLike" resultType="Blog">  SELECT * FROM BLOG WHERE state = ‘ACTIVE’  <choose>    <when test="title != null">      AND title like #{title}    </when>    <when test="author != null and author.name != null">      AND author_name like #{author.name}    </when>    <otherwise>      AND featured = 1    </otherwise>  </choose></select>

4、trim

prefix：前缀prefixoverride：去掉第一个and或者是or

select * from test<trim prefix="WHERE" prefixoverride="AND丨OR">      <if test="a!=null and a!=' '">AND a=#{a}<if>      <if test="b!=null and b!=' '">AND a=#{a}<if></trim>

5、set

set 元素主要是用在更新操作的时候，如果包含的语句是以逗号结束的话将会把该逗号忽略，如果set包含的内容为空的话则会出错。

<update id="dynamicSetTest" parameterType="Blog">      update t_blog      <set>          <if test="title != null">              title = #{title},          </if>          <if test="content != null">              content = #{content},          </if>          <if test="owner != null">              owner = #{owner}          </if>      </set>      where id = #{id}  </update> 

6、foreach

foreach主要用在构建in条件中

<select id="dynamicForeachTest" resultType="Blog">          select * from t_blog where id in          <foreach collection="list" index="index" item="item" open="(" separator="," close=")">              #{item}          </foreach>      </select>  

open separator close

相当于是in （？，？，？）

如果是个map怎么办

<select id="dynamicForeach3Test" resultType="Blog">          select * from t_blog where title like "%"#{title}"%" and id in          <foreach collection="ids" index="index" item="item" open="(" separator="," close=")">              #{item}          </foreach>      </select>  

collection对应map的键，像这样

List<Integer> ids = new ArrayList<Integer>();          ids.add(1);          ids.add(2);          ids.add(3);          ids.add(6);          ids.add(7);          ids.add(9);          Map<String, Object> params = new HashMap<String, Object>();          params.put("ids", ids);  

5，Like模糊查询

方式一：

$ 这种方式，简单，但是无法防止SQL注入，所以不推荐使用

LIKE '%${name}%'

方式二：

LIKE "%"#{name}"%"

方式三：字符串拼接

AND name LIKE CONCAT(CONCAT('%',#{name},'%'))

方式四：bind标签

<select id="searchStudents" resultType="com.example.entity.StudentEntity"  parameterType="com.example.entity.StudentEntity">  <bind name="pattern1" value="'%' + _parameter.name + '%'" />  <bind name="pattern2" value="'%' + _parameter.address + '%'" />  SELECT * FROM test_student  <where>   <if test="age != null and age != '' and compare != null and compare != ''">    age    ${compare}    #{age}   </if>   <if test="name != null and name != ''">    AND name LIKE #{pattern1}   </if>   <if test="address != null and address != ''">    AND address LIKE #{pattern2}   </if>  </where>  ORDER BY id </select>

6，传递多个参数

方法一:使用map接口传递参数

严格来说，map适用几乎所有场景，但是我们用得不多。原因有两个：首先，map是一个键值对应的集合，使用者要通过阅读它的键，才能明了其作用；其次，使用map不能限定其传递的数据类型，因此业务性质不强，可读性差，使用者要读懂代码才能知道需要传递什么参数给它，所以不推荐用这种方式传递多个参数。

public List<Role> findRolesByMap(Map<String, Object> parameterMap);<select id="findRolesByMap" parameterType="map" resultType="role">    select id, role_name as roleName, note from t_role where role_name like concat('%', #{roleName}, '%') and note like concat('%', #{note}, '%')</select>

方法二:使用注解传递多个参数　　

MyBatis为开发者提供了一个注解@Param（org.apache.ibatis.annotations.Param），可以通过它去定义映射器的参数名称，使用它可以得到更好的可读性　　这个时候需要修改映射文件的代码，此时并不需要给出parameterType属性，让MyBatis自动探索便可以了　　使可读性大大提高，使用者也方便了，但是这会带来一个麻烦。如果SQL很复杂，拥有大于10个参数，那么接口方法的参数个数就多了，使用起来就很不容易，不过不必担心，MyBatis还提供传递Java Bean的形式。

public List<Role> findRolesByAnnotation(@Param("roleName") String rolename, @Param("note") String note);<select id="findRolesByAnnotation" resultType="role">    select id, role_name as roleName, note from t_role where role_name like concat('%', #{roleName}, '%') and note like concat('%', #{note}, '%')</select>

方法三:通过Java Bean传递多个参数

public List<Role> findRolesByBean(RoleParams roleParam);<select id="findRolesByBean" parameterType="com.xc.pojo.RoleParams" resultType="role">    select id, role_name as roleName, note from t_role where role_name like concat('%', #{roleName}, '%') and note like concat('%', #{note}, '%')</select>

方法四:混合使用　　

在某些情况下可能需要混合使用几种方法来传递参数。举个例子，查询一个角色，可以通过角色名称和备注进行查询，与此同时还需要支持分页

public List<Role> findByMix(@Param("params") RoleParams roleParams, @Param("page") PageParam PageParam);<select id="findByMix" resultType="role">    select id, role_name as roleName, note from t_role    where role_name like concat('%', #{params.roleName}, '%') and note like concat('%', #{params.note}, '%')      limit #{page.start}, #{page.limit}</select>

总结:

描述了4种传递多个参数的方法，对各种方法加以点评和总结，以利于我们在实际操作中的应用。

　　?使用 map 传递参数导致了业务可读性的丧失，导致后续扩展和维护的困难，在实际的应用中要果断废弃这种方式。

　　?使用 @Param 注解传递多个参数，受到参数个数（n）的影响。当 n≤5 时，这是最佳的传参方式，它比用 Java Bean 更好，因为它更加直观；当 n＞5 时，多个参数将给调用带来困难，此时不推荐使用它。

　　?当参数个数多于5个时，建议使用 Java Bean 方式。

　　?对于使用混合参数的，要明确参数的合理性。

7，MyBatis缓存机制

缓存机制减轻数据库压力，提高数据库性能

mybatis的缓存分为两级：一级缓存、二级缓存

一级缓存：

一级缓存为 SqlSession 缓存，缓存的数据只在 SqlSession 内有效。在操作数据库的时候需要先创建 SqlSession 会话对象，在对象中有一个 HashMap 用于存储缓存数据，此 HashMap 是当前会话对象私有的，别的 SqlSession 会话对象无法访问。

具体流程：

第一次执行 select 完毕会将查到的数据写入 SqlSession 内的 HashMap 中缓存起来

第二次执行 select 会从缓存中查数据，如果 select 同传参数一样，那么就能从缓存中返回数据，不用去数据库了，从而提高了效率

注意：

1、如果 SqlSession 执行了 DML 操作（insert、update、delete），并 commit 了，那么 mybatis 就会清空当前 SqlSession 缓存中的所有缓存数据，这样可以保证缓存中的存的数据永远和数据库中一致，避免出现差异

2、当一个 SqlSession 结束后那么他里面的一级缓存也就不存在了， mybatis 默认是开启一级缓存，不需要配置

3、 mybatis 的缓存是基于 [namespace:sql语句:参数] 来进行缓存的，意思就是， SqlSession 的 HashMap 存储缓存数据时，是使用 [namespace:sql:参数] 作为 key ，查询返回的语句作为 value 保存的

二级缓存：

二级缓存是mapper 级别的缓存，也就是同一个 namespace 的 mapper.xml ，当多个 SqlSession 使用同一个 Mapper 操作数据库的时候，得到的数据会缓存在同一个二级缓存区域

二级缓存默认是没有开启的。需要在 setting 全局参数中配置开启二级缓存

开启二级缓存步骤：

1、conf.xml 配置全局变量开启二级缓存

<settings>    <setting name="cacheEnabled" value="true"/>默认是false：关闭二级缓存<settings>

2、在userMapper.xml中配置

<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>当前mapper下所有语句开启二级缓存

这里配置了一个 FIFO缓存，并每隔60秒刷新，最大存储512个对象，而返回的对象是只读的，因此在不同线程中的调用者之间修改它们会导致冲突。可用的收回策略有，默认的是LRU：

1. LRU- 最近最少使用的；移除最长时间不被使用的对象。
2. FIFO- 先进先出；按对象进入缓存的顺序来移除它们。
3. SOFT- 软引用；移除基于垃圾回收器状态和软引用规则的对象
4. WEAK- 弱引用；更积极地移除基干垃圾收集器状态和弱引用规则的对象

若想禁用当前select语句的二级缓存，添加 useCache="false"修改如下：

<select id="getCountByName" parameterType="java.util.Map" resultType="INTEGER" statementType="CALLABLE" useCache="false">

具体流程：

1.当一个sqlseesion执行了一次select 后，在关闭此session 的时候，会将查询结果缓存到二级缓存

2.当另一个sqlsession执行select 时，首先会在他自己的一级缓存中找，如果没找到，就回去二级缓存中找，找到了就返回，就不用去数据库了，从而减少了数据库压力提高了性能

注意:

1、如果 SqlSession 执行了 DML 操作（insert、update、delete），并 commit 了，那么 mybatis 就会清空当前mapper 缓存中的所有缓存数据，这样可以保证缓存中的存的数据永远和数据库中一致，避免出现差异

2、mybatis 的一级缓存是基于[namespace:sql语句:参数]来进行缓存的，意思就是，SqlSession 的 HashMap 存储缓存数据时，是使用 [namespace:sql:参数]作为 key ，查询返回的语句作为 value 保存的。

是否应该使用二级缓存？

那么究竟应该不应该使用二级缓存呢？先来看一下二级缓存的注意事项：

1. 缓存是以namespace为单位的，不同namespace下的操作互不影响。
2. insert,update,delete操作会清空所在namespace下的全部缓存。
3. 通常使用MyBatis Generator生成的代码中，都是各个表独立的，每个表都有自己的namespace。
4. 多表操作一定不要使用二级缓存，因为多表操作进行更新操作，一定会产生脏数据。

如果你遵守二级缓存的注意事项，那么你就可以使用二级缓存。

但是，如果不能使用多表操作，二级缓存不就可以用一级缓存来替换掉吗？而且二级缓存是表级缓存，开销大，没有一级缓存直接使用 HashMap 来存储的效率更高，所以二级缓存并不推荐使用。

8，MyBatis时间timestamp做条件进行查询

首先要将条件 转换为 时间戳

long startTime = TimeUtil.parseTimestamp(start);long endTime = TimeUtil.parseTimestamp(end); /*对应工具类*/public static long parseTimestamp(String datetime){    try{    SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");    Date date = dateformat.parse(datetime);    return date.getTime()/1000;             }catch(Exception e){        e.printStackTrace();    }    return 0;}

然后Mapper.xml中 使用BETWEEN and 和 to_timestamp

<if test="startDate !=null and startDate !='' and endDate !=null and endDate !=''">            AND tdnm.create_time BETWEEN to_timestamp(#{startDate}) AND to_timestamp(#{endDate})</if>

9，mybatis 是否支持延迟加载？延迟加载的原理是什么？

1.MyBatis 支持延迟加载。

2.什么是延迟加载：延迟加载，也称为懒加载，是指在进行关联查询时，按照设置延迟规则推迟对关联对象的select查询。延迟加载可以有效的减少数据库压力。MyBatis的延迟加载只是对关联对象的查询有延迟设置，对于主加载对象都是直接执行查询语句的。

3.MyBatis 对关联对象的加载类型

（1）直接加载：执行完对主加载对象的select语句，马上执行对关联对象的select查询。

（2）侵入式延迟：执行对主加载对象的查询时，不会执行对关联对象的查询。但当要访问主加载对象的详情时，就会马上执行关联对象的select查询。（将关联对象的详情作为主加载对象的详情的一部分出现）

（3）深度延迟：执行对主加载对象的查询时，不会执行对关联对象的查询。访问主加载对象的详情时也不会执行关联对象的select查询。只有当真正访问关联对象的详情时，才会执行对关联对象的select查询。

4.延迟加载的原理：调用的时候触发加载，而不是在初始化的时候就加载信息

例如：调用 a. getB(). getName()，这个时候发现 a. getB() 的值为 null，此时会单独触发事先保存好的关联 B 对象的 SQL，先查询出来 B，然后再调用 a. setB(b)，而这时候再调用 a. getB(). getName() 就有值了