关本文是Mybatis基础系列的第四篇文章，点击下面链接可以查看前面的文章：

mybatis基础系列（三）——动态sql

mybatis基础系列（二）——基础语法、别名、输入映射、输出映射

mybatis基础系列（一）——mybatis入门

关联查询

表设计时通常需要分析表与表的关联关系、数据库级别表与表之间的业务关系。

一对一查询

员工表和部门表之间的关系分析：一个员工只能属于一个部门。

需求：查询出员工编号为7369的员工信息和部门信息。

sql语句：

  1. select * from t_emp JOIN t_dept on(t_emp.deptno=t_dept.deptno) where t_emp.empno=7369

resultType映射

看看mybatis中的写法

mapper.xml

  1. <select id="queryEmpDeptInfo" parameterType="com.itpsc.request.EmpRequest" resultType="com.itpsc.vo.EmpVo">
  2. select * from t_emp JOIN t_dept on(t_emp.deptno=t_dept.deptno) where t_emp.empno=#{emp.empno}
  3. </select>

扩展Emp类增加部门熟悉

  1. public class EmpVo extends Emp{
  2. //增加dept表的属性
  3.     private Integer deptno;
  4.     private String dname;
  5.     private String loc;
  6. //....
  7. }

运行结果

  1. ==>  Preparing: select * from t_emp JOIN t_dept on(t_emp.deptno=t_dept.deptno) where t_emp.empno=?
  2. ==> Parameters: 7369(Integer)
  3. <==    Columns: empno, ename, job, mgr, hiredate, sal, comm, deptno, deptno, dname, loc
  4. <==        Row: 7369, SMITH, CLERK, 7902, 1980-12-17, 800.00, null, 20, 20, RESEARCH, DALLAS
  5. <==      Total: 1
  6. Closing non transactional SqlSession
  7. [org.apache.ibatis.session.defaults.DefaultSqlSession@266e9dda]
  8. Emp{empno=7369, ename='SMITH', job='CLERK', mgr=7902, hiredate=Wed Dec 17 00:00:00 CST 1980, sal=800.0, comm=null, deptno=null}

从上面可以看出，如果输出映射的实体类中没有包括查询出来的列名，需要增加列名对应的属性，即可完成映射。

resultMap映射

除了用EmpVo类继承Emp类并且增加部门属性外，也可以在Emp类中增加Dept类型的对象来完成映射。mapper.xml中association 标签来映射关联对象。

  1. public class Emp {
  2.     private Integer empno;
  3.     private String ename;
  4.     private String job;
  5.     private Integer mgr;
  6.     private Date hiredate;
  7.     private Float sal;
  8.     private Float comm;
  9.     private Integer deptno;
  10.     private Dept dept;
  11. //....
  12. }

mybatis的写法

  1. <select id="queryEmpDeptInfo" parameterType="com.itpsc.request.EmpRequest" resultMap="empMap">
  2. select * from t_emp JOIN t_dept on(t_emp.deptno=t_dept.deptno) where t_emp.empno=#{emp.empno}
  3. </select>
  4.  
  5.   <resultMap id="empMap" type="com.itpsc.entity.Emp" >
  6.     <result column="empno" property="empno" jdbcType="INTEGER" />
  7.     <result column="ename" property="ename" jdbcType="VARCHAR" />
  8.     <result column="job" property="job" jdbcType="VARCHAR" />
  9.     <result column="mgr" property="mgr" jdbcType="INTEGER" />
  10.     <result column="hiredate" property="hiredate" jdbcType="DATE" />
  11.     <result column="sal" property="sal" jdbcType="REAL" />
  12.     <result column="comm" property="comm" jdbcType="REAL" />
  13.     <result column="deptno" property="deptno" jdbcType="INTEGER" />
  14.     <association property="dept" javaType="com.itpsc.entity.Dept">
  15.       <result column="deptno" property="deptno" jdbcType="INTEGER" />
  16.       <result column="dname" property="dname" jdbcType="VARCHAR" />
  17.       <result column="loc" property="loc" jdbcType="VARCHAR" />
  18.     </association>
  19.   </resultMap>

