mybatis延迟加载、缓存

目次
一、所需表
二、延迟加载
1.延迟加载概念
2.立刻加载和延迟加载的应用场景
3.多对一延迟加载查询演示
(1)实体类
User
Account
(2)AccountMapper接口
(3)AccountMapper.xml
(4)UserMapper接口
(5)UserMapper.xml
(6)在总配置文件(mybatis-config.xml)中开启延迟加载配置
(7)测试类
(8)运行
(9)如果测试类中的输出语句改为
4.一对多延迟加载
(1)实体类
(2)UserMapper接口
(3)UserMapper.xml文件
(4)AccountMapper接口
(5)AccountMapper.xml文件
(6)在总配置文件中开启延迟加载
(7)测试类
(8)运行
三、mybatis框架的缓存
1.概念
2.一级缓存
(1)验证一级缓存的存在
测试类
运行
(2)一级缓存失效的四种情况
①使用差别的sqlSession对象查询
测试类
运行
②使用相同的sqlSession对象进行查询，但是查询条件差别
测试类
 运行
③使用相同的sqlSession对象进行查询，但是在两次实验中间我们进行了一次增删改操作
UserMapper接口
UserMapper.xml
测试类
运行
④使用相同的sqlSession对象进行查询，但是手动清除了缓存
测试类
运行
3.二级缓存
(1)在总配置文件中开启二级缓存
(2)在映射配置文件中配置
(3)实体类实现序列化接口
(4)二级缓存必须在SqlSession关闭或提交之后
(5)证实二级缓存
测试类
运行：

---

一、所需表

account

user

二、延迟加载

1.延迟加载概念

立刻加载：当前查询用户的时间，默认把该用户所拥有的账户信息查询出来了
延迟加载：当前查询用户的时间，没有把该用户所拥有的账户信息查询出来，而是使用账户数据的时间，再去查询账户的数据

2.立刻加载和延迟加载的应用场景

(1)查询账户的时间，可以直接把用户查询出来(多对一)，这个时间可以选择立刻加载
(2)查询用户的时间，可以先不查账户信息，需要账户信息的时间再去查，这时选择延迟加载
3.多对一延迟加载查询演示

(1)实体类

User

1. package com.qcby.pojo;
3. import java.util.Date;
5. /*
6. * 一
7. * */
8. public class User {
9.     private Integer id;
10.     private String username;
11.     private Date birthday;
12.     private String sex;
13.     private String address;
15.     public User() {
16.     }
18.     public User(Integer id, String username, Date birthday, String sex, String address) {
19.         this.id = id;
20.         this.username = username;
21.         this.birthday = birthday;
22.         this.sex = sex;
23.         this.address = address;
24.     }
26.     public Integer getId() {
27.         return id;
28.     }
30.     public void setId(Integer id) {
31.         this.id = id;
32.     }
34.     public String getUsername() {
35.         return username;
36.     }
38.     public void setUsername(String username) {
39.         this.username = username;
40.     }
42.     public Date getBirthday() {
43.         return birthday;
44.     }
46.     public void setBirthday(Date birthday) {
47.         this.birthday = birthday;
48.     }
50.     public String getSex() {
51.         return sex;
52.     }
54.     public void setSex(String sex) {
55.         this.sex = sex;
56.     }
58.     public String getAddress() {
59.         return address;
60.     }
62.     public void setAddress(String address) {
63.         this.address = address;
64.     }
66.     @Override
67.     public String toString() {
68.         return "User{" +
69.                 "id=" + id +
70.                 ", username='" + username + '\'' +
71.                 ", birthday=" + birthday +
72.                 ", sex='" + sex + '\'' +
73.                 ", address='" + address + '\'' +
74.                 '}';
75.     }
76. }

复制代码

Account

