延迟加载
举个例子来说吧：如果查询用户并且关联查询用户的账户信息。如果先查询用户信息就可以满足要求，当我们需要查询账户信息的时候再去查询账户信息。把用用户信息去查询账户信息的这一过程进行延迟处理，就被称为延迟加载。 延迟加载有什么好处呢？那我们都知道，单表查询的速度肯定是要比多表要快的，那么当我们只需要查询单表，但又有时候要联合多表查询，那么开启延迟加载就是最好的选择，既可以提升查询速度，当要使用到多表的时候就可以级联。在这我们用一个案例来讲解一下。
第一步：User表以及Account表
建表信息我就不给了，因为在上一个多表查询章节中我已经将建表数据贴上了。
第二步：在IAccountDao接口中添加接口方法
//根据用户Id查询账户信息
List<Account> findAccountByUid(Integer uid);
第三步：主配置信息中添加
<settings>
<!--打开mybatis支持延迟加载-->
<setting name="lazyLoadingEnabled" value="true"></setting>
<setting name="aggressiveLazyLoading" value="false"></setting>
</settings>
第四步：IUserDao接口
//用户的持久层接口
public interface IUserDao {
//查询所有用户,同时获取到用户下所有账户的信息
List<User> findAll();
}
第五步：IUserDao映射器
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.IUserDao">
<!--定义user一个resultMap-->
<resultMap id="UserAccountMap" type="user">
<id property="id" column="id"></id>
<result property="username" column="username"></result>
<result property="address" column="address"></result>
<result property="sex" column="sex"></result>
<result property="birthday" column="birthday"></result>
<!--配置user对象中accounts集合的映射-->
<!--ofType里要用全限定类名，因为外面SqlMapConfig里配置的typeAliases别名，就可以直接用account，
不然要用com.itheima.demain.account-->
<collection property="accounts" ofType="account" select="com.itheima.dao.IAccountDao.findAccountByUid" column="id"></collection>
</resultMap>
<!--//查询所有-->
<select id="findAll" resultMap="UserAccountMap">
select * from user
</select>
</mapper>
第六步：测试方法
@Test
public void testFindAll(){
List<User> users = userDao.findAll();
for(User user : users){
System.out.println("每个用户的信息：" + user);
System.out.println(user.getAccounts());
}
}
我们来对比一下开启延迟加载和不开启延迟加载的查询区别
开启延迟加载：
关闭延迟加载：
可以看出来两者有很大的区别了，首先开启延迟加载，是分别去运行了select * from user，如果需要账户信息，我再去运行select * from account a where uid = ?，这样就可以体现出延迟加载的不同之处；而在不开启延迟加载的时候，则是直接就全部执行一遍之后，再去输出所有的信息。这样是无论怎样都会全部运行，而不是由你去选择。那开启延迟加载主要就是以在主配置文件中的元素标签：
<!--配置参数-->
<settings>
<!--打开mybatis支持延迟加载-->
<setting name="lazyLoadingEnabled" value="true"></setting>
<setting name="aggressiveLazyLoading" value="false"></setting>
</settings>
lazyLoadingEnabled：为打开延迟加载开关，默认值为false，即默认值为关闭延迟加载
aggressiveLazyLoading：为上面的设置的反义词，他为实时加载开关，默认值为true，即默认值为打开实时加载
缓存
Mybatis提供了一级缓存和二级缓存的支持：
1.一级缓存: 基于PerpetualCache 的 HashMap本地缓存，其存储作用域为 Session，当 Session flush 或 close 之后，该Session中的所有 Cache 就将清空。
2. 二级缓存：与一级缓存其机制相同，默认也是采用 PerpetualCache，HashMap存储，不同在于其存储作用域为 Mapper(Namespace)，并且可自定义存储源，如 Ehcache。
一级缓存示例：
首先在前面的示例代码中的主配置文件中加入：
<settings>
<setting name="cacheEnabled" value="true"/>
</settings>
此设置是打开缓存开关。
测试方法更改为：
package com.test;
import com.dao.IUserDao;
import com.demain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.InputStream;
//测试Mybatis的CRUD操作
public class SecondLevelCacheTest {
private InputStream is;
private SqlSession session;
private IUserDao userDao;
private SqlSessionFactory factory;
//用于在测试方法执行之前执行
@Before
//通用工具方法
public void init()throws Exception{
//1.获取配置文件流
is = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.生成SqlSessionFactory
SqlSessionFactory factory= new SqlSessionFactoryBuilder().build(is);
//3.用factory生成SqlSession对象
session = factory.openSession();
//4.生成代理对象
userDao = session.getMapper(IUserDao.class);
}
//用于测试方法之后运行
@After
public void destroy()throws Exception{
// session.close();
is.close();
}
//测试一级缓存
@Test
public void testFirstLevelCache(){
//一级缓存
//第一个User对象
User user1 = new User();
user1.setId(45);
User user3 = userDao.findById(45);
System.out.println(user3);
//第二个User对象
User user2 = new User();
user2.setId(45);
User user4 = userDao.findById(45);
System.out.println(user4);
}
测试结果：
可以看到，只执行了一次SQL语句，但是测试方法中生成了两个User对象，按道理应该是要查询两次，只查询一次是因为SqlSesson中存在一级缓存的支持，因为Mybatis识别到查询的两个对象都是一样的，那么查询一次后，将查询的结果存在了SqlSession的一级缓存中，然后第二次的时候直接将其从缓存中拿出来，所以获取两个对象的地址是一样的。
破坏一级缓存缓存
在测试方法的两个user对象中间添加代码：
//破坏一级缓存
user1.setUsername("update mybatis= =");
user1.setAddress("C");
userDao.updateUser(user1);
执行以后：
发现它并没有一级缓存的存在，那是因为Mybatis识别到两个信息不一样，所以缓存需要更新，那么就会重新执行SQL语句，所以输出的User对象的存放的地址也是不同的。
二级缓存示例：
将刚刚的测试方法改为：
package com.test;
import com.dao.IUserDao;
import com.demain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.InputStream;
//测试Mybatis的CRUD操作
public class SecondLevelCacheTest {
private InputStream is;
// private SqlSession session;
// private IUserDao userDao;
private SqlSessionFactory factory;
//用于在测试方法执行之前执行
@Before
//通用工具方法
public void init()throws Exception{
//1.获取配置文件流
is = Resources.getResourceAsStream("SqlMapConfig.xml");
// 2.生成SqlSessionFactory
// SqlSessionFactory factory= new SqlSessionFactoryBuilder().build(is);
// 3.用factory生成SqlSession对象
// session = factory.openSession();
// 4.生成代理对象
// userDao = session.getMapper(IUserDao.class);
}
//用于测试方法之后运行
@After
public void destroy()throws Exception{
// session.close();
is.close();
}
//测试一级缓存
// @Test
// public void testFirstLevelCache(){
// 一级缓存
// //第一个User对象
// User user1 = new User();
// user1.setId(45);
// User user3 = userDao.findById(45);
// System.out.println(user3);
//
// //破坏一级缓存
// user1.setUsername("update mybatis= =");
// user1.setAddress("C");
// userDao.updateUser(user1);
//
// //第二个User对象
// User user2 = new User();
// user2.setId(45);
// User user4 = userDao.findById(45);
// System.out.println(user4);
// }
@Test
public void testSecondLevelCache(){
//二级缓存测试
factory = new SqlSessionFactoryBuilder().build(is);
SqlSession session1 = factory.openSession();
IUserDao userDao1 = session1.getMapper(IUserDao.class);
User user1 = new User();
user1.setId(45);
user1.setUsername("heiman");
user1.setAddress("T");
userDao1.updateUser(user1);
userDao1.findById(45);
session1.close();
SqlSession session2 = factory.openSession();
IUserDao userDao2 = session2.getMapper(IUserDao.class);
User user2 = new User();
user2.setId(45);
user2.setUsername("heigay");
user2.setAddress("JJ");
userDao2.updateUser(user2);
userDao2.findById(45);
}
}
在IUserDao.xml中的mapper下添加代码：
<!--开启user支持二级缓存-->
<cache></cache>
执行测试方法：
而不开启二级缓存是什么样子的呢？
注意：虽然这两个结果很相似，但是要仔细去对比，发现打开二级缓存，日志出现了一句话：
Cache Hit Ratio [com.itheima.dao.IUserDao]: 0.0
这就是没开和有开的区别。
注意：
1. 映射语句文件中的所有select语句将会被缓存。
2. 映射语句文件中的所有insert，update和delete语句会刷新缓存。
3. 缓存会使用Least Recently Used（LRU，最近最少使用的）算法来收回。
4. 缓存会根据指定的时间间隔来刷新。
5. 缓存会存储1024个对象
1260
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