运行结果

  1. ==>  Preparing: select * from t_emp JOIN t_dept on(t_emp.deptno=t_dept.deptno) where t_emp.empno=?
  2. ==> Parameters: 7369(Integer)
  3. <==    Columns: empno, ename, job, mgr, hiredate, sal, comm, deptno, deptno, dname, loc
  4. <==        Row: 7369, SMITH, CLERK, 7902, 1980-12-17, 800.00, null, 20, 20, RESEARCH, DALLAS
  5. <==      Total: 1
  6. Closing non transactional
  7. SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@2a87ba34]
  8. Emp{empno=7369, ename='SMITH', job='CLERK', mgr=7902, hiredate=Wed Dec 17 00:00:00 CST 1980, sal=800.0, comm=null, deptno=20, dept=Dept{deptno=20, dname='RESEARCH', loc='DALLAS'}}

一对多查询

部门表和员工表之间的关系分析：一个部门可以有多个员工。

需求：查询部门编号为20的所有员工的信息。

sql语句语法：

  1. select t_emp.* from t_emp JOIN t_dept on(t_emp.deptno=t_dept.deptno) where t_dept.deptno=20;

看看mybatis中的写法：

  1. <select id="queryEmpInfoByDeptno" parameterType="com.itpsc.request.EmpRequest" resultType="com.itpsc.entity.Emp">
  2. select t_emp.* from t_emp JOIN t_dept on(t_emp.deptno=t_dept.deptno) where t_dept.deptno=#{emp.deptno};
  3. </select>

运行结果

  1. ==>  Preparing: select t_emp.* from t_emp JOIN t_dept on(t_emp.deptno=t_dept.deptno) where t_dept.deptno=?;
  2. ==> Parameters: 20(Integer)
  3. <==    Columns: empno, ename, job, mgr, hiredate, sal, comm, deptno
  4. <==        Row: 7369, SMITH, CLERK, 7902, 1980-12-17, 800.00, null, 20
  5. <==        Row: 7566, JONES, MANAGER, 7839, 1981-04-02, 2975.00, null, 20
  6. <==        Row: 7788, SCOTT, ANALYST, 7566, 1987-04-19, 3000.00, null, 20
  7. <==        Row: 7876, ADAMS, CLERK, 7788, 1987-05-23, 1100.00, null, 20
  8. <==        Row: 7902, FORD, ANALYST, 7566, 1981-12-03, 3000.00, null, 20
  9. <==        Row: 7100, itpsc, mannager, 7902, 1980-01-10, null, 1000.00, 20
  10. <==        Row: 7101, itpsc2, developer, 7902, 1980-01-10, 2000.00, 1000.00, 20
  11. <==      Total: 7

多对多查询

部门表和员工表之间的关系分析：一个部门可以有多个员工。

员工表和技能表之间的关系分析：一个员工可以有多个技能。

需求：查询部门编号为20的所有员工的信息，并查询这些员工拥有的技能。

Sql 语句：

  1. select t1.*,t_skill.* from (
  2. select
  3.    t_dept.*,
  4.    t_emp.empno,
  5.    t_emp.ename,
  6.    t_emp.job,
  7.    t_emp.mgr,
  8.    t_emp.hiredate,
  9.    t_emp.sal
  10. from t_emp JOIN t_dept on(t_emp.deptno=t_dept.deptno) where t_dept.deptno=20) t1
  11. join t_skill on (t1.empno=t_skill.empno);