1. package com.qcby.pojo;
3. /*
4. * 多
5. * */
6. public class Account {
7.     private Integer id;
8.     private String money;
9.     private Integer uid;
11.     //多对一
12.     private User user;
14.     public Account() {
15.     }
17.     public Account(Integer id, String money, Integer uid, User user) {
18.         this.id = id;
19.         this.money = money;
20.         this.uid = uid;
21.         this.user = user;
22.     }
24.     public Integer getUid() {
25.         return uid;
26.     }
28.     public void setUid(Integer uid) {
29.         this.uid = uid;
30.     }
32.     public User getUser() {
33.         return user;
34.     }
36.     public void setUser(User user) {
37.         this.user = user;
38.     }
40.     public Integer getId() {
41.         return id;
42.     }
44.     public void setId(Integer id) {
45.         this.id = id;
46.     }
48.     public String getMoney() {
49.         return money;
50.     }
52.     public void setMoney(String money) {
53.         this.money = money;
54.     }
56.     @Override
57.     public String toString() {
58.         return "Account{" +
59.                 "id=" + id +
60.                 ", money='" + money + '\'' +
61.                 ", uid=" + uid +
62.                 ", user=" + user +
63.                 '}';
64.     }
65. }

复制代码

(2)AccountMapper接口

1. package com.qcby.mapper;
3. import com.qcby.pojo.Account;
5. import java.util.List;
7. public interface AccountMapper {
8.    
9.     /*
10.     * 多对一:
11.     * 查询所有
12.     * */
13.     public List<Account> findAll();
14. }

复制代码

(3)AccountMapper.xml

在 <association> 标签中，需要指定一个 column 属性，这个属性的值应该是 account 表中用来关联 user 表的外键列名： column="uid"

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.qcby.mapper.AccountMapper"> <!--对谁进行操作就写谁-->
7.     <!--多对一:-->
8.     <!--查询所有：public List<Account> findAll();-->
9.     <select id="findAll" resultMap="accountMap">
10.         select * from account
11.     </select>
12.     <resultMap id="accountMap" type="account">
13.         <id property="id" column="id"/>
14.         <result property="money" column="money"/>
15.         <result property="uid" column="uid"/>
16.         <!--配置延迟加载-->
17.         <association property="user" column="uid" javaType="user" select="com.qcby.mapper.UserMapper.findById">
18.             <id column="id" property="uid"/>
19.             <result column="username" property="username"/>
20.             <result column="birthday" property="birthday"/>
21.             <result column="sex" property="sex"/>
22.             <result column="address" property="address"/>
23.         </association>
24.     </resultMap>
25. </mapper>

复制代码

(4)UserMapper接口

1. package com.qcby.mapper;
3. import com.qcby.pojo.User;
5. public interface UserMapper {
6.    
7.     /*
8.     * 多对一:
9.     * 根据id查询
10.     * */
11.     public User findById(Integer id);
12. }

复制代码

(5)UserMapper.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.qcby.mapper.UserMapper"> <!--对谁进行操作就写谁-->
7.     <!--多对一-->
8.     <!--根据id查询:public User findById(Integer id);-->
9.     <select id="findById" parameterType="int" resultType="user">
10.         select * from user where id=#{id}
11.     </select>
12. </mapper>

复制代码

(6)在总配置文件(mybatis-config.xml)中开启延迟加载配置

mybatis-config.xml

1. <settings>
2.     <!--开启延迟加载-->
3.     <setting name="lazyLoadingEnabled" value="true"/>
4.     <!--将积极加载改为消极加载及按需加载-->
5.     <setting name="aggressiveLazyLoading" value="false"/>
6. </settings>

复制代码

(7)测试类

