1、mybatis 处理IN
<select id="queryBorrowListByMemberId">
SELECT
*
FROM
t_borrow_order bo
WHERE
bo.`borrow_member_id` IN
<foreach collection="inStateFlag" item="item" index="index" open="(" close=")" separator=",">
#{item}
</foreach>
</select>
#Java传参
params.put("inStateFlag", Arrays.asList(8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 26, 27, 28,29,32,33))2、处理日期
<if test="currentMonth != null and currentMonth != ''">
DATE_FORMAT(create_time, '%Y-%m') = DATE_FORMAT(STR_TO_DATE(#{currentMonth}, '%Y-%m'), '%Y-%m')
</if>
<if test="createTimeStart != null and createTimeStart != ''">
<![CDATA[ AND create_time >= STR_TO_DATE(CONCAT(#{createTimeStart,jdbcType=VARCHAR}," 00:00:00"),'%Y-%m-%d %H:%i:%s')]]>
</if>3、处理LIKE
<if test="borrowOrderNo != null and borrowOrderNo !='' " >
and t1.borrow_order_no like CONCAT('%',#{borrowOrderNo}, '%')
</if>4、返回插入记录的主键ID
<!--
第一种方法
keyProperty="id" 这个id必须是实体的id，而不是数据表的主键id，否则，得不到正确的返回结果
-->
<insert id="insertSelective" parameterType="com.chenzhou.mybatis.User" useGeneratedKeys="true" keyProperty="userId">
insert into user(userName,password,comment)
values(#{userName},#{password},#{comment})
</insert>
<!--
第二种方法
接收返回值时候，必须用实体的get属性，而不能定义变量，否则，接收不到正确的返回结果：即必须用user.getId()来接收
-->
<insert id="insert" parameterType="cn.***.beans.LogObject">
<selectKey resultType="java.lang.Integer" order="BEFORE" keyProperty="id">
SELECT LOGS_SEQ.nextval AS ID FROM DUAL
</selectKey>
INSERT INTO S_T_LOGS ( ID, USER_ID, USER_NAME,USER_IP, OPERATION_TIME, DESCRIPTION,RESOURCE_ID)
VALUES (#{id},#{userId},#{userName},#{userIp},#{operationTime},#{description},#{resourceId})
</insert>5、处理大号小号的方法
<!--
第一种方法：用了转义字符把>和<替换掉
<（小于号）:<
>（大于号）：>
&（和）：&
'（单引号）：'
"（双引号）："
-->
SELECT * FROM test WHERE 1 = 1 AND start_date <= CURRENT_DATE AND end_date >= CURRENT_DATE
<!-- 第二种方法：通过CDATA声明不进行解析 -->
<![CDATA[ when min(starttime)<='12:00' and max(endtime)<='12:00' ]]> 6、mybatis xml dtd 位置
7、mybatis参数处理
单个参数：mybatis不会做特殊处理，
#{参数名/任意名}：取出参数值。
多个参数：mybatis会做特殊处理。
多个参数会被封装成 一个map，
key：param1...paramN,或者参数的索引也可以
value：传入的参数值
#{}就是从map中获取指定的key的值；
异常：
org.apache.ibatis.binding.BindingException:
Parameter 'id' not found.
Available parameters are [1, 0, param1, param2]
操作：
方法：public Employee getEmpByIdAndLastName(Integer id,String lastName);
取值：#{id},#{lastName}
【命名参数】：明确指定封装参数时map的key；@Param("id")
多个参数会被封装成 一个map，
key：使用@Param注解指定的值
value：参数值
#{指定的key}取出对应的参数值
public Employee getEmp(@Param("id")Integer id,String lastName);
取值：id==>#{id/param1} lastName==>#{param2}
public Employee getEmp(Integer id,@Param("e")Employee emp);
取值：id==>#{param1} lastName===>#{param2.lastName/e.lastName}
##特别注意：如果是Collection（List、Set）类型或者是数组，
也会特殊处理。也是把传入的list或者数组封装在map中。
key：Collection（collection）,如果是List还可以使用这个key(list)
数组(array)
public Employee getEmpById(List<Integer> ids);
取值：取出第一个id的值： #{list[0]}
8、#和$取值的区别
select * from tbl_employee where id=${id} and last_name=#{lastName}
Preparing: select * from tbl_employee where id=2 and last_name=?
区别：
#{}:是以预编译的形式，将参数设置到sql语句中；PreparedStatement；防止sql注入
${}:取出的值直接拼装在sql语句中；会有安全问题；
大多情况下，我们去参数的值都应该去使用#{}；
原生jdbc不支持占位符的地方我们就可以使用${}进行取值
比如分表、排序。。。；按照年份分表拆分
select * from ${year}_salary where xxx;
select * from tbl_employee order by ${f_name} ${order}9、记录封装
//1、多条记录封装一个map：Map<Integer,Employee>:键是这条记录的主键，值是记录封装后的javaBean
//@MapKey:告诉mybatis封装这个map的时候使用哪个属性作为map的key
@MapKey("lastName")
public Map<String, Employee> getEmpByLastNameLikeReturnMap(String lastName);
<select id="getEmpByLastNameLikeReturnMap" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee where last_name like #{lastName}
</select>
//2、返回一条记录的map；key就是列名，值就是对应的值
public Map<String, Object> getEmpByIdReturnMap(Integer id);
<select id="getEmpByIdReturnMap" resultType="map">
select * from tbl_employee where id=#{id}
</select><!--
场景一：
查询Employee（有个部门类属性）的同时查询员工对应的部门
Employee===Department
一个员工有与之对应的部门信息；
id last_name gender d_id did dept_name (private Department dept;)
-->
<!--
方法一：联合查询：级联属性封装结果集
-->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="gender" property="gender"/>
<result column="did" property="dept.id"/>
<result column="dept_name" property="dept.departmentName"/>
</resultMap>
<select id="getEmpAndDept" resultMap="MyDifEmp">
SELECT e.id id,e.last_name last_name,e.gender gender,e.d_id d_id,
d.id did,d.dept_name dept_name FROM tbl_employee e,tbl_dept d
WHERE e.d_id=d.id AND e.id=#{id}
</select>
<!--
方法二：使用association定义关联的单个对象的封装规则；
-->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp2">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="gender" property="gender"/>
<!-- association可以指定联合的javaBean对象
property="dept"：指定哪个属性是联合的对象
javaType:指定这个属性对象的类型[不能省略]
-->
<association property="dept" javaType="com.atguigu.mybatis.bean.Department">
<id column="did" property="id"/>
<result column="dept_name" property="departmentName"/>
</association>
</resultMap>
<!-- 方法三：使用association进行分步查询：
1、先按照员工id查询员工信息
2、根据查询员工信息中的d_id值去部门表查出部门信息
3、部门设置到员工中；
-->
<!-- id last_name email gender d_id -->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpByStep">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
<!-- association定义关联对象的封装规则
select:表明当前属性是调用select指定的方法查出的结果
column:指定将哪一列的值传给这个方法
流程：使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性
-->
<association property="dept"
select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
column="d_id">
</association>
</resultMap>
<!-- public Employee getEmpByIdStep(Integer id);-->
<select id="getEmpByIdStep" resultMap="MyEmpByStep">
select * from tbl_employee where id=#{id}
<if test="_parameter!=null">
and 1=1
</if>
</select>
<!-- association可以使用延迟加载（懒加载）；(按需加载)
Employee==>Dept：
我们每次查询Employee对象的时候，都将一起查询出来。
部门信息在我们使用的时候再去查询；
分段查询的基础之上加上两个配置：
-->
==========collection===========
<!--
public class Department {
private Integer id;
private String departmentName;
private List<Employee> emps;
did dept_name || eid last_name email gender
-->
<!--嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则 -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDept">
<id column="did" property="id"/>
<result column="dept_name" property="departmentName"/>
<!--
collection定义关联集合类型的属性的封装规则
ofType:指定集合里面元素的类型
-->
<collection property="emps" ofType="com.atguigu.mybatis.bean.Employee">
<!-- 定义这个集合中元素的封装规则 -->
<id column="eid" property="id"/>
<result column="last_name" property="lastName"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
</collection>
</resultMap>
<!-- public Department getDeptByIdPlus(Integer id); -->
<select id="getDeptByIdPlus" resultMap="MyDept">
SELECT d.id did,d.dept_name dept_name,
e.id eid,e.last_name last_name,e.email email,e.gender gender
FROM tbl_dept d
LEFT JOIN tbl_employee e
ON d.id=e.d_id
WHERE d.id=#{id}
</select>
<!-- collection：分段查询 -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDeptStep">
<id column="id" property="id"/>
<id column="dept_name" property="departmentName"/>
<collection property="emps"
select="com.atguigu.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
column="{deptId=id}" fetchType="lazy"></collection>
</resultMap>
<!-- public Department getDeptByIdStep(Integer id); -->
<select id="getDeptByIdStep" resultMap="MyDeptStep">
select id,dept_name from tbl_dept where id=#{id}
</select>
<!-- 扩展：多列的值传递过去：
将多列的值封装map传递；
column="{key1=column1,key2=column2}"
fetchType="lazy"：表示使用延迟加载；
- lazy：延迟
- eager：立即
-->
<!-- =======================鉴别器============================ -->
<!-- <discriminator javaType=""></discriminator>
鉴别器：mybatis可以使用discriminator判断某列的值，然后根据某列的值改变封装行为
封装Employee：
如果查出的是女生：就把部门信息查询出来，否则不查询；
如果是男生，把last_name这一列的值赋值给email;
-->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpDis">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
<!--
column：指定判定的列名
javaType：列值对应的java类型 -->
<discriminator javaType="string" column="gender">
<!--女生 resultType:指定封装的结果类型；不能缺少。/resultMap-->
<case value="0" resultType="com.atguigu.mybatis.bean.Employee">
<association property="dept"
select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
column="d_id">
</association>
</case>
<!--男生 ;如果是男生，把last_name这一列的值赋值给email; -->
<case value="1" resultType="com.atguigu.mybatis.bean.Employee">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="last_name" property="email"/>
<result column="gender" property="gender"/>
</case>
</discriminator>
</resultMap>
<select id="getEmpsByConditionIf" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<!-- where -->
<where>
<!-- test：判断表达式（OGNL）
OGNL参照PPT或者官方文档。
c:if test
从参数中取值进行判断
遇见特殊符号应该去写转义字符：
&&：
-->
<if test="id!=null">
id=#{id}
</if>
<if test="lastName!=null && lastName!=""">
and last_name like #{lastName}
</if>
<if test="email!=null and email.trim()!=""">
and email=#{email}
</if>
<!-- ognl会进行字符串与数字的转换判断 "0"==0 -->
<if test="gender==0 or gender==1">
and gender=#{gender}
</if>
</where>
</select>
<select id="getEmpsByConditionTrim" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<!-- 后面多出的and或者or where标签不能解决
prefix="":前缀：trim标签体中是整个字符串拼串 后的结果。
prefix给拼串后的整个字符串加一个前缀
prefixOverrides="":
前缀覆盖： 去掉整个字符串前面多余的字符
suffix="":后缀
suffix给拼串后的整个字符串加一个后缀
suffixOverrides=""
后缀覆盖：去掉整个字符串后面多余的字符
-->
<!-- 自定义字符串的截取规则 -->
<trim prefix="where" suffixOverrides="and">
<if test="id!=null">
id=#{id} and
</if>
<if test="lastName!=null && lastName!=""">
last_name like #{lastName} and
</if>
<if test="email!=null and email.trim()!=""">
email=#{email} and
</if>
<!-- ognl会进行字符串与数字的转换判断 "0"==0 -->
<if test="gender==0 or gender==1">
gender=#{gender}
</if>
</trim>
</select>
<select id="getEmpsByConditionChoose" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<where>
<!-- 如果带了id就用id查，如果带了lastName就用lastName查;只会进入其中一个 -->
<choose>
<when test="id!=null">
id=#{id}
</when>
<when test="lastName!=null">
last_name like #{lastName}
</when>
<when test="email!=null">
email = #{email}
</when>
<otherwise>
gender = 0
</otherwise>
</choose>
</where>
</select>
<!--
抽取可重用的sql片段。方便后面引用
1、sql抽取：经常将要查询的列名，或者插入用的列名抽取出来方便引用
2、include来引用已经抽取的sql：
3、include还可以自定义一些property，sql标签内部就能使用自定义的属性
include-property：取值的正确方式${prop},
#{不能使用这种方式}
-->
<sql id="insertColumn">
<if test="_databaseId=='oracle'">
employee_id,last_name,email
</if>
<if test="_databaseId=='mysql'">
last_name,email,gender,d_id
</if>
</sql><!-- 两个内置参数：
不只是方法传递过来的参数可以被用来判断，取值。。。
mybatis默认还有两个内置参数：
_parameter:代表整个参数
单个参数：_parameter就是这个参数
多个参数：参数会被封装为一个map；_parameter就是代表这个map
_databaseId:如果配置了databaseIdProvider标签。
_databaseId就是代表当前数据库的别名oracle
-->
<!--public List<Employee> getEmpsTestInnerParameter(Employee employee); -->
<select id="getEmpsTestInnerParameter" resultType="com.atguigu.mybatis.bean.Employee">
<!-- bind：可以将OGNL表达式的值绑定到一个变量中，方便后来引用这个变量的值 -->
<bind name="_lastName" value="'%'+lastName+'%'"/>
<if test="_databaseId=='mysql'">
select * from tbl_employee
<if test="_parameter!=null">
where last_name like #{lastName}
</if>
</if>
<if test="_databaseId=='oracle'">
select * from employees
<if test="_parameter!=null">
where last_name like #{_parameter.lastName}
</if>
</if>
</select>10、缓存
两级缓存：
一级缓存：（本地缓存）：sqlSession级别的缓存。一级缓存是一直开启的；SqlSession级别的一个Map
与数据库同一次会话期间查询到的数据会放在本地缓存中。
以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库；
一级缓存失效情况（没有使用到当前一级缓存的情况，效果就是，还需要再向数据库发出查询）：
1、sqlSession不同。
2、sqlSession相同，查询条件不同.(当前一级缓存中还没有这个数据)
3、sqlSession相同，两次查询之间执行了增删改操作(这次增删改可能对当前数据有影响)
4、sqlSession相同，手动清除了一级缓存（缓存清空）
二级缓存：（全局缓存）：基于namespace级别的缓存：一个namespace对应一个二级缓存：
工作机制：
1、一个会话，查询一条数据，这个数据就会被放在当前会话的一级缓存中；
2、如果会话关闭；一级缓存中的数据会被保存到二级缓存中；新的会话查询信息，就可以参照二级缓存中的内容；
3、sqlSession===EmployeeMapper==>Employee
DepartmentMapper===>Department
不同namespace查出的数据会放在自己对应的缓存中（map）
效果：数据会从二级缓存中获取
查出的数据都会被默认先放在一级缓存中。
只有会话提交或者关闭以后，一级缓存中的数据才会转移到二级缓存中
使用：
1）、开启全局二级缓存配置：<setting name="cacheEnabled" value="true"/>
2）、去mapper.xml中配置使用二级缓存：
<cache></cache>
3）、我们的POJO需要实现序列化接口
和缓存有关的设置/属性：
1）、cacheEnabled=true：false：关闭缓存（二级缓存关闭）(一级缓存一直可用的)
2）、每个select标签都有useCache="true"：
false：不使用缓存（一级缓存依然使用，二级缓存不使用）
3）、【每个增删改标签的：flushCache="true"：（一级二级都会清除）】
增删改执行完成后就会清除缓存；
测试：flushCache="true"：一级缓存就清空了；二级也会被清除；
查询标签：flushCache="false"：默认是false
如果flushCache=true;每次查询之后都会清空缓存；缓存是没有被使用的；
4）、sqlSession.clearCache();只是清除当前session的一级缓存；
5）、localCacheScope：本地缓存作用域：（一级缓存SESSION）；当前会话的所有数据保存在会话缓存中；
STATEMENT：可以禁用一级缓存；
第三方缓存整合：
1）、导入第三方缓存包即可；
2）、导入与第三方缓存整合的适配包；官方有；
3）、mapper.xml中使用自定义缓存
<cache type="org.mybatis.caches.ehcache.EhcacheCache">
<!--
eviction:缓存的回收策略：
• LRU – 最近最少使用的：移除最长时间不被使用的对象。
• FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
• SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
• WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
• 默认的是 LRU。
flushInterval：缓存刷新间隔
缓存多长时间清空一次，默认不清空，设置一个毫秒值
readOnly:是否只读：
true：只读；mybatis认为所有从缓存中获取数据的操作都是只读操作，不会修改数据。
mybatis为了加快获取速度，直接就会将数据在缓存中的引用交给用户。不安全，速度快
false：非只读：mybatis觉得获取的数据可能会被修改。
mybatis会利用序列化&反序列的技术克隆一份新的数据给你。安全，速度慢
size：缓存存放多少元素；
type=""：指定自定义缓存的全类名；
实现Cache接口即可；
-->
</cache>
<!-- 引用缓存：namespace：指定和哪个名称空间下的缓存一样 -->
<cache-ref namespace="com.atguigu.mybatis.dao.EmployeeMapper"/>11、ehcache.xml
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
<!-- 磁盘保存路径 -->
<diskStore path="D:\44\ehcache" />
<defaultCache
maxElementsInMemory="10000"
maxElementsOnDisk="10000000"
eternal="false"
overflowToDisk="true"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU">
</defaultCache>
</ehcache>
<!--
属性说明：
l diskStore：指定数据在磁盘中的存储位置。
l defaultCache：当借助CacheManager.add("demoCache")创建Cache时，EhCache便会采用<defalutCache/>指定的的管理策略
以下属性是必须的：
l maxElementsInMemory - 在内存中缓存的element的最大数目
l maxElementsOnDisk - 在磁盘上缓存的element的最大数目，若是0表示无穷大
l eternal - 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断
l overflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
以下属性是可选的：
l timeToIdleSeconds - 当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大
l timeToLiveSeconds - 缓存element的有效生命期，默认是0.,也就是element存活时间无穷大
diskSpoolBufferSizeMB 这个参数设置DiskStore(磁盘缓存)的缓存区大小.默认是30MB.每个Cache都应该有自己的一个缓冲区.
l diskPersistent - 在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。
l diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
l memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）
-->12、mybatis运行原理
1、获取sqlSessionFactory对象:
解析文件的每一个信息保存在Configuration中，返回包含Configuration的DefaultSqlSession；
注意：【MappedStatement】：代表一个增删改查的详细信息
2、获取sqlSession对象
返回一个DefaultSQlSession对象，包含Executor和Configuration;
这一步会创建Executor对象；
3、获取接口的代理对象（MapperProxy）
getMapper，使用MapperProxyFactory创建一个MapperProxy的代理对象
代理对象里面包含了，DefaultSqlSession（Executor）
4、执行增删改查方法
总结：
1、根据配置文件（全局，sql映射）初始化出Configuration对象
2、创建一个DefaultSqlSession对象，
他里面包含Configuration以及
Executor（根据全局配置文件中的defaultExecutorType创建出对应的Executor）
3、DefaultSqlSession.getMapper（）：拿到Mapper接口对应的MapperProxy；
4、MapperProxy里面有（DefaultSqlSession）；
5、执行增删改查方法：
1）、调用DefaultSqlSession的增删改查（Executor）；
2）、会创建一个StatementHandler对象。
（同时也会创建出ParameterHandler和ResultSetHandler）
3）、调用StatementHandler预编译参数以及设置参数值;
使用ParameterHandler来给sql设置参数
4）、调用StatementHandler的增删改查方法；
5）、ResultSetHandler封装结果
注意：
四大对象每个创建的时候都有一个interceptorChain.pluginAll(parameterHandler);13、插件
14、调用存储过程
<!-- public void getPageByProcedure();
1、使用select标签定义调用存储过程
2、statementType="CALLABLE":表示要调用存储过程
3、{call procedure_name(params)}
-->
<select id="getPageByProcedure" statementType="CALLABLE" databaseId="oracle">
{call hello_test(
#{start,mode=IN,jdbcType=INTEGER},
#{end,mode=IN,jdbcType=INTEGER},
#{count,mode=OUT,jdbcType=INTEGER},
#{emps,mode=OUT,jdbcType=CURSOR,javaType=ResultSet,resultMap=PageEmp}
)}
</select>15、TypeHandler类型处理器
全局配置文件
<configuration>
<properties resource="dbconfig.properties"></properties>
<typeHandlers>
<!--1、配置我们自定义的TypeHandler -->
<typeHandler handler="com.atguigu.mybatis.typehandler.MyEnumEmpStatusTypeHandler" javaType="com.atguigu.mybatis.bean.EmpStatus"/>
<!--2、也可以在处理某个字段的时候告诉MyBatis用什么类型处理器
保存：#{empStatus,typeHandler=xxxx}
查询：
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmp">
<id column="id" property="id"/>
<result column="empStatus" property="empStatus" typeHandler=""/>
</resultMap>
注意：如果在参数位置修改TypeHandler，应该保证保存数据和查询数据用的TypeHandler是一样的。
-->
</typeHandlers>
</configuration>
自定义类型处理器，实现TypeHandler
public class MyEnumEmpStatusTypeHandler implements TypeHandler<EmpStatus> {
4195
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