DeptMapper.xml

  1. <mapper namespace="com.itpsc.mapper.DeptMapper" >
  2.     <!--查询部门信息-->
  3.     <resultMap id="deptMap" type="com.itpsc.entity.Dept" >
  4.         <result column="deptno" property="deptno" jdbcType="INTEGER" />
  5.         <result column="dname" property="dname" jdbcType="VARCHAR" />
  6.         <result column="loc" property="loc" jdbcType="VARCHAR" />
  7.         <!--查询部门下的员工信息，一个部门有多个员工，用collection-->
  8.         <collection property="empList" ofType="com.itpsc.entity.Emp">
  9.             <result column="empno" property="empno" jdbcType="INTEGER" />
  10.             <result column="ename" property="ename" jdbcType="VARCHAR" />
  11.             <result column="job" property="job" jdbcType="VARCHAR" />
  12.             <result column="mgr" property="mgr" jdbcType="INTEGER" />
  13.             <result column="hiredate" property="hiredate" jdbcType="DATE" />
  14.             <result column="sal" property="sal" jdbcType="REAL" />
  15.             <result column="comm" property="comm" jdbcType="REAL" />
  16.             <collection property="skillList" ofType="com.itpsc.entity.Skill">
  17.                 <result column="skillid" property="skillid" jdbcType="INTEGER" />
  18.                 <result column="empno" property="empno" jdbcType="INTEGER" />
  19.                 <result column="sname" property="sname" jdbcType="VARCHAR" />
  20.                 <result column="descs" property="descs" jdbcType="VARCHAR" />
  21.             </collection>
  22.         </collection>
  23.     </resultMap>
  24.  
  25. <select id="queryByDeptno" parameterType="com.itpsc.request.EmpRequest" resultMap="deptMap">
  26.         select t1.*,t_skill.* from (
  27.             select
  28.             t_dept.*,
  29.             t_emp.empno,
  30.             t_emp.ename,
  31.             t_emp.job,
  32.             t_emp.mgr,
  33.             t_emp.hiredate,
  34.             t_emp.sal
  35.             from t_emp JOIN t_dept on(t_emp.deptno=t_dept.deptno)
  36.             where t_dept.deptno=#{emp.deptno}) t1
  37.         join t_skill on (t1.empno=t_skill.empno);
  38.     </select>
  39. </mapper>

运行结果

  1. ==>  Preparing: select t1.*,t_skill.* from ( select t_dept.*, t_emp.empno, t_emp.ename, t_emp.job, t_emp.mgr, t_emp.hiredate, t_emp.sal from t_emp JOIN t_dept on(t_emp.deptno=t_dept.deptno) where t_dept.deptno=?) t1 join t_skill on (t1.empno=t_skill.empno);
  2. ==> Parameters: 20(Integer)
  3. ...
  4. <==      Total: 6
  5. Closing non transactional
  6. SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@1129829c]
  7. Dept{deptno=20, dname='RESEARCH', loc='DALLAS', empList=[Emp{empno=7100, ename='itpsc', job='mannager', mgr=7902, hiredate=Thu Jan 10 00:00:00 CST 1980, sal=null, comm=null, deptno=null, skillList=[Skill{skillid=1001, empno=7100, sname='mybatis', descs='database crud'}, Skill{skillid=1002, empno=7100, sname='mysql', descs='data store'}, Skill{skillid=1003, empno=7100, sname='java', descs='program language'}]}, Emp{empno=7369, ename='SMITH', job='CLERK', mgr=7902, hiredate=Wed Dec 17 00:00:00 CST 1980, sal=800.0, comm=null, deptno=null, skillList=[Skill{skillid=1004, empno=7369, sname='spring', descs='spring'}, Skill{skillid=1005, empno=7369, sname='spring mvc', descs='spring mvc'}, Skill{skillid=1006, empno=7369, sname='thymealf', descs='thymealf'}]}]}

总结

resultType：将查询结果按照表列名与java对象属性名一一对应映射到java对象中。

resultMap：自定义表列名与java对象属性名之间的映射关系。结合association和collection完成一对一和一对多高级映射。association标签的作用是将关联的信息映射到一个对象中，实现一对一的映射。而collection标签将关联信息映射到一个list集合中，实现一对多的映射。

延迟加载

延迟加载基本概念

上面我们已经知道使用association、collection可以实现一对一及一对多映射，association、collection还有另外一个延迟加载的功能。

延迟加载(lazy load)是关联对象默认的加载方式，延迟加载机制是为了避免一些无谓的性能开销而提出来的，所谓延迟加载就是当在真正需要数据的时候，才真正执行数据加载操作。