1. package com.qcby.test;
3. import com.qcby.mapper.AccountMapper;
4. import com.qcby.mapper.UserMapper;
5. import com.qcby.pojo.Account;
6. import com.qcby.pojo.User;
7. import org.apache.ibatis.io.Resources;
8. import org.apache.ibatis.session.SqlSession;
9. import org.apache.ibatis.session.SqlSessionFactory;
10. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
11. import org.junit.After;
12. import org.junit.Before;
13. import org.junit.Test;
15. import java.io.IOException;
16. import java.io.InputStream;
17. import java.util.ArrayList;
18. import java.util.List;
20. public class demo {
21.     private InputStream inputStream;
22.     private SqlSession sqlSession;
23.     private AccountMapper accountMapper;
24.     private UserMapper userMapper;
25.     @Before
26.     public void init() throws IOException {
27.         //加载配置文件
28.         inputStream= Resources.getResourceAsStream("mybatis-config.xml");
29.         //创建工厂对象
30.         SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
31.         //创建session对象
32.         sqlSession=sqlSessionFactory.openSession();
33.         //获取到代理对象
34.         userMapper=sqlSession.getMapper(UserMapper.class);
35.         accountMapper=sqlSession.getMapper(AccountMapper.class);
36.     }
38.     /*
39.     * 多对一：
40.     * account查询所有
41.     * */
42.     @Test
43.     public void findAllTest(){
44.         List<Account> accounts=accountMapper.findAll();
45.         for (Account account:accounts){
46.             //System.out.println("开始...");
47.             System.out.println(account.getMoney());
48.             //System.out.println("结束...");
49.             System.out.println("--------------------");
50.         }
51.     }
56.     @After
57.     public void destory() throws IOException {
58.         inputStream.close();
59.         sqlSession.close();
60.     }
61. }

复制代码

(8)运行

可以看到此时是没有加载出来用户的信息的
(9)如果测试类中的输出语句改为

System.out.println(account.getUser().getUsername())；
再运行：

可以看到此时实验了user根据id查询的sql语句
4.一对多延迟加载

(1)实体类

User类

1. package com.qcby.pojo;
3. import java.util.Date;
4. import java.util.List;
6. /*
7. * 一
8. * */
9. public class User {
10.     private Integer id;
11.     private String username;
12.     private Date birthday;
13.     private String sex;
14.     private String address;
15.    
16.     /*一对多*/
17.     private List<Account> accounts;
19.     public List<Account> getAccounts() {
20.         return accounts;
21.     }
23.     public void setAccounts(List<Account> accounts) {
24.         this.accounts = accounts;
25.     }
27.     public Integer getId() {
28.         return id;
29.     }
31.     public void setId(Integer id) {
32.         this.id = id;
33.     }
35.     public String getUsername() {
36.         return username;
37.     }
39.     public void setUsername(String username) {
40.         this.username = username;
41.     }
43.     public Date getBirthday() {
44.         return birthday;
45.     }
47.     public void setBirthday(Date birthday) {
48.         this.birthday = birthday;
49.     }
51.     public String getSex() {
52.         return sex;
53.     }
55.     public void setSex(String sex) {
56.         this.sex = sex;
57.     }
59.     public String getAddress() {
60.         return address;
61.     }
63.     public void setAddress(String address) {
64.         this.address = address;
65.     }
67.     @Override
68.     public String toString() {
69.         return "User{" +
70.                 "id=" + id +
71.                 ", username='" + username + '\'' +
72.                 ", birthday=" + birthday +
73.                 ", sex='" + sex + '\'' +
74.                 ", address='" + address + '\'' +
75.                 ", accounts=" + accounts +
76.                 '}';
77.     }
78. }

复制代码

(2)UserMapper接口

1. /*
2. * 一对多:
3. * 查询所有
4. * */
5. public List<User> findUserAll();

复制代码

(3)UserMapper.xml文件

1. <!--一对多-->
2. <!--查询所有:public List<User> findUserAll();-->
3. <select id="findUserAll" resultMap="userMap">
4.     select * from user
5. </select>
6. <resultMap id="userMap" type="user">
7.     <id property="id" column="id"/>
8.     <result property="username" column="username"/>
9.     <result property="birthday" column="birthday"/>
10.     <result property="sex" column="sex"/>
11.     <result property="address" column="address"/>
12.     <collection property="accounts" column="id" ofType="account" select="com.qcby.mapper.AccountMapper.findAccountById">
13.         <id column="id" property="id"/>
14.         <result column="money" property="money"/>
15.         <result column="uid" property="uid"/>
16.     </collection>
17. </resultMap>

复制代码

(4)AccountMapper接口

1. /*
2. * 一对多:
3. * 根据id查询
4. * */
5. public Account findAccountById(Integer id);

