SSM

MyBatis: LAZY LOAD

张天宇 on 2020-04-06

MyBatis中的延迟加载。

延迟加载和立即加载

延迟加载：真正使用数据时候才发起查询，不用的时候不查询，按需加载（懒加载）。

立即加载：不管用不用，只要一调用方法，马上发起查询。

在对应的四种表关系中，一对多、多对多使用 延迟加载。多对一、一对一采用立即加载。

即看屁股，屁股大的延迟加载。

实现

一对一实现延迟加载

需求：当查询账户信息时使用延迟加载。也就是说，如果不需要使用用户信息的话，那么只查询账户信息；只有当需要使用用户信息时，才去关联查询。

  1. 在MyBatis的配置文件中开启延迟加载

    1
    2
    3
    4
    5
     <!-- 开启延迟加载 -->
    <settings>
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

  2. 修改上一篇笔记编写好的账户映射文件 AccountMapper.xml

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <mapper namespace="top.tyzhang.dao.IAccountDao">
        <resultMap id="accountUserMap" type="top.tyzhang.domain.Account">
            <id property="id" column="id"></id>
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
            <association property="user" column="uid" javaType="top.tyzhang.domain.User" select="top.tyzhang.dao.IUserDao.findById"></association>
        </resultMap>
        <select id="findAll" resultMap="accountUserMap">
            SELECT * from account
        </select>
    </mapper>
  • 标签中的 select 属性表示我们要调用的映射语句的 ID，它会从 column 属性指定的列中检索数据，作为参数传递给目标 select 语句。
  • column 属性指定传递给我们要调用的映射语句的参数。