mybatis默认没有开启延迟加载功能，需要在springboot的yml配置文件中启动延迟加载功能：

  1. mybatis-plus:
  2.   mapper-locations: "classpath:com/itpsc/mapper/**/*.xml"
  3.   type-aliases-package: "com.itpsc.entity"
  4.   global-config:
  5.     db-column-underline: true
  6.   configuration:
  7.     map-underscore-to-camel-case: true
  8.     cache-enabled: true #配置的缓存的全局开关
  9.     lazyLoadingEnabled: true #延时加载的开关
  10.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #打印sql语句,调试用

延迟加载例子

比如查询员工信息的时候关联查询员工的部门信息。我们可以先把员工信息查询出来，当遍历员工信息需要查询对应的部门信息的时候，就可以调用员工的getDept()方法去加载部门信息。

EmpMapper.xml

  1. <!--resultMap 延迟加载-->
  2.   <resultMap id="empLazyLoadDeptMap" type="com.itpsc.entity.Emp" >
  3.     <result column="empno" property="empno" jdbcType="INTEGER" />
  4.     <result column="ename" property="ename" jdbcType="VARCHAR" />
  5.     <result column="job" property="job" jdbcType="VARCHAR" />
  6.     <result column="mgr" property="mgr" jdbcType="INTEGER" />
  7.     <result column="hiredate" property="hiredate" jdbcType="DATE" />
  8.     <result column="sal" property="sal" jdbcType="REAL" />
  9.     <result column="comm" property="comm" jdbcType="REAL" />
  10.     <result column="deptno" property="deptno" jdbcType="INTEGER" />
  11.     <!--延迟加载关联对象，Emp对象中延迟加载Dept对象-->
  12.     <association property="dept" javaType="com.itpsc.entity.Dept"
  13.                  select="com.itpsc.mapper.DeptMapper.queryByDeptno" column="deptno">
  14.     </association>
  15.   </resultMap>
  16.  
  17.   <select id="queryEmpLazyLoadDept" resultMap="empLazyLoadDeptMap">
  18.     select * from t_emp;
  19.   </select>

DeptMapper.xml

  1. <select id="queryByDeptno" parameterType="int" resultType="com.itpsc.entity.Dept">
  2.         select * from t_dept where t_dept.deptno=#{emp.deptno}
  3.     </select>

测试代码

  1. @Test
  2.     public void testQueryEmpLazyLoadDept() {
  3.         List<Emp> empList = empService.queryEmpLazyLoadDept();
  4.         System.out.println(empList.size());
  5.         for(int i=0;i<empList.size();i++) {
  6.             Emp emp = empList.get(i);
  7.             System.out.println("员工信息：" + emp.toString());
  8.             System.out.println("员工所有部门信息：" + emp.getDept());
  9.         }
  10.     }

运行结果

  1. JDBC Connection [com.mysql.jdbc.JDBC4Connection@1cd6b1bd] will not be managed by Spring
  2. ==>  Preparing: select * from t_dept where t_dept.deptno=?
  3. ==> Parameters: 10(Integer)
  4. <==    Columns: deptno, dname, loc
  5. <==        Row: 10, ACCOUNTING, NEW YORK
  6. <==      Total: 1
  7. 员工信息：Emp{empno=7934, ename='MILLER', job='CLERK', mgr=7782, hiredate=Sat Jan 23 00:00:00 CST 1982, sal=1300.0, comm=null, deptno=10, skillList=null}
  8. 员工所有部门信息：Dept{deptno=10, dname='ACCOUNTING', loc='NEW YORK'}

从运行结果可以看出，调用Emp对象的getDept()方法是，才发出查询部门信息的sql语句，达到延迟加载的作用。

mybatis缓存

缓存的作用，主要是为了提高查询访问速度，某些数据被频繁查询时，可以缓存到内存中而不是每次都从数据库查询，这样可以减轻数据库压力。

MyBatis的缓存机制，根据缓存的作用域（生命周期）可以划分为2种：一级查询缓存和二级查询缓存。

一级缓存介绍

