Mybatis SQL映射文件详解

mybatis除了有全局配置文件，还有映射文件，在映射文件中可以编写以下的顶级元素标签：

  1. cache – 该命名空间的缓存配置。
  2. cache-ref – 引用其它命名空间的缓存配置。
  3. resultMap – 描述如何从数据库结果集中加载对象，是最复杂也是最强大的元素。
  4. parameterMap – 老式风格的参数映射。此元素已被废弃，并可能在将来被移除！要求使用行内参数映射。
  5. sql – 可被其它语句引用的可重用语句块。
  6. insert – 映射插入语句。
  7. update – 映射更新语句。
  8. delete – 映射删除语句。
  9. select – 映射查询语句。

在每个顶级元素标签中可以添加很多个属性，下面是一些下具体的配置。

一、insert、update、delete元素

属性 描述
id 在命名空间中,SQL语句的唯一标识符，可以被用来引用这条语句。
parameterType 将会传入这条语句的参数的类全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过类型处理器（TypeHandler）推断出具体传入语句的参数，默认值为未设置（unset）。
parameterMap 用于引用外部 parameterMap 的属性，目前已被废弃。推荐使用行内参数映射和 parameterType 属性。
flushCache 将其设置为 true 后，只要语句被调用，都会导致本地缓存和二级缓存被清空，默认值：（对 insert、update 和 delete 语句）true。
timeout 这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为未设置（unset）（依赖数据库驱动）。
statementType 可选 STATEMENT，PREPARED 或 CALLABLE。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。
useGeneratedKeys 这会令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法来取出由数据库内部生成的主键（比如：像 MySQL 和 SQL Server 这样的关系型数据库管理系统的自动递增字段），默认值：false。（仅适用于 insert 和 update）
keyProperty 指定能够唯一识别对象的属性，MyBatis 会使用 getGeneratedKeys 的返回值或 insert 语句的 selectKey 子元素设置它的值，默认值：未设置（unset）。如果生成列不止一个，可以用逗号分隔多个属性名称。（仅适用于 insert 和 update）
keyColumn 设置生成键值在表中的列名，在某些数据库（像 PostgreSQL）中，当主键列不是表中的第一列的时候，是必须设置的。如果生成列不止一个，可以用逗号分隔多个属性名称。（仅适用于 insert 和 update）
databaseId 如果配置了数据库厂商标识（databaseIdProvider），MyBatis 会加载所有不带 databaseId 或匹配当前 databaseId 的语句；如果带和不带的语句都有，则不带的会被忽略。 
  1. 	<!--如果数据库支持自增可以使用这样的方式-->
  2.     <insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
  3.         insert into user(user_name) values(#{userName})
  4.     </insert>
  5.     <!--如果数据库不支持自增的话，那么可以使用如下的方式进行赋值查询,利用selectKey语句生成一个id值,对应到insert语句上-->
  6.     <insert id="insertUser2" >
  7.         <selectKey order="BEFORE" keyProperty="id" resultType="integer">
  8.             select max(id)+1 from user
  9.         </selectKey>
  10.         insert into user(id,user_name) values(#{id},#{userName})
  11.     </insert>

二、select元素

1、select的参数传递

  1. <!--
  2.     当查询语句中包含多个参数的是，如果使用#{属性名称}就无法获取具体的值了，那么应该如何使用呢？
  3.         下面就是mybatis的参数传递方式
  4.         1、如果是单个参数，
  5.             基本类型：使用#{随便写}
  6.             引用类型：使用#{类的属性名称}
  7.         2、多个参数：
  8.             当查询的时候传入多个参数的时候，就无法简单的通过#{参数名}来获取值了，
  9.             只能通过arg0,arg1...或者param1,param2等方式来获取值
  10.             原因就在于，mybatis在传入多个参数的时候，会将这些参数封装到一个map中，此时map中的key就是arg0,arg1,param1,param2这些值，但是很明显，这样的传值方式不是很友好，没有办法根据参数的名称来获取具体的值，因此可以使用如下的方式来指定参数的key是什么
  11.             Emp selectEmpByNoAndName(@Param("empno") Integer empno, @Param("ename") String ename);
  12.                 也就是通过@Param来指定存入map中的key值是什么
  13.         3、使用map来传递参数：
  14.                 依然是直接使用#{key}来获取具体的属性值
  15.     -->
  16.     <select id="selectEmpByNoAndName" resultType="com.courage.bean.Emp">
  17.         select * from emp where empno=#{empno} and ename=#{ename}
  18.     </select>
  20.     <select id="selectEmpByNoAndName2" resultType="com.courage.bean.Emp">
  21.         select * from emp where empno=#{empno} and ename=#{ename}
  22.     </select>

2、参数的取值方式

​ 在xml文件中编写sql语句的时候有两种取值的方式，详细信息可以参考Mybatis总结(一),这儿简单述说,分别是#{}和${}，他们之间的区别如下：

  1.  <!--
  2.         当使用#{}来获取值的时候会发现打印的sql语句如下：
  3.             select * from emp where empno=? and ename=?
  4.         当使用${}来获取值的时候会发现打印的sql语句如下：
  5.             select * from emp where empno=7369 and ename='SMITH'
  6.         通过刚刚的案例大家已经发现了存在的问题了，
  7.         使用#{}方式进行取值：采用的是参数预编译的方式，参数的位置使用？进行替代，不会出现sql注入的问题
  8.         使用${}方式进行取值：采用的是直接跟sql语句进行拼接的方式
  10. 		此处大家需要注意，如果我们的sql语句中的某些值不支持参数预编译，那么就必须要使用${}的方式来取值了
  11.     -->
  12.     <select id="selectEmpByNoAndName" resultType="com.courage.bean.Emp">
  13.         select * from #{t} where empno=${empno} and ename=${ename}
  14.     </select>

参数预编译可以参考Mybatis参数预编译.

3、处理集合返回结果

EmpDao.xml

  1. <!--当返回值的结果是集合的时候，返回值的类型依然写的是集合中具体的类型,例如返回的是List<Emp>,resultType依旧是Emp-->
  2.     <select id="selectAllEmp" resultType="com.courage.bean.Emp">
  3.         select  * from emp
  4.     </select>
  6. <!--在查询的时候可以设置返回值的类型为map，当mybatis查询完成之后会把列的名称作为key
  7.     列的值作为value，转换到map中
  8.     -->
  9.     <select id="selectEmpByEmpReturnMap" resultType="map">
  10.         select * from emp where empno = #{empno}
  11.     </select>
  13.     <!--注意，当返回的结果是一个集合对象的是，返回值的类型一定要写集合具体value的类型
  14.     同时在dao的方法上要添加@MapKey的注解，来设置key是什么结果
  15.     @MapKey("empno")
  16.     Map<Integer,Emp> getAllEmpReturnMap();-->
  17.     <select id="getAllEmpReturnMap" resultType="com.courage.bean.Emp">
  18.         select * from emp
  19.     </select>

UserDao.java

  1. package com.courage.dao;
  3. import com.courage.bean.Emp;
  4. import org.apache.ibatis.annotations.MapKey;
  5. import org.apache.ibatis.annotations.Param;
  7. import java.util.List;
  8. import java.util.Map;
  10. public interface EmpDao {
  12.     public Emp findEmpByEmpno(Integer empno);
  14.     public int updateEmp(Emp emp);
  16.     public int deleteEmp(Integer empno);
  18.     public int insertEmp(Emp emp);
  20.     Emp selectEmpByNoAndName(@Param("empno") Integer empno, @Param("ename") String ename,@Param("t") String tablename);
  21.     Emp selectEmpByNoAndName2(Map<String,Object> map);
  23.     List<Emp> selectAllEmp();
  25.     Map<String,Object> selectEmpByEmpReturnMap(Integer empno);
  27.     @MapKey("empno")
  28.     Map<Integer,Emp> getAllEmpReturnMap();
  29. }

4、自定义结果集resultMap

Dog.java

  1. package com.courage.bean;
  3. public class Dog {
  4.     private Integer id;
  5.     private String name;
  6.     private Integer age;
  7.     private String gender;
  9.     public Integer getId() {
  10.         return id;
  11.     }
  13.     public void setId(Integer id) {
  14.         this.id = id;
  15.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  25.     public Integer getAge() {
  26.         return age;
  27.     }
  29.     public void setAge(Integer age) {
  30.         this.age = age;
  31.     }
  33.     public String getGender() {
  34.         return gender;
  35.     }
  37.     public void setGender(String gender) {
  38.         this.gender = gender;
  39.     }
  41.     @Override
  42.     public String toString() {
  43.         return "Dog{" +
  44.                 "id=" + id +
  45.                 ", name='" + name + '\'' +
  46.                 ", age=" + age +
  47.                 ", gender='" + gender + '\'' +
  48.                 '}';
  49.     }
  50. }

dog.sql

  1. /*
  2. Navicat MySQL Data Transfer
  4. Source Server         : node01
  5. Source Server Version : 50729
  6. Source Host           : 192.168.85.111:3306
  7. Source Database       : demo
  9. Target Server Type    : MYSQL
  10. Target Server Version : 50729
  11. File Encoding         : 65001
  13. Date: 2020-03-24 23:54:22
  14. */
  16. SET FOREIGN_KEY_CHECKS=0;
  17. -- ----------------------------
  18. -- Table structure for `dog`
  19. -- ----------------------------
  20. DROP TABLE IF EXISTS `dog`;
  21. CREATE TABLE `dog` (
  22.   `id` int(11) NOT NULL AUTO_INCREMENT,
  23.   `dname` varchar(255) DEFAULT NULL,
  24.   `dage` int(11) DEFAULT NULL,
  25.   `dgender` varchar(255) DEFAULT NULL,
  26.   PRIMARY KEY (`id`)
  27. ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
  29. -- ----------------------------
  30. -- Records of dog
  31. -- ----------------------------
  32. INSERT INTO dog VALUES ('1', '大黄', '1', '雄');
  33. INSERT INTO dog VALUES ('2', '二黄', '2', '雌');
  34. INSERT INTO dog VALUES ('3', '三黄', '3', '雄');

DogDao.java

  1. package com.courage.dao;
  3. import com.courage.bean.Dog;
  5. public interface DogDao {
  7.     public Dog selectDogById(Integer id);
  8. }

DogDao.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.courage.dao.DogDao">
  6.    <!--
  7.    在使用mybatis进行查询的时候，mybatis默认会帮我们进行结果的封装，但是要求列名跟属性名称一一对应上
  8.    在实际的使用过程中，我们会发现有时候数据库中的列名跟我们类中的属性名并不是一一对应的，此时就需要起别名
  9.    起别名有两种实现方式：
  10.       1、在编写sql语句的时候添加别名
  11.       2、自定义封装结果集
  12.    -->
  13.    <!--根据查询的数据进行结果的封装要使用resultMap属性，表示使用自定义规则-->
  14.    <select id="selectDogById" resultMap="myDog">
  15.       select * from dog where id = #{id}
  16.    </select>
  18.    <!--自定义结果集，将每一个列的数据跟javaBean的对象属性对应起来
  19.    type:表示为哪一个javaBean对象进行对应
  20.    id:唯一标识，方便其他属性标签进行引用
  21.    -->
  22.    <resultMap id="myDog" type="com.courage.bean.Dog">
  23.       <!--
  24.       指定主键列的对应规则：
  25.       column：表示表中的主键列
  26.       property:指定javaBean的属性
  27.       -->
  28.       <id column="id" property="id"></id>
  29.       <!--设置其他列的对应关系-->
  30.       <result column="dname" property="name"></result>
  31.       <result column="dage" property="age"></result>
  32.       <result column="dgender" property="gender"></result>
  33.    </resultMap>
  34.    <!--可以在sql语句中写别名-->
  35.  <!--  <select id="selectDogById" resultType="com.courage.bean.Dog">
  36.       select id id,dname name,dage age,dgender gender from dog where id = #{id}
  37.    </select>-->
  39.    <!--这种方式是查询不到任何结果的，因为属性名跟列名并不是一一对应的-->
  40.   <!-- <select id="selectDogById" resultType="com.courage.bean.Dog">
  41.       select * from dog where id = #{id}
  42.    </select>-->
  43. </mapper>

5、联合查询

emp.java

  1. package com.courage.bean;
  3. import java.util.Date;
  5. public class Emp {
  7.     private Integer empno;
  8.     private String ename;
  9.     private String job;
  10.     private Integer mgr;
  11.     private Date hiredate;
  12.     private Double sal;
  13.     private Double common;
  14.     private Dept dept;
  16.     public Emp() {
  17.     }
  19.     public Emp(Integer empno, String ename) {
  20.         this.empno = empno;
  21.         this.ename = ename;
  22.     }
  24.     public Emp(Integer empno, String ename, String job, Integer mgr, Date hiredate, Double sal, Double common, Dept dept) {
  25.         this.empno = empno;
  26.         this.ename = ename;
  27.         this.job = job;
  28.         this.mgr = mgr;
  29.         this.hiredate = hiredate;
  30.         this.sal = sal;
  31.         this.common = common;
  32.         this.dept = dept;
  33.     }
  35.     public Integer getEmpno() {
  36.         return empno;
  37.     }
  39.     public void setEmpno(Integer empno) {
  40.         this.empno = empno;
  41.     }
  43.     public String getEname() {
  44.         return ename;
  45.     }
  47.     public void setEname(String ename) {
  48.         this.ename = ename;
  49.     }
  51.     public String getJob() {
  52.         return job;
  53.     }
  55.     public void setJob(String job) {
  56.         this.job = job;
  57.     }
  59.     public Integer getMgr() {
  60.         return mgr;
  61.     }
  63.     public void setMgr(Integer mgr) {
  64.         this.mgr = mgr;
  65.     }
  67.     public Date getHiredate() {
  68.         return hiredate;
  69.     }
  71.     public void setHiredate(Date hiredate) {
  72.         this.hiredate = hiredate;
  73.     }
  75.     public Double getSal() {
  76.         return sal;
  77.     }
  79.     public void setSal(Double sal) {
  80.         this.sal = sal;
  81.     }
  83.     public Double getCommon() {
  84.         return common;
  85.     }
  87.     public void setCommon(Double common) {
  88.         this.common = common;
  89.     }
  91.     public Dept getDept() {
  92.         return dept;
  93.     }
  95.     public void setDept(Dept dept) {
  96.         this.dept = dept;
  97.     }
  99.     @Override
  100.     public String toString() {
  101.         return "Emp{" +
  102.                 "empno=" + empno +
  103.                 ", ename='" + ename + '\'' +
  104.                 ", job='" + job + '\'' +
  105.                 ", mgr=" + mgr +
  106.                 ", hiredate=" + hiredate +
  107.                 ", sal=" + sal +
  108.                 ", common=" + common +
  109.                 ", dept=" + dept +
  110.                 '}';
  111.     }
  112. }

Dept.java

  1. package com.courage.bean;
  3. public class Dept {
  4.     private Integer deptno;
  5.     private String dname;
  6.     private String loc;
  8.     public Dept() {
  9.     }
  11.     public Dept(Integer deptno, String dname, String loc) {
  12.         this.deptno = deptno;
  13.         this.dname = dname;
  14.         this.loc = loc;
  15.     }
  17.     public Integer getDeptno() {
  18.         return deptno;
  19.     }
  21.     public void setDeptno(Integer deptno) {
  22.         this.deptno = deptno;
  23.     }
  25.     public String getDname() {
  26.         return dname;
  27.     }
  29.     public void setDname(String dname) {
  30.         this.dname = dname;
  31.     }
  33.     public String getLoc() {
  34.         return loc;
  35.     }
  37.     public void setLoc(String loc) {
  38.         this.loc = loc;
  39.     }
  41.     @Override
  42.     public String toString() {
  43.         return "Dept{" +
  44.                 "deptno=" + deptno +
  45.                 ", dname='" + dname + '\'' +
  46.                 ", loc='" + loc + '\'' +
  47.                 '}';
  48.     }
  49. }

EmpDao.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <!--namespace:编写接口的全类名，就是告诉要实现该配置文件是哪个接口的具体实现-->
  6. <mapper namespace="com.courage.dao.EmpDao">
  8.     <!--再做查询的时候，有时候需要关联其他对象，因此需要使用关联查询
  9.     可以通过下面自定义结果集的方式实现
  10.     -->
  11.     <select id="selectEmpAndDept" resultMap="empDept">
  12.         select * from emp left join dept on emp.deptno = dept.deptno where empno = #{empno};
  13.     </select>
  14.     <resultMap id="empDept" type="com.courage.bean.Emp">
  15.         <id column="empno" property="empno"></id>
  16.         <result column="ename" property="ename"></result>
  17.         <result column="job" property="job"></result>
  18.         <result column="mgr" property="mgr"></result>
  19.         <result column="hiredate" property="hiredate"></result>
  20.         <result column="sal" property="sal"></result>
  21.         <result column="comm" property="common"></result>
  22.         <result column="deptno" property="dept.deptno"></result>
  23.         <result column="dname" property="dept.dname"></result>
  24.         <result column="loc" property="dept.loc"></result>
  25.     </resultMap>
  26.     <!--在mybatis中还提供了一种简单的形式，使用association标签可以搞定
  27.     -->
  28.     <resultMap id="empDept" type="com.courage.bean.Emp">
  29.         <id column="empno" property="empno"></id>
  30.         <result column="ename" property="ename"></result>
  31.         <result column="job" property="job"></result>
  32.         <result column="mgr" property="mgr"></result>
  33.         <result column="hiredate" property="hiredate"></result>
  34.         <result column="sal" property="sal"></result>
  35.         <result column="comm" property="common"></result>
  36.         <association property="dept" javaType="com.courage.bean.Dept">
  37.             <id column="deptno" property="deptno"></id>
  38.             <result column="dname" property="dname"></result>
  39.             <result column="loc" property="loc"></result>
  40.         </association>
  41.     </resultMap>
  42. </mapper>

Test

  1.     @Test
  2.     public void test08() {
  4.         // 获取数据库的会话
  5.         SqlSession sqlSession = sqlSessionFactory.openSession();
  6.         try {
  7.             EmpDao mapper = sqlSession.getMapper(EmpDao.class);
  8.             Emp emp = mapper.selectEmpAndDept(7369);
  9.             System.out.println(emp);
  10.         } catch (Exception e) {
  11.             e.printStackTrace();
  12.         } finally {
  13.             sqlSession.close();
  14.         }
  15.     }

6、获取集合元素

Dept.java

  1. package com.courage.bean;
  3. import java.util.List;
  5. public class Dept {
  6.     private Integer deptno;
  7.     private String dname;
  8.     private String loc;
  10.     private List<Emp> emps;
  12.     public Dept() {
  13.     }
  15.     public Dept(Integer deptno, String dname, String loc) {
  16.         this.deptno = deptno;
  17.         this.dname = dname;
  18.         this.loc = loc;
  19.     }
  21.     public Integer getDeptno() {
  22.         return deptno;
  23.     }
  25.     public void setDeptno(Integer deptno) {
  26.         this.deptno = deptno;
  27.     }
  29.     public String getDname() {
  30.         return dname;
  31.     }
  33.     public void setDname(String dname) {
  34.         this.dname = dname;
  35.     }
  37.     public String getLoc() {
  38.         return loc;
  39.     }
  41.     public void setLoc(String loc) {
  42.         this.loc = loc;
  43.     }
  45.     public List<Emp> getEmps() {
  46.         return emps;
  47.     }
  49.     public void setEmps(List<Emp> emps) {
  50.         this.emps = emps;
  51.     }
  53.     @Override
  54.     public String toString() {
  55.         return "Dept{" +
  56.                 "deptno=" + deptno +
  57.                 ", dname='" + dname + '\'' +
  58.                 ", loc='" + loc + '\'' +
  59.                 ", emps=" + emps +
  60.                 '}';
  61.     }
  62. }

DeptDao.java

  1. package com.courage.dao;
  3. import com.courage.bean.Dept;
  4. import com.courage.bean.Emp;
  6. import java.util.List;
  8. public interface DeptDao {
  10.     public Dept getDeptAndEmps(Integer deptno);
  11. }

DeptDao.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.courage.dao.DeptDao">
  6.     <!--定义查询集合元素-->
  7.     <select id="getDeptAndEmps" resultMap="deptEmp">
  8.         select * from dept left join emp on dept.deptno = emp.deptno where dept.deptno=#{deptno}
  9.     </select>
  10.     <resultMap id="deptEmp" type="com.courage.bean.Dept">
  11.         <id property="deptno" column="deptno"></id>
  12.         <result property="dname" column="dname"></result>
  13.         <result property="loc" column="loc"></result>
  14.         <!--封装集合类的元素
  15.             property：指定集合的属性
  16.             ofType:指定集合中的元素类型
  17.         -->
  18.         <collection property="emps" ofType="com.courage.bean.Emp">
  19.             <id property="empno" column="empno"></id>
  20.             <result column="ename" property="ename"></result>
  21.             <result column="job" property="job"></result>
  22.             <result column="mgr" property="mgr"></result>
  23.             <result column="hiredate" property="hiredate"></result>
  24.             <result column="sal" property="sal"></result>
  25.             <result column="comm" property="common"></result>
  26.         </collection>
  27.     </resultMap>
  28. </mapper>

Test

  1.     @Test
  2.     public void test09() {
  4.         // 获取数据库的会话
  5.         SqlSession sqlSession = sqlSessionFactory.openSession();
  6.         try {
  7.             DeptDao mapper = sqlSession.getMapper(DeptDao.class);
  8.             Dept deptAndEmps = mapper.getDeptAndEmps(10);
  9.             System.out.println(deptAndEmps);
  10.         } catch (Exception e) {
  11.             e.printStackTrace();
  12.         } finally {
  13.             sqlSession.close();
  14.         }
  15.     }

7、分步查询

​ 在上述逻辑的查询中，是由我们自己来完成sql语句的关联查询的，那么，我们能让mybatis帮我们实现自动的关联查询吗?

关联查询的分步

DeptDao.java

  1. package com.courage.dao;
  3. import com.courage.bean.Dept;
  4. import com.courage.bean.Emp;
  6. import java.util.List;
  8. public interface DeptDao {
  10.     public Dept getDeptAndEmps(Integer deptno);
  12.     public Dept getDeptAndEmpsBySimple(Integer deptno);
  13. }

EmpDao.java

  1. package com.courage.dao;
  3. import com.courage.bean.Emp;
  4. import org.apache.ibatis.annotations.MapKey;
  5. import org.apache.ibatis.annotations.Param;
  7. import java.util.List;
  8. import java.util.Map;
  10. public interface EmpDao {
  12.     Emp selectEmpAndDept(Integer empno);
  13.     Emp selectEmpAndDeptBySimple(Integer empno);
  14. }

DeptDao.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.courage.dao.DeptDao">
  6.     <select id="getDeptAndEmpsBySimple" resultType="com.courage.bean.Dept">
  7.         select * from dept where deptno = #{deptno}
  8.     </select>
  9. </mapper>

EmpDao.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.courage.dao.EmpDao">
  7.     <select id="selectEmpAndDeptBySimple" resultMap="simpleEmpAndDept">
  8.         select * from emp where empno = #{empno}
  9.     </select>
  10.     <resultMap id="simpleEmpAndDept" type="com.courage.bean.Emp">
  11.         <id column="empno" property="empno"></id>
  12.         <result column="ename" property="ename"></result>
  13.         <result column="job" property="job"></result>
  14.         <result column="mgr" property="mgr"></result>
  15.         <result column="hiredate" property="hiredate"></result>
  16.         <result column="sal" property="sal"></result>
  17.         <result column="comm" property="common"></result>
  18.         <association property="dept" select="com.courage.dao.DeptDao.getDeptAndEmpsBySimple" column="deptno">
  19.         </association>
  20.     </resultMap>
  21. </mapper>

Test

  1. @Test
  2.     public void test08() {
  4.         // 获取数据库的会话
  5.         SqlSession sqlSession = sqlSessionFactory.openSession();
  6.         try {
  7.             EmpDao mapper = sqlSession.getMapper(EmpDao.class);
  8. //            Emp emp = mapper.selectEmpAndDept(7369);
  9.             Emp emp = mapper.selectEmpAndDeptBySimple(7369);
  10.             System.out.println(emp);
  11.         } catch (Exception e) {
  12.             e.printStackTrace();
  13.         } finally {
  14.             sqlSession.close();
  15.         }
  16.     }

集合的分步查询

EmpDao.java

  1. package com.courage.dao;
  3. import com.courage.bean.Emp;
  4. import org.apache.ibatis.annotations.MapKey;
  5. import org.apache.ibatis.annotations.Param;
  7. import java.util.List;
  8. import java.util.Map;
  10. public interface EmpDao {
  11.     Emp selectEmpAndDeptBySimple(Integer empno);
  12.     Emp selectEmpByStep(Integer empno);
  13. }

DeptDao.java

  1. package com.courage.dao;
  3. import com.courage.bean.Dept;
  4. import com.courage.bean.Emp;
  6. import java.util.List;
  8. public interface DeptDao {
  10.     public Dept getDeptAndEmps(Integer deptno);
  12.     public Dept getDeptAndEmpsBySimple(Integer deptno);
  14.     public Dept getDeptAndEmpsByStep(Integer deptno);
  15. }

EmpDao.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.courage.dao.EmpDao">
  7.     <select id="selectEmpByStep" resultType="com.courage.bean.Emp">
  8.         select * from emp where deptno = #{deptno}
  9.     </select>
  10. </mapper>

DeptDao.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.courage.dao.DeptDao">
  7.     <select id="getDeptAndEmpsByStep" resultMap="deptEmpByStep">
  8.         select * from dept where deptno = #{deptno}
  9.     </select>
  10.     <resultMap id="deptEmpByStep" type="com.courage.bean.Dept">
  11.         <id property="deptno" column="deptno"></id>
  12.         <result property="dname" column="dname"></result>
  13.         <result property="loc" column="loc"></result>
  14.         <!--封装集合类的元素
  15.             property：指定集合的属性
  16.             ofType:指定集合中的元素类型
  17.         -->
  18.         <collection property="emps" ofType="com.courage.bean.Emp" select="com.courage.dao.EmpDao.selectEmpByStep" column="deptno">
  19.         </collection>
  20.     </resultMap>
  21. </mapper>

Test

  1.     @Test
  2.     public void test09() {
  4.         // 获取数据库的会话
  5.         SqlSession sqlSession = sqlSessionFactory.openSession();
  6.         try {
  7.             DeptDao mapper = sqlSession.getMapper(DeptDao.class);
  8. //            Dept deptAndEmps = mapper.getDeptAndEmps(10);
  9.             Dept deptAndEmpsByStep = mapper.getDeptAndEmpsByStep(10);
  10.             System.out.println(deptAndEmpsByStep);
  11.         } catch (Exception e) {
  12.             e.printStackTrace();
  13.         } finally {
  14.             sqlSession.close();
  15.         }
  16.     }

8、延迟查询

​ 当我们在进行表关联的时候，有可能在查询结果的时候不需要关联对象的属性值，那么此时可以通过延迟加载来实现功能。在全局配置文件中添加如下属性

mybatis-config.xml

  1.  <settings>
  2.         <!--开启延时加载-->
  3.         <setting name="lazyLoadingEnabled" value="true"/>
  4.     </settings>

如果设置了全局加载，但是希望在某一个sql语句查询的时候不适用延时策略，可以添加如下属性：

  1.         <association property="dept" select="com.courage.dao.DeptDao.getDeptAndEmpsBySimple" column="deptno" fetchType="eager"/>

三、动态SQL

​ 动态 SQL 是 MyBatis 的强大特性之一。在 JDBC 或其它类似的框架中，根据不同条件拼接 SQL 语句是很痛苦的，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。

​ 使用动态 SQL 并非一件易事，借助可用于任何 SQL 映射语句中的强大的动态 SQL 语言，MyBatis 显著地提升了这一特性的易用性。

​ 在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。

  • if
  • choose (when, otherwise)
  • trim (where, set)
  • foreach

1、if

EmpDao.xml

  1. <select id="getEmpByCondition" resultType="com.courage.bean.Emp">
  2.         select * from emp where
  3.         <if test="empno!=null">
  4.             empno > #{empno} and
  5.         </if>
  6.         <if test="ename!=null">
  7.             ename like #{ename} and
  8.         </if>
  9.         <if test="sal!=null">
  10.             sal > #{sal}
  11.         </if>
  12.     </select>

EmpDao.java

  1. public List<Emp> getEmpByCondition(Emp emp);

Test.java

  1.  @Test
  2.     public void test10() {
  4.         SqlSession sqlSession = sqlSessionFactory.openSession();
  5.         try {
  6.             EmpDao mapper = sqlSession.getMapper(EmpDao.class);
  7.             Emp emp = new Emp();
  8.             emp.setEmpno(6500);
  9.             emp.setEname("%E%");
  10.             emp.setSal(500.0);
  11.             List<Emp> empByCondition = mapper.getEmpByCondition(emp);
  12.             for (Emp emp1 : empByCondition) {
  13.                 System.out.println(emp1);
  14.             }
  15.         } catch (Exception e) {
  16.             e.printStackTrace();
  17.         } finally {
  18.             sqlSession.close();
  19.         }
  20.     }

​ 看起来测试是比较正常的，但是大家需要注意的是如果我们传入的参数值有缺失会怎么呢？这个时候拼接的sql语句就会变得有问题，例如不传参数或者丢失最后一个参数，那么语句中就会多一个where或者and的关键字，因此在mybatis中也给出了具体的解决方案：

​ where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

  1. <select id="getEmpByCondition" resultType="com.courage.bean.Emp">
  2.         select * from emp
  3.         <where>
  4.             <if test="empno!=null">
  5.                 empno > #{empno}
  6.             </if>
  7.             <if test="ename!=null">
  8.                 and ename like #{ename}
  9.             </if>
  10.             <if test="sal!=null">
  11.                 and sal > #{sal}
  12.             </if>
  13.         </where>
  14.     </select>

​ 现在看起来没有什么问题了，但是我们的条件添加到了拼接sql语句的前后，那么我们该如何处理呢？

  1.  <!--
  2.     trim截取字符串：
  3.     prefix：前缀，为sql整体添加一个前缀
  4.     prefixOverrides:去除整体字符串前面多余的字符
  5.     suffixOverrides:去除后面多余的字符串
  6.     -->
  7.     <select id="getEmpByCondition" resultType="com.courage.bean.Emp">
  8.         select * from emp
  10.         <trim prefix="where" prefixOverrides="and" suffixOverrides="and">
  11.             <if test="empno!=null">
  12.                 empno > #{empno} and
  13.             </if>
  14.             <if test="ename!=null">
  15.                 ename like #{ename} and
  16.             </if>
  17.             <if test="sal!=null">
  18.                 sal > #{sal} and
  19.             </if>
  20.         </trim>
  21.     </select>

2、foreach

​ 动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 IN 条件语句的时候）。

  1. <!--foreach是对集合进行遍历
  2.     collection="deptnos"  指定要遍历的集合
  3.     close="" 表示以什么结束
  4.     index="" 给定一个索引值
  5.     item=""  遍历的每一个元素的值
  6.     open=""  表示以什么开始
  7.     separator="" 表示多个元素的分隔符
  8.     -->
  9.     <select id="getEmpByDeptnos" resultType="Emp">
  10.         select * from emp where deptno in
  11.         <foreach collection="deptnos" close=")" index="idx" item="deptno" open="(" separator=",">
  12.             #{deptno}
  13.         </foreach>
  14.     </select>

3、choose

​ 有时候，我们不想使用所有的条件，而只是想从多个条件中选择一个使用。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句。

  1. <select id="getEmpByConditionChoose" resultType="com.courage.bean.Emp">
  2.         select * from emp
  3.         <where>
  4.             <choose>
  5.                 <when test="empno!=null">
  6.                     empno > #{empno}
  7.                 </when>
  8.                 <when test="ename!=null">
  9.                     ename like #{ename}
  10.                 </when>
  11.                 <when test="sal!=null">
  12.                     sal > #{sal}
  13.                 </when>
  14.                 <otherwise>
  15.                     1=1
  16.                 </otherwise>
  17.             </choose>
  18.         </where>
  19.     </select>

4、set

​ 用于动态更新语句的类似解决方案叫做 set。set 元素可以用于动态包含需要更新的列，忽略其它不更新的列。

  1. <update id="updateEmpByEmpno">
  2.     update emp
  3.     <set>
  4.         <if test="empno!=null">
  5.             empno=#{empno},
  6.         </if>
  7.         <if test="ename!=null">
  8.             ename = #{ename},
  9.         </if>
  10.         <if test="sal!=null">
  11.             sal = #{sal}
  12.         </if>
  13.     </set>
  14.     <where>
  15.         empno = #{empno}
  16.     </where>
  17. </update>

四、缓存

​ MyBatis 内置了一个强大的事务性查询缓存机制，它可以非常方便地配置和定制。 为了使它更加强大而且易于配置，我们对 MyBatis 3 中的缓存实现进行了许多改进。

​ 默认情况下，只启用了本地的会话缓存，它仅仅对一个会话中的数据进行缓存。 要启用全局的二级缓存，只需要在你的 SQL 映射文件中添加一行：

  1. <cache/>

当添加上该标签之后，会有如下效果：

  • 映射语句文件中的所有 select 语句的结果将会被缓存。
  • 映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
  • 缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
  • 缓存不会定时进行刷新（也就是说，没有刷新间隔）。
  • 缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
  • 缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

在进行配置的时候还会分为一级缓存和二级缓存：

一级缓存：线程级别的缓存，是本地缓存，sqlSession级别的缓存

二级缓存：全局范围的缓存，不止局限于当前会话

1、一级缓存的使用

​ 一级缓存是sqlsession级别的缓存，默认是存在的。在下面的案例中，大家发现我发送了两个相同的请求，但是sql语句仅仅执行了一次，那么就意味着第一次查询的时候已经将结果进行了缓存。

  1.  @Test
  2.     public void test01() {
  4.         SqlSession sqlSession = sqlSessionFactory.openSession();
  5.         try {
  6.             EmpDao mapper = sqlSession.getMapper(EmpDao.class);
  7.             List<Emp> list = mapper.selectAllEmp();
  8.             for (Emp emp : list) {
  9.                 System.out.println(emp);
  10.             }
  11.             System.out.println("--------------------------------");
  12.             List<Emp> list2 = mapper.selectAllEmp();
  13.             for (Emp emp : list2) {
  14.                 System.out.println(emp);
  15.             }
  16.         } catch (Exception e) {
  17.             e.printStackTrace();
  18.         } finally {
  19.             sqlSession.close();
  20.         }
  21.     }

​ 在大部分的情况下一级缓存是可以的，但是有几种特殊的情况会造成一级缓存失效：

1、一级缓存是sqlSession级别的缓存，如果在应用程序中只有开启了多个sqlsession，那么会造成缓存失效

  1. @Test
  2.     public void test02(){
  3.         SqlSession sqlSession = sqlSessionFactory.openSession();
  4.         EmpDao mapper = sqlSession.getMapper(EmpDao.class);
  5.         List<Emp> list = mapper.selectAllEmp();
  6.         for (Emp emp : list) {
  7.             System.out.println(emp);
  8.         }
  9.         System.out.println("================================");
  10.         SqlSession sqlSession2 = sqlSessionFactory.openSession();
  11.         EmpDao mapper2 = sqlSession2.getMapper(EmpDao.class);
  12.         List<Emp> list2 = mapper2.selectAllEmp();
  13.         for (Emp emp : list2) {
  14.             System.out.println(emp);
  15.         }
  16.         sqlSession.close();
  17.         sqlSession2.close();
  18.     }

2、在编写查询的sql语句的时候，一定要注意传递的参数，如果参数不一致，那么也不会缓存结果

3、如果在发送过程中发生了数据的修改，那么结果就不会缓存

  1.  @Test
  2.     public void test03(){
  3.         SqlSession sqlSession = sqlSessionFactory.openSession();
  4.         EmpDao mapper = sqlSession.getMapper(EmpDao.class);
  5.         Emp empByEmpno = mapper.findEmpByEmpno(1111);
  6.         System.out.println(empByEmpno);
  7.         System.out.println("================================");
  8.         empByEmpno.setEname("zhangsan");
  9.         int i = mapper.updateEmp(empByEmpno);
  10.         System.out.println(i);
  11.         System.out.println("================================");
  12.         Emp empByEmpno1 = mapper.findEmpByEmpno(1111);
  13.         System.out.println(empByEmpno1);
  14.         sqlSession.close();
  15.     }

4、在两次查询期间，手动去清空缓存，也会让缓存失效

  1. @Test
  2.     public void test03(){
  3.         SqlSession sqlSession = sqlSessionFactory.openSession();
  4.         EmpDao mapper = sqlSession.getMapper(EmpDao.class);
  5.         Emp empByEmpno = mapper.findEmpByEmpno(1111);
  6.         System.out.println(empByEmpno);
  7.         System.out.println("================================");
  8.         System.out.println("手动清空缓存");
  9.         sqlSession.clearCache();
  10.         System.out.println("================================");
  11.         Emp empByEmpno1 = mapper.findEmpByEmpno(1111);
  12.         System.out.println(empByEmpno1);
  13.         sqlSession.close();
  14.     }

2、二级缓存

​ 二级缓存是全局作用域缓存，默认是不开启的，需要手动进行配置。

​ Mybatis提供二级缓存的接口以及实现，缓存实现的时候要求实体类实现Serializable接口，二级缓存在sqlSession关闭或提交之后才会生效。

a、缓存的使用

​ 步骤：

​ 1、全局配置文件中添加如下配置：

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

​ 2、需要在使用二级缓存的映射文件出使用标签标注

​ 3、实体类必须要实现Serializable接口

  1. @Test
  2.     public void test04(){
  3.         SqlSession sqlSession = sqlSessionFactory.openSession();
  4.         SqlSession sqlSession2 = sqlSessionFactory.openSession();
  5.         EmpDao mapper = sqlSession.getMapper(EmpDao.class);
  6.         EmpDao mapper2 = sqlSession2.getMapper(EmpDao.class);
  7.         Emp empByEmpno = mapper.findEmpByEmpno(1111);
  8.         System.out.println(empByEmpno);
  9.         sqlSession.close();
  11.         Emp empByEmpno1 = mapper2.findEmpByEmpno(1111);
  12.         System.out.println(empByEmpno1);
  13.         sqlSession2.close();
  14.     }

b、缓存的属性

​ eviction:表示缓存回收策略，默认是LRU

​ LRU：最近最少使用的，移除最长时间不被使用的对象

​ FIFO：先进先出，按照对象进入缓存的顺序来移除

​ SOFT：软引用，移除基于垃圾回收器状态和软引用规则的对象

​ WEAK：弱引用，更积极地移除基于垃圾收集器状态和弱引用规则的对象

​ flushInternal:刷新间隔，单位毫秒

​ 默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新

​ size：引用数目，正整数

​ 代表缓存最多可以存储多少个对象，太大容易导致内存溢出

​ readonly：只读，true/false

​ true：只读缓存，会给所有调用这返回缓存对象的相同实例，因此这些对象不能被修改。

​ false：读写缓存，会返回缓存对象的拷贝（序列化实现），这种方式比较安全，默认值

  1. 	//可以看到会去二级缓存中查找数据，而且二级缓存跟一级缓存中不会同时存在数据，因为二级缓存中的数据是在sqlsession 关闭之后才生效的
  2. 	@Test
  3.     public void test05(){
  4.         SqlSession sqlSession = sqlSessionFactory.openSession();
  5.         EmpDao mapper = sqlSession.getMapper(EmpDao.class);
  6.         Emp empByEmpno = mapper.findEmpByEmpno(1111);
  7.         System.out.println(empByEmpno);
  8.         sqlSession.close();
  10.         SqlSession sqlSession2 = sqlSessionFactory.openSession();
  11.         EmpDao mapper2 = sqlSession2.getMapper(EmpDao.class);
  12.         Emp empByEmpno2 = mapper2.findEmpByEmpno(1111);
  13.         System.out.println(empByEmpno2);
  14.         Emp empByEmpno3 = mapper2.findEmpByEmpno(1111);
  15.         System.out.println(empByEmpno3);
  16.         sqlSession2.close();
  17.     }
  19. 	// 缓存查询的顺序是先查询二级缓存再查询一级缓存
  20.  	@Test
  21.     public void test05(){
  22.         SqlSession sqlSession = sqlSessionFactory.openSession();
  23.         EmpDao mapper = sqlSession.getMapper(EmpDao.class);
  24.         Emp empByEmpno = mapper.findEmpByEmpno(1111);
  25.         System.out.println(empByEmpno);
  26.         sqlSession.close();
  28.         SqlSession sqlSession2 = sqlSessionFactory.openSession();
  29.         EmpDao mapper2 = sqlSession2.getMapper(EmpDao.class);
  30.         Emp empByEmpno2 = mapper2.findEmpByEmpno(1111);
  31.         System.out.println(empByEmpno2);
  32.         Emp empByEmpno3 = mapper2.findEmpByEmpno(1111);
  33.         System.out.println(empByEmpno3);
  35.         Emp empByEmpno4 = mapper2.findEmpByEmpno(7369);
  36.         System.out.println(empByEmpno4);
  37.         Emp empByEmpno5 = mapper2.findEmpByEmpno(7369);
  38.         System.out.println(empByEmpno5);
  39.         sqlSession2.close();
  40.     }

3、二级缓存的作用范围：

​ 如果设置了全局的二级缓存配置，那么在使用的时候需要注意，在每一个单独的select语句中，可以设置将查询缓存关闭，以完成特殊的设置

​ 1、在setting中设置，是配置二级缓存开启，一级缓存默认一直开启

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

​ 2、select标签的useCache属性：

​ 在每一个select的查询中可以设置当前查询是否要使用二级缓存，只对二级缓存有效

​ 3、sql标签的flushCache属性

​ 增删改操作默认值为true，sql执行之后会清空一级缓存和二级缓存，而查询操作默认是false

​ 4、sqlSession.clearCache()

​ 只是用来清楚一级缓存

3、整合第三方缓存

​ 在某些情况下我们也可以自定义实现缓存，或为其他第三方缓存方案创建适配器，来完全覆盖缓存行为。

​ 1、导入对应的maven依赖

  1.  <!-- https://mvnrepository.com/artifact/org.ehcache/ehcache -->
  2.         <dependency>
  3.             <groupId>org.ehcache</groupId>
  4.             <artifactId>ehcache</artifactId>
  5.             <version>3.8.1</version>
  6.         </dependency>
  7.         <!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
  8.         <dependency>
  9.             <groupId>org.mybatis.caches</groupId>
  10.             <artifactId>mybatis-ehcache</artifactId>
  11.             <version>1.2.0</version>
  12.         </dependency>
  13.         <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
  14.         <dependency>
  15.             <groupId>org.slf4j</groupId>
  16.             <artifactId>slf4j-api</artifactId>
  17.             <version>2.0.0-alpha1</version>
  18.         </dependency>
  19.         <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
  20.         <dependency>
  21.             <groupId>org.slf4j</groupId>
  22.             <artifactId>slf4j-log4j12</artifactId>
  23.             <version>2.0.0-alpha1</version>
  24.             <scope>test</scope>
  25.         </dependency>

​ 2、导入ehcache配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.  xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">
  4.  <!-- 磁盘保存路径 -->
  5.  <diskStore path="D:\ehcache" />
  7.  <defaultCache
  8.    maxElementsInMemory="1"
  9.    maxElementsOnDisk="10000000"
  10.    eternal="false"
  11.    overflowToDisk="true"
  12.    timeToIdleSeconds="120"
  13.    timeToLiveSeconds="120"
  14.    diskExpiryThreadIntervalSeconds="120"
  15.    memoryStoreEvictionPolicy="LRU">
  16.  </defaultCache>
  17. </ehcache>
  19. <!--
  20. 属性说明：
  21. l diskStore：指定数据在磁盘中的存储位置。
  22. l defaultCache：当借助CacheManager.add("demoCache")创建Cache时，EhCache便会采用<defalutCache/>指定的的管理策略
  24. 以下属性是必须的：
  25. l maxElementsInMemory - 在内存中缓存的element的最大数目
  26. l maxElementsOnDisk - 在磁盘上缓存的element的最大数目，若是0表示无穷大
  27. l eternal - 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断
  28. l overflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
  30. 以下属性是可选的：
  31. l timeToIdleSeconds - 当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大
  32. l timeToLiveSeconds - 缓存element的有效生命期，默认是0.,也就是element存活时间无穷大
  33.  diskSpoolBufferSizeMB 这个参数设置DiskStore(磁盘缓存)的缓存区大小.默认是30MB.每个Cache都应该有自己的一个缓冲区.
  34. l diskPersistent - 在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。
  35. l diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
  36. l memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）
  37.  -->

​ 3、在mapper文件中添加自定义缓存

  1.     <cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache>

Mybatis SQL映射文件详解的更多相关文章

  1. Mybatis(三) 映射文件详解

    前面说了全局配置文件中内容的详解,大家应该清楚了,现在来说说这映射文件,这章就对输入映射.输出映射.动态sql这几个知识点进行说明,其中高级映射(一对一,一对多,多对多映射)在下一章进行说明. 一.输 ...

  2. MyBatis 映射文件详解(六）

    MyBatis 配置文件类型 MyBatis配置文件有两种类型,如下: 全局配置文件(如 mybatis-config.xml) Mapper XML 映射文件(如 UserMapper.xml) 上 ...

  3. Hibernate配置文件和映射文件详解

    Hibernate是一个彻底的ORM(Object Relational Mapping,对象关系映射)开源框架. 我们先看一下官方文档所给出的,Hibernate 体系结构的高层视图: 其中PO=P ...

  4. Mybatis sql映射文件浅析 Mybatis简介（三）

    简介 除了配置相关之外,另一个核心就是SQL映射,MyBatis 的真正强大也在于它的映射语句. Mybatis创建了一套规则以XML为载体映射SQL 之前提到过,各项配置信息将Mybatis应用的整 ...

  5. Mybatis sql映射文件浅析 Mybatis简介（三） 简介

    Mybatis sql映射文件浅析 Mybatis简介(三)   简介 除了配置相关之外,另一个核心就是SQL映射,MyBatis 的真正强大也在于它的映射语句. Mybatis创建了一套规则以XML ...

  6. 笔记：MyBatis Mapper XML文件详解 - 映射和参数

    MyBatis 的真正强大在于它的映射语句,也是它的魔力所在.由于它的异常强大,映射器的 XML 文件就显得相对简单.如果拿它跟具有相同功能的 JDBC 代码进行对比,你会立即发现省掉了将近 95% ...

  7. 笔记：MyBatis Mapper XML文件详解 - Cache

    缓存(Cache) 从数据库中加载的数据缓存到内存中,是很多应用程序为了提高性能而采取的一贯做法.MyBatis对通过映射的SELECT语句加载的查询结果提供了内建的缓存支持.默认情况下,启用一级缓存 ...

  8. MyBatis -- sql映射文件具体解释

    MyBatis 真正的力量是在映射语句中. 和对等功能的jdbc来比价,映射文件节省非常多的代码量. MyBatis的构建就是聚焦于sql的. sql映射文件有例如以下几个顶级元素:(按顺序) cac ...

  9. SSM - Mybatis SQL映射文件

    MyBatis 真正的力量是在映射语句中.和对等功能的jdbc来比价,映射文件节省很多的代码量.MyBatis的构建就是聚焦于sql的. sql映射文件有如下几个顶级元素:(按顺序) cache配置给 ...

随机推荐

  1. 在python中元组与列表的区别及序列解包

    一. 元组与列表的区别 元组中的数据一旦定义就不允许更改. 元组没有append().extend()和insert()等方法,无法向元组中添加元素. 元组没有remove()或pop()方法,也无法 ...

  2. Argo CD使用指南：如何构建一套完整的GitOps？

    随着Kubernetes继续将自己确立为容器编排的行业标准,为你的应用和工具找到使用声明式模型的有效方法是成功的关键.在这篇文章中,我们将在AWS中建立一个K3s Kubernetes集群,然后使用A ...

  3. 4.自定义view-进度条控件

    1.效果 2.实现原理 画圆,画圆弧,画文字 外部控制进度,通过invalidate()方法更新 核心代码: @Override protected void onDraw(Canvas canvas ...

  4. java使用map去重复

    public class Test { public static void main(String[] args) { Map<Number, String> map1 = new Ha ...

  5. js对比两个时间的大小

    /** * 时间对比 开始=结束返回0;开始>结束返回-1;开始<结束返回1 */ function dateComparison(date1,date2){ var start =new ...

  6. HTML文本格式化标签

    1 <!DOCTYPE html> 2 <html> 3 <head> 4 <meta charset="UTF-8"> 5 < ...

  7. FileZilla使用教程

    FileZilla使用教程和问题汇总 正式开始之前我还是想闲聊几句,毕竟调试解决这些问题,整整耗了我一天半的时间.前不久学校要求上交一个web大作业,然后我们宿舍就寻思光做出来前后端搞头不大,不如整个 ...

  8. .NET C#中处理Url中文编码问题

    近些日子在做一个用C#访问webservise的程序,由于需要传递中文参数去请求网站,所以碰到了中文编码问题.我们知道像百度这种搜索引擎中,当用户输入中文关键字后,它会把中文转码,以确保在Url中不会 ...

  9. Turtlebot3新手教程：OpenCR软件设置(shell)

    *本文针对如何利用脚本来更新固件进行讲解 具体步骤如下: burger的固件更新 $ export OPENCR_PORT=/dev/ttyACM0 $ export OPENCR_MODEL=bur ...

  10. 看图知义，Winform开发的技术特点分析

    整理一下自己之前的Winform开发要点,以图文的方式展示一些关键性的技术特点,总结一下. 1.主体界面布局 2.权限管理系统 3.工作流模块 4.字典管理 5.通用的附件管理模块 6.系统模块化开发 ...