一对多实现延迟加载

  1. IUserDao映射文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    <mapper namespace="top.tyzhang.dao.IUserDao">
        <resultMap id="userAccountMap" type="top.tyzhang.domain.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>
            <collection property="accounts" ofType="top.tyzhang.domain.Account" select="top.tyzhang.dao.IAccountDao.findAccountByUid" column="uid"></collection>
        </resultMap>
        <select id="findAll" resultMap="userAccountMap">
            select * from userm
        </select>
    </mapper>

  2. 在账户实体类添加对应方法

    1
    2
    3
    4
    public interface IAccountDao {
        List<Account> findAll();
        List<Account> findAccountByUid(Integer uid);
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <mapper namespace="top.tyzhang.dao.IAccountDao">
        <resultMap id="accountUserMap" type="top.tyzhang.domain.Account">
            <id property="id" column="id"></id>
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
            <association property="user" column="uid" javaType="top.tyzhang.domain.User" select="top.tyzhang.dao.IUserDao.findById"></association>
        </resultMap>
        <select id="findAccountByUid" resultType="top.tyzhang.domain.Account">
            SELECT * from account where uid = #{uid}
        </select>
    </mapper>

  3. 测试类

    1
    2
    3
    4
    5
    6
    7
    public void findAll() {
        List<Account> accounts = accountDao.findAll();
        for (Account account : accounts) {
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }

    当只执行findAll时候，日志中只调用了SELECT * from account ，如果打印语句执行，在打印循环体中还会逐个执行select * from userm where id = ? 。

缓存

WHAT：存在于内存的临时数据。

WHY：为了减少和数据库交互的次数，提高执行效率。

HOW：适用：经常查询并且不经常改变的数据。数据的正确与否对最终结果影响不大的。不适用：经常改变的数据。数据的正确与否对最终结果影响很大的。例如：商品的库存、银行的汇率、股市的牌价等。

一级缓存

指的是MyBatis中SqlSession对象的缓存，当我们执行查询后，查询的结果会同时存入SqlSession为我们提供的一块区域中。该区域的结构是一个Map，当我们再次查询同样的数据，MyBatis会先去SqlSession中查询是否有，有的话直接拿过来用。当SqlSession对象消失时，MyBatis的一级缓存也就消失了。

1
2
3
4
User user1 = userDao.findById(41);
User user2 = userDao.findById(41);
System.out.println(user1 == user2);
//输出 true
1
2
3
4
5
6
7
8
9
User user1 = userDao.findById(41);
//1
sqlSession.close();
sqlSession = factory.openSession();
//2 sqlSession.clearCache(); 也可以清空缓存
userDao = sqlSession.getMapper(IUserDao.class);
User user2 = userDao.findById(41);
System.out.println(user1 == user2);
//输出 false

当调用SqlSession的修改、添加、删除、commit()、close()等方法时，就会清空一级缓存。例如以上例子如果在user2前update user1，输出false。

二级缓存

指的是MyBatis中SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享缓存。

使用步骤

  1. 让MyBatis框架支持二级缓存，在SqlMapConfig.xml中配置。

    1
    2
    3
    4
    <settings>
        <!-- 开启缓存, 可以忽略，默认为true -->
        <setting name="cacheEnabled" value="true"/>
    </settings>

  2. 让当前的映射文件支持二级缓存，在IUserDao.xml中配置。

    1
    <cache/>

  3. 让当前的操作支持二级缓存，在select标签中配置。

    1
    2
    3
    <select id="findAll" resultMap="userAccountsMap" useCache="true">
        SELECT * FROM user
    </select>
    • 当我们使用二级缓存的时候，所缓存的类一定要实现 java.io.Serializable 接口，这样才可以使用序列化的方式来保存对象。
    • 由于是序列化保存对象，所以二级缓存中存放的是数据，而不是整个对象。
1
2
3
4
5
6
7
8
9
10
11
12
SqlSession sqlSession1 = factory.openSession();
IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);
User user1 = dao1.findById(41);
sqlSession.close();

SqlSession sqlSession2 = factory.openSession();
IUserDao dao2 = sqlSession2.getMapper(IUserDao.class);
User user2 = dao2.findById(41);
sqlSession.close();

System.out.println(user1 == user2);
//输出：false，但通过日志发现，只执行了一次sql语句。不开启二级缓存，执行两次。

基于注解开发

常用注解

注解 作用
@Intsert 实现新增
@Update 实现更新
@Delete 实现删除
@Select 实现查询
@Results 实现结果集封装
@ResultMap 实现引用 @Results 定义的封装
@One 实现一对一结果集封装
@Many 实现一对多结果集封装
@SelectProvider 实现动态 SQL 映射
@CacheNamespace 实现注解二级缓存的使用

环境搭建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="jdbcConfig.properties"></properties>
    <!-- 配置别名 -->
    <typeAliases>
        <package name="top.tyzhang.domain"></package>
    </typeAliases>
    <!-- 配置环境 -->
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 指定带有注解的Dao接口所在位置 -->
    <mappers>
        <package name="top.tyzhang.dao"></package>
    </mappers>
</configuration>

CRUD

接口实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public interface IUserDao {
    @Select("select * from userm")
    List<User> findAll();

    @Insert("insert into userm(username, address, sex, birthday) values (#{username}, #{address}, #{sex}, #{birthday})")
    void saveUser(User user);

    @Update("update userm set username=#{username}, sex=#{sex}, birthday=#{birthday}, address=#{address} where id = #{id}")
    void updateUser(User user);

    @Delete("delete from userm where id =#{id}")
    void deleteUser(Integer id);

    @Select("select * from userm where id =#{id}")
    User findById(Integer id);

    @Select("select * from userm where username like #{username}")
    List<User> findUserByName(String username);

    @Select("select * from userm where username like '%${value}%'")
    List<User> findUserByName1(String username);

    @Select("select count(*) from userm")
    int findTotal();
}
测试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
public class annocrud {
    private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IUserDao userDao;

    @Before
    public void init() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        factory = new SqlSessionFactoryBuilder().build(in);
        session = factory.openSession();
        userDao = session.getMapper(IUserDao.class);
    }
    @After
    public void destroy() throws IOException {
        session.commit();
        session.close();
        in.close();
    }
    @Test
    public void testSave(){
        User user = new User();
        user.setUsername("张天宇");
        user.setAddress("山东省临沂市");
        userDao.saveUser(user);
    }

    @Test
    public void testUpdate(){
        User user = new User();
        user.setId(49);
        user.setUsername("张天宇");
        user.setAddress("浙江省杭州市");
        user.setSex("男");
        userDao.updateUser(user);
    }

    @Test
    public void testDelete(){
        userDao.deleteUser(49);
    }

    @Test
    public void testFindOne(){
        System.out.println(userDao.findById(48));
    }

    @Test
    public void testFindByName(){
        List<User> users = userDao.findUserByName("%王%");
        for (User user:users)
            System.out.println(user);
    }

    @Test
    public void testFindByName1(){
        List<User> users = userDao.findUserByName1("王");
        for (User user:users)
            System.out.println(user);
    }

    @Test
    public void testFindTotal(){
        System.out.println(userDao.findTotal());
    }
}
注意