一级缓存是SqlSession级别的缓存。每个SqlSession中持有了Executor，每个Executor中有一个HashMap类型的Cache（我们称为Local cache）。不同的SqlSession之间的缓存数据区域（HashMap）是互相不影响的。其作用域是SqlSession，当一个SqlSessoin结束后，该SqlSession中的一级查询缓存也就不存在了。

当用户发起查询时，在Local Cache进行查询，如果缓存命中的话，直接返回结果给用户，如果缓存没有命中的话，查询数据库结果写入Local Cache，最后返回结果给用户。

一级缓存失效问题

  1. @Test
  2. public void testQueryById() {
  3.     System.out.println(empService.queryById(7369));
  4.     System.out.println(empService.queryById(7369));
  5. }

运行结果

  1. Creating a new SqlSession
  2. SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@66d25ba9] was not registered for synchronization because synchronization is not active
  3. JDBC Connection [com.mysql.jdbc.JDBC4Connection@31efacad] will not be managed by Spring
  4. ==>  Preparing: SELECT * FROM t_emp WHERE empno=?
  5. ==> Parameters: 7369(Integer)
  6. <==    Columns: empno, ename, job, mgr, hiredate, sal, comm, deptno
  7. <==        Row: 7369, SMITH, CLERK, 7902, 1980-12-17, 800.00, null, 20
  8. <==      Total: 1
  9. Closing non transactional SqlSession
  10.  [org.apache.ibatis.session.defaults.DefaultSqlSession@66d25ba9]
  11. Emp{empno=7369, ename='SMITH', job='CLERK', mgr=7902, hiredate=Wed Dec 17 00:00:00 CST 1980, sal=800.0, comm=null, deptno=20, skillList=null}
  12. Creating a new SqlSession
  13. SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@2df65a56] was not registered for synchronization because synchronization is not active
  14. JDBC Connection [com.mysql.jdbc.JDBC4Connection@31efacad] will not be managed by Spring
  15. ==>  Preparing: SELECT * FROM t_emp WHERE empno=?
  16. ==> Parameters: 7369(Integer)
  17. <==    Columns: empno, ename, job, mgr, hiredate, sal, comm, deptno
  18. <==        Row: 7369, SMITH, CLERK, 7902, 1980-12-17, 800.00, null, 20
  19. <==      Total: 1
  20. Closing non transactional SqlSession
  21.  [org.apache.ibatis.session.defaults.DefaultSqlSession@2df65a56]
  22. Emp{empno=7369, ename='SMITH', job='CLERK', mgr=7902, hiredate=Wed Dec 17 00:00:00 CST 1980, sal=800.0, comm=null, deptno=20, skillList=null}

从上面的结果可以看出，执行2次queryById方法分别创建了2次SqlSession，也就是mybatis的一级缓存没有起作用，这是因为与spring框架整合后的导致的。

mybatis的会话提供了编程式的事务管理，通过SqlSession.commit(), SqlSession.rollback() or SqlSession.close()这些方法进行事务管理。但是当与spring整合后，事务将交由spring管理，这就意味着你不能手动编程式的管理事务了。spring对mybatis的sqlsession的使用是由template控制的，每次数据库操作申请一个sqlsession，使用完后就关闭。所以就产生了上面一级缓存失效的问题。

二级缓存介绍

mybaits的二级缓存是mapper范围级别，多个SqlSession之间可以共享二级缓存。二级缓存开启后，每一个namespace的mapper都有一个二缓存区域。当开启二级缓存后，数据的查询执行的流程就是二级缓存 -> 一级缓存 -> 数据库。

二级缓存验证

开启二级缓存，实体要实现Serializable接口序列化。

  1. mybatis-plus:
  2.   mapper-locations: "classpath:com/itpsc/mapper/**/*.xml"
  3.   type-aliases-package: "com.itpsc.entity"
  4.   global-config:
  5.     db-column-underline: true
  6.   configuration:
  7.     map-underscore-to-camel-case: true
  8.     cache-enabled: true #打开二级缓存
  9.     lazyLoadingEnabled: true #延时加载的开关
  10. log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #打印sql语句,调试用