复制代码

(5)AccountMapper.xml文件

1. <!--一对多-->
2. <!--根据id查询:public Account findAccountById(Integer id);-->
3. <select id="findAccountById" parameterType="int" resultType="account">
4.     select * from account where id=#{id}
5. </select>

复制代码

(6)在总配置文件中开启延迟加载

1. <settings>
2.     <!--开启延迟加载-->
3.     <setting name="lazyLoadingEnabled" value="true"/>
4.     <!--将积极加载改为消极加载及按需加载-->
5.     <setting name="aggressiveLazyLoading" value="false"/>
6. </settings>

复制代码

(7)测试类

1. /*
2. * 一对多:
3. * user查询所有
4. * */
5. @Test
6. public void findUserAllTest(){
7.     List<User> users=userMapper.findUserAll();
8.     for (User user:users){
9.         System.out.println(user.getUsername()+"  "+user.getAddress());
10.         System.out.println("--------------------");
11.     }
12. }

复制代码

(8)运行

三、mybatis框架的缓存

1.概念

常常需要查询，不需要修改的数据，不特殊紧张的数据都可以存储到缓存中
2.一级缓存

①mybatis的一级缓存是SqlSession的缓存
②查询的时间，先从SqlSession的缓存中查找，如果有，直接返回，如果没有，再去查询数据库
(1)验证一级缓存的存在

查询两次，检察结果
查询的语句在多对一查询的时间写过了
测试类

1. /*
2. * 验证一级缓存的存在
3. * */
4. @Test
5. public void findUserByIdTest(){
6.     User user1=userMapper.findById(1);
7.     System.out.println(user1);
8.     User user2=userMapper.findById(1);
9.     System.out.println(user2);
10. }

复制代码

运行

(2)一级缓存失效的四种情况

①使用差别的sqlSession对象查询

测试类

1. package com.qcby.test;
3. import com.qcby.mapper.AccountMapper;
4. import com.qcby.mapper.UserMapper;
5. import com.qcby.pojo.Account;
6. import com.qcby.pojo.User;
7. import org.apache.ibatis.io.Resources;
8. import org.apache.ibatis.session.SqlSession;
9. import org.apache.ibatis.session.SqlSessionFactory;
10. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
11. import org.junit.After;
12. import org.junit.Before;
13. import org.junit.Test;
15. import java.io.IOException;
16. import java.io.InputStream;
17. import java.util.ArrayList;
18. import java.util.List;
20. public class demo {
21.     private InputStream inputStream;
22.     private SqlSession sqlSession;
23.     private SqlSession sqlSession2;
24.     private AccountMapper accountMapper;
25.     private UserMapper userMapper;
26.     private UserMapper userMapper2;
27.     @Before
28.     public void init() throws IOException {
29.         //加载配置文件
30.         inputStream= Resources.getResourceAsStream("mybatis-config.xml");
31.         //创建工厂对象
32.         SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
33.         //创建session对象
34.         sqlSession=sqlSessionFactory.openSession();
35.         sqlSession2=sqlSessionFactory.openSession();
36.         //获取到代理对象
37.         userMapper=sqlSession.getMapper(UserMapper.class);
38.         userMapper2=sqlSession2.getMapper(UserMapper.class);
39.         accountMapper=sqlSession.getMapper(AccountMapper.class);
40.     }
44.     /*
45.      * 一级缓存失效的四种情况：
46.      * 1.使用不同的sqlSession对象进行查询
47.      * */
48.     @Test
49.     public void findUserByIdTest1(){
50.         User user1=userMapper.findById(1);
51.         System.out.println(user1);
52.         User user2=userMapper2.findById(1);
53.         System.out.println(user2);
54.     }
56.     @After
57.     public void destory() throws IOException {
58.         inputStream.close();
59.         sqlSession.close();
60.     }
61. }

复制代码

运行

②使用相同的sqlSession对象进行查询，但是查询条件差别

测试类