当实体类的属性与数据库表列名不一致，应该使用@Results、@Result、@ResultMap 等注解。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public interface IUserDao {
    @Select("SELECT * FROM user")
    @Results(id = "UserMap",value = {
            @Result(id = true, property = "userId",column = "id"),
            @Result(property = "userName",column = "username"),
            @Result(property = "userBirthday",column = "birthday"),
            @Result(property = "userSex",column = "sex"),
            @Result(property = "userAddress",column = "address"),
    })
    List<User> listAllUsers();
    
    @Insert("INSERT INTO user(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})")
    @ResultMap("UserMap")
    int saveUser(User user);
}
  • @Results 注解用于定义映射结果集，相当于标签 。
    其中，id 属性为唯一标识。value 属性用于接收 @Result[] 注解类型的数组。
  • @Result 注解用于定义映射关系，相当于标签 和
    其中，id 属性指定主键。property 属性指定实体类的属性名，column 属性指定数据库表中对应的列。
  • @ResultMap 注解用于引用 @Results 定义的映射结果集，避免了重复定义映射结果集。

一对一立即加载

1
2
3
4
5
6
7
8
public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;
    //多对一，mybatis称之为一对一，一个账户只能属于一个用户
    private User user;
    //...
}
1
2
3
4
5
6
7
8
9
10
public interface IAccountDao {
    @Select("select * from account")
    @Results(id="accountMap", value={
            @Result(id=true, column = "id", property = "id"),
            @Result(column = "uid", property = "uid"),
            @Result(column = "money", property = "money"),
            @Result(property = "user", column = "uid", one=@One(select="top.tyzhang.dao.IUserDao.findById", fetchType= FetchType.EAGER))
    })
    List<Account> findAll();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class accounttest {
    private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IAccountDao accountDao;

    @Before
    public void init() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        factory = new SqlSessionFactoryBuilder().build(in);
        session = factory.openSession();
        accountDao = session.getMapper(IAccountDao.class);
    }
    @After
    public void destroy() throws IOException {
        session.commit();
        session.close();
        in.close();
    }
    @Test
    public void testFindAll(){
        List<Account> accounts = accountDao.findAll();
        for (Account account:accounts) {
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }
}
  • @One 注解相当于标签 ，是多表查询的关键，在注解中用来指定子查询返回单一对象。其中，select 属性指定用于查询的接口方法，fetchType 属性用于指定立即加载或延迟加载，分别对应 FetchType.EAGER 和 FetchType.LAZY。
  • 在包含 @one 注解的 @Result 中，column 属性用于指定将要作为参数进行查询的数据库表列。

一对多延迟加载

1
2
3
4
5
6
7
8
9
10
public class User implements Serializable {
    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;
    //一对多关系映射，一个用户对应多个账户
    private List<Account> accounts;
    //...
}
1
2
3
4
5
6
7
8
public interface IUserDao {
    @Select("select * from userm")
    @Results(value = {@Result(id=true, column = "id", property = "id"),
            @Result(property = "accounts", column = "id",
                    many = @Many(select = "top.tyzhang.dao.IAccountDao.findAccountByUid", fetchType = FetchType.LAZY))}
                    )
    List<User> findAll();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public interface IAccountDao {

    @Select("select * from account")
    @Results(id="accountMap", value={
            @Result(id=true, column = "id", property = "id"),
            @Result(column = "uid", property = "uid"),
            @Result(column = "money", property = "money"),
            @Result(property = "user", column = "uid", one=@One(select="top.tyzhang.dao.IUserDao.findById", fetchType= FetchType.EAGER))
    })
    List<Account> findAll();
    @Select("select * from account where uid = #{uid}")
    List<Account> findAccountByUid(Integer uid);
}

开启二级缓存

1
2
3
4
<settings>
    <!-- 开启缓存 -->
    <setting name="cacheEnabled" value="true"/>
</settings>

在持久层配置

1
2
3
4
@CacheNamespace(blocking = true)
public interface IUserDao {
	// .....
}



标签
SSM