测试代码

  1. @Test
  2. public void testQueryById() {
  3.     System.out.println(empService.queryById(7369));
  4.     System.out.println(empService.queryById(7369));
  5. }

运行结果

  1. Creating a new SqlSession
  2. SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7db40fd5] was not registered for synchronization because synchronization is not active
  3. Cache Hit Ratio [com.itpsc.mapper.EmpMapper]: 0.0
  4. JDBC Connection [com.mysql.jdbc.JDBC4Connection@670342a2] will not be managed by Spring
  5. ==>  Preparing: SELECT * FROM t_emp WHERE empno=?
  6. ==> Parameters: 7369(Integer)
  7. <==    Columns: empno, ename, job, mgr, hiredate, sal, comm, deptno
  8. <==        Row: 7369, SMITH, CLERK, 7902, 1980-12-17, 800.00, null, 20
  9. <==      Total: 1
  10. Closing non transactional SqlSession
  11.  [org.apache.ibatis.session.defaults.DefaultSqlSession@7db40fd5]
  12. Emp{empno=7369, ename='SMITH', job='CLERK', mgr=7902, hiredate=Wed Dec 17 00:00:00 CST 1980, sal=800.0, comm=null, deptno=20, skillList=null}
  13. Creating a new SqlSession
  14. SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@c412556] was not registered for synchronization because synchronization is not active
  15. Cache Hit Ratio [com.itpsc.mapper.EmpMapper]: 0.5
  16. Closing non transactional SqlSession
  17. [org.apache.ibatis.session.defaults.DefaultSqlSession@c412556]
  18. Emp{empno=7369, ename='SMITH', job='CLERK', mgr=7902, hiredate=Wed Dec 17 00:00:00 CST 1980, sal=800.0, comm=null, deptno=20, skillList=null}

可以看出，创建了两个SqlSession，第二次会话并没有去数据库查询而是从二级缓存中查询。

禁用或者刷新二级缓存

在statement中设置useCache=”false”可以禁用当前select语句的二级缓存，默认情况是true。如下：

  1. <select id="queryById" parameterType="int" resultType="com.itpsc.entity.Emp" useCache="false">
  2.     SELECT * FROM t_emp WHERE empno=#{empno}
  3. </select>