1. /*
2. * 一级缓存失效的四种情况：
3. * 2.使用相同的sqlSession对象进行查询，但是查询条件不同
4. * */
5. @Test
6. public void findUserByIdTest2(){
7.     User user1=userMapper.findById(1);
8.     System.out.println(user1);
9.     User user2=userMapper.findById(2);
10.     System.out.println(user2);
11. }

复制代码

 运行

③使用相同的sqlSession对象进行查询，但是在两次实验中间我们进行了一次增删改操作

UserMapper接口

1. /*
2. * 根据id删除
3. * */
4. public int deleteById(Integer id);

复制代码

UserMapper.xml

1. <!--根据id删除:public int deleteById(Integer id);-->
2. <delete id="deleteById" parameterType="int">
3.     delete from user where id=#{id}
4. </delete>

复制代码

测试类

1. /*
2. * 一级缓存失效的四种情况：
3. * 3.使用相同的sqlSession对象进行查询，但是在两次执行中间我们进行了一次增删改操作
4. * */
5. @Test
6. public void findUserByIdTest3(){
7.     User user1= userMapper.findById(1);
8.     System.out.println(user1);
9.     userMapper.deleteById(3);
10.     sqlSession.commit();
11.     User user2=userMapper.findById(1);
12.     System.out.println(user2);
13. }

复制代码

运行

④使用相同的sqlSession对象进行查询，但是手动清除了缓存

测试类

1. /*
2. * 一级缓存失效的四种情况：
3. *  4.使用相同的sqlSession对象进行查询，但是手动清除了缓存
4. * */
5. @Test
6. public void findUserByIdTest4(){
7.     User user1=userMapper.findById(1);
8.     System.out.println(user1);
9.     sqlSession.clearCache();//手动清理缓存
10.     User user2=userMapper.findById(1);
11.     System.out.println(user2);
12. }

复制代码

运行

3.二级缓存

二级缓存是SqlSessionFactory级别的
(1)在总配置文件中开启二级缓存

1. <!--开启二级缓存-->
2. <settings>
3.     <setting name="cacheEnabled" value="true"/>
4.     <setting name="logImpl" value="STDOUT_LOGGING"/>
5. </settings>

复制代码

(2)在映射配置文件中配置<cache>

(3)实体类实现序列化接口

(4)二级缓存必须在SqlSession关闭或提交之后

(5)证实二级缓存

二级缓存的适用对象地点差别，但是也从缓存加载，二级缓存存储的是零散数据，是组装出来的对象
测试类

1. package com.qcby.test;
3. import com.qcby.mapper.UserMapper;
4. import com.qcby.pojo.User;
5. import org.apache.ibatis.io.Resources;
6. import org.apache.ibatis.session.SqlSession;
7. import org.apache.ibatis.session.SqlSessionFactory;
8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
9. import org.junit.Test;
11. import java.io.IOException;
12. import java.io.InputStream;
14. public class demo2 {
16.     @Test
17.     public void test() throws IOException {
18.         //加载配置文件
19.         InputStream inputStream= Resources.getResourceAsStream("mybatis-config.xml");
20.         //创建工厂对象
21.         SqlSessionFactory sqlSessionFactory=new     SqlSessionFactoryBuilder().build(inputStream);
23.         //创建session对象
24.         SqlSession sqlSession1=sqlSessionFactory.openSession();
25.         //获取到代理对象
26.         UserMapper userMapper1=sqlSession1.getMapper(UserMapper.class);
27.         //调用方法
28.         User user1=userMapper1.findById(1);
29.         System.out.println(user1);
30.         System.out.println("-----------");
31.         //手动清理缓存
32.         sqlSession1.clearCache();
33.         sqlSession1.commit();
34.         sqlSession1.close();
37.         SqlSession sqlSession2=sqlSessionFactory.openSession();
38.         UserMapper userMapper2=sqlSession2.getMapper(UserMapper.class);
39.         User user2=userMapper2.findById(1);
40.         System.out.println(user2);
41.         sqlSession2.close();
42.         inputStream.close();
44.     }
45. }

复制代码

运行：

可以看出，sql语句只实验了一次，说明它是查的缓存，但是地点不一样，因为他从缓存里组装出来的






 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。