通常情况下insert、update、delete操作后需要刷新缓存，这时可以在对应的statement中设置flushCache="true"，默认情况下为true。

  1. <insert id="add" parameterType="com.itpsc.entity.Emp" flushCache="true">
  2.     insert into t_emp(empno,ename,job,mgr,hiredate,sal,comm,deptno)
  3.     values(#{empno},#{ename},#{job},#{mgr},#{hiredate,jdbcType=DATE},#{sal},#{comm},#{deptno})
  4.   </insert>

mybatis基础系列（四）——关联查询、延迟加载、一级缓存与二级缓存的更多相关文章

  1. MyBatis 系列五 之 延迟加载、一级缓存、二级缓存设置

    MyBatis的延迟加载.一级缓存.二级缓存设置 首先我们必须分清延迟加载的适用对象 延迟加载 MyBatis中的延迟加载,也称为懒加载,是指在进行关联查询时,按照设置延迟加载规则推迟对关联对象的se ...

  2. mybatis基础系列（三）——动态sql

    本文是Mybatis基础系列的第三篇文章,点击下面链接可以查看前面的文章: mybatis基础系列(二)--基础语法.别名.输入映射.输出映射 mybatis基础系列(一)--mybatis入门 动态 ...

  3. mybatis的延迟加载、一级缓存、二级缓存

    mybatis的延迟加载.一级缓存.二级缓存 mybatis是什么? mybatis是一个持久层框架,是apache下的开源项目,前身是itbatis,是一个不完全的ORM框架,mybatis提供输入 ...

  4. MyBatis 延迟加载，一级缓存，二级缓存设置

    什么是延迟加载 resultMap中的association和collection标签具有延迟加载的功能. 延迟加载的意思是说,在关联查询时,利用延迟加载,先加载主信息.使用关联信息时再去加载关联信息 ...

  5. 【Mybatis】MyBatis之表的关联查询（五）

    本章介绍Mybatis之表的关联查询 一对一关联 查询员工信息以及员工的部门信息 1.准备表employee员工表,department部门表 CREATE TABLE `employee` ( `i ...

  6. MyBatis 一级缓存，二级缓存,延迟加载设置

       1  什么是延迟加载  resultMap中的association和collection标签具有延迟加载的功能. 延迟加载的意思是说,在关联查询时,利用延迟加载,先加载主信息.使用关联信息时再 ...

  7. Mybatis延迟加载， 一级缓存、二级缓存

    延迟加载 概念:MyBatis中的延迟加载,也称为懒加载,是指在进行关联查询时,按照设置延迟规则推迟对关联对象的select查询.延迟加载可以有效的减少数据库压力. (注意:MyBatis的延迟加载只 ...

  8. mybatis高级(3)_延迟加载_深度延迟_一级缓存_二级缓存

    设置延迟加载需要在mybatis.xml中设置 注: 侵入式延迟加载为真时是延迟加载 侵入式延迟加载为假时是深度延迟加载 <!-- 延迟加载和深度延迟加载 --> <settings ...

  9. MyBatis从入门到放弃六：延迟加载、一级缓存、二级缓存

    前言 使用ORM框架我们更多的是使用其查询功能,那么查询海量数据则又离不开性能,那么这篇中我们就看下mybatis高级应用之延迟加载.一级缓存.二级缓存.使用时需要注意延迟加载必须使用resultMa ...

随机推荐

  1. c# 生成自定义图片

    using System.Drawing; using System.IO; using System.Drawing.Imaging; using System; namespace treads ...

  2. WebForm 【上传图片--添加水印】

      对图片添加水印,上传 <div> <asp:FileUpload ID="FileUpload1" runat="server" /> ...

  3. Angular Forms - 自定义 ngModel 绑定值的方式

    在 Angular 应用中,我们有两种方式来实现表单绑定--"模板驱动表单"与"响应式表单".这两种方式通常能够很好的处理大部分的情况,但是对于一些特殊的表单控 ...

  4. jdk1.7安装，cmd下 java -version出现错误：“could not open `D:\Java\jre7\lib\amd64\jvm.cfg”

    cmd 下java -version出现错误:“could not open `D:\Java\jre7\lib\amd64\jvm.cfg”,出现这种错误可能是由于先前有安装老版本jdk,之后将新版 ...

  5. 具体CAS操作实现(无锁算法)

    具体CAS操作 上一篇讲述了CAS机制,这篇讲解CAS具体操作. 什么是悲观锁.乐观锁?在java语言里,总有一些名词看语义跟本不明白是啥玩意儿,也就总有部分面试官拿着这样的词来忽悠面试者,以此来找优 ...

  6. Java开发中json使用，各对象与json相互转换

    Json:一种网络通信使用的数据格式,因为便于解析,比较流行,对象可以转为json,同样json也可以转对象. 下面介绍下Json工具的简单使用(fastjson && jackson ...

  7. Javassm连接数据库报错129 ERROR [com.alibaba.druid.pool.DruidDataSource] - {dataSource-1} init error

    Javassm连接数据库报错129 ERROR [com.alibaba.druid.pool.DruidDataSource] - {dataSource-1} init error 发现jdbc这 ...

  8. Vim settings file on Windows

    Question: I can't believe I am typing a question for a simple thing like this but here we are. I can ...

  9. MEF 插件式开发之 WPF 初体验

    MEF 在 WPF 中的简单应用 MEF 的开发模式主要适用于插件化的业务场景中,C/S 和 B/S 中都有相应的使用场景,其中包括但不限于 ASP.NET MVC .ASP WebForms.WPF ...

  10. linux下安装mysql环境

    1.在安装apache的时候已经检查了本地没有安装centos自带的mysql,有的话一定要卸载掉,否则可能占用端口 2.准备mysql安装包(注意编译的时候,mysql5.5版本以上的编译和5.5一 ...