Mybatis04:延迟加载、一二级缓存、注解开发

V2AS问路

Mybatis04:延迟加载、一二级缓存、注解开发

阅读原文时间：2023年07月08日阅读：1

今日内容

mybatis中的延迟加载
延迟加载的概念
立即加载的概念
如果实现延迟加载
Mybatis中的缓存
什么是缓存
为什么使用缓存
什么数据可以使用缓存，什么样的数据不能使用缓存
Mybatis中的一级缓存和二级缓存
Mybatis中的注解开发
环境搭建
单表crud操作（代理dao方式）
多表查询操作
缓存的配置

一、延迟加载

1、背景

问题：在一对多中，当有1个用户有100个账户

查询用户时，是否需要把关联的账户查出来

内存的巨大开销，但如果不查出来，无法使用
即：在查询用户时，什么时候使用账户信息，什么时候去查（根据用户的需求）
在查询账户时，是否需要把关联的用户查出来
在查询账户时，账户的所属用户信息应该随着账户查询时一起查询出来

2、延迟加载和立即加载的概念

延迟加载：在真正使用数据时才发起查询，不用的时候不查询，需要按需加载（懒加载）
立即加载：不管用不用，只要一调用方法，马上发起查询
选择：在四种表关系中
一对多，多对多：通常情况下采用延迟加载（集合浪费及内存空间）
多对一，一对一：采用立即加载

3、mybatis一对一实现延迟加载--association

查询账户对应的用户【只查账户不查用户】

<configuration>
    <properties resource="jdbcConfig.properties">
    </properties>
    <settings>
        <!--开启Mybatis支持延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!--Mybatis每个属性都会按需加载-->
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

<mapper namespace="com.itcast.dao.IAccountDao">
    <!--定义封装account和user的resultMap-->
    <resultMap id="accountUserMap" type="account">
        <id property="id" column="id"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!--应当建立一对一的关系映射：配置封装user的内容-->
        <!--
            使用association标签配置延迟加载
            通过select属性指定的唯一内容，查询用户的唯一标识-根据id查询用户的配置
            column属性指定的内容：用户根据id查询时，所需要参数的值
        -->
        <association property="user" column="uid" javaType="user" select="com.itcast.dao.IUserDao.findById">
        </association>

    </resultMap>
    <select id="findAll" resultMap="accountUserMap" >
        SELECT * FROM account
    </select>
</mapper>

    <select id="findById" parameterType="int" resultType="user">
        select * from user where id = #{uid}
    </select>

   /**
     * 测试查询所有
     */
    @Test
    public void testFindAll(){
        List<Account> accounts = accountDao.findAll();
        /*for (Account account : accounts) {
            System.out.println("-----每个account的信息-----");
            System.out.println(account);
            System.out.println(account.getUser());*/
        }

4、mybatis一对多实现延迟加载--collection

查询用户下的账户信息，对账户信息进行延迟加载（一对多）【只查用户不查账户】

<mapper namespace="com.itcast.dao.IAccountDao">
    <!--定义封装account和user的resultMap-->
    <resultMap id="accountUserMap" type="account">
        <id property="id" column="id"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!--应当建立一对一的关系映射：配置封装user的内容-->
        <!--
            使用association标签配置延迟加载
            通过select属性指定的唯一内容，查询用户的唯一标识-根据id查询用户的配置
            column属性指定的内容：用户根据id查询时，所需要参数的值
        -->
        <association property="user" column="uid" javaType="user" select="com.itcast.dao.IUserDao.findById"></association>
        <collection property="accounts" ofType="account" select="com.itcast.dao.IUserDao.findAccountByUid" column="id"></collection>
    </resultMap>
    <!--根据用户id查询账户列表-->
    <select id="findAccountByUid" resultType="account">
        SELECT * FROM account where uid = #{uid}
    </select>
</mapper>

<mapper namespace="com.itcast.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对象中account集合的映射-->
        <collection property="accounts" ofType="account">
        </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("-----每个account的信息-----");
            System.out.println(user);
            System.out.println(user.getAccounts());
        }*/
    }

二、缓存

1、缓存的概念

什么是缓存：存在于内存中的临时数据
为什么使用缓存：减少和数据库的交互次数，提高执行效率
适用于缓存的数据：
经常用于查询并且不经常改变的
数据的正确与否对最终结果影响不大
不适用于缓存：
经常改变的数据
数据的正确与否对最终结果影响很大，如商品的库存、银行的汇率、股市的牌价

2、Mybatis中的一级缓存

指的是Mybatis中SQLSession对象的缓存，即当执行查询之后，查询的结果会同时存入到SQLSession提供的一块区域中，该区域的结构是一个map；当再次查询同样数据时，Mybatis会先去SqlSession中查看是否有map，如果有的话，直接拿来使用

当SqlSession对象消失时，Mybatis的一级缓存也会消失

 /**
 * session关闭，缓存消失
 */
@Test
public void testFirstLevelCache(){
    User user1 = userDao.findById(41);
    System.out.println(user1);
    //关闭sesson
    /*sqlSession.close();
    sqlSession = factory.openSession();
    userDao = sqlSession.getMapper(IUserDao.class);*/
    //SQLSession清空缓存的方法，也可以清空缓存，执行两次查询
    sqlSession.clearCache();
    User user2 = userDao.findById(41);
    System.out.println(user2);
    System.out.println(user1==user2);
}

3、触发清空一级缓存的情况

一级缓存是 SqlSession 范围的缓存，当调用 SqlSession 的修改，添加，删除，commit()，close()等方法时，就会清空一级缓存。

    <!--更新用户信息-->
    <update id="updateUser" parameterType="user">
        update user set username=#{username},address=#{address} where id =#{id}
    </update>

    /**
     * 测试缓存的同步
     */
    @Test
    public void testClearCache(){
        //1.根据id查询用户
        User user1 = userDao.findById(41);
        System.out.println(user1);
        //2.更新用户信息
        user1.setUsername("clear cache");
        user1.setAddress("望京");
        //userDao.updateUser(user1);
        //3.再次查询id为41的用户
        User user2 = userDao.findById(41);
        System.out.println(user2);
        System.out.println(user1==user2);
    }

8、mybatis的二级缓存

概念：指的是Mybatis中，SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。

/**
 * session关闭，缓存消失
 */
@Test
public void testFirstLevelCache(){
    SqlSession sqlSession1 = factory.openSession();
    IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);
    User user1 = dao1.findById(41);
    System.out.println(user1);
    sqlSession1.close();//一级缓存消失SqlSession sqlSession2 = factory.openSession();
IUserDao dao2 = sqlSession2.getMapper(IUserDao.class);
User user2 = dao2.findById(41);
System.out.println(user2);
sqlSession2.close();

System.out.println(user1==user2);
}

//结果不可以

使用步骤：
第一步：让Mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）
第二步：让当前的映射文件支持二级缓存（在IUserDao.xml中配置）
第三步：让当前的操作支持二级缓存（在select标签中配置）

存放数据而不是对象，每次都会创建新的用户对象

三、注解开发【单表和多表】

1、注解开发的环境搭建

之前两个xml：SqlMapConfig.xml和IUserDao.xml
注解开发只是配置IUserDao.xml
环境搭建

package com.itheima.dao;

import com.itheima.domain.User;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
- 在Mybatis中，针对CRUD共有4个注解
- @Select @Insert @Update @Delete / public interface IUserDao { /*
  - 查询所有用户
  - @return
    */
    @Select("select * from user")
    List findAll();
    }

2、注解开发测试和使用注意事项

package com.itheima.test;

import com.itheima.dao.IUserDao;
import com.itheima.domain.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 java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MybatisAnnoTest {
    /**
     * 测试基于注解的Mybatis使用
     * @param args
     */
    public static void main(String[] args) throws IOException {
        //1.获取字节输入流
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.根据字节输入流获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.根据SqlSessionFactory生产一个SqlSession
        SqlSession session = factory.openSession();
        //4.使用SqlSession获取Dao的代理对象
        IUserDao userDao = session.getMapper(IUserDao.class);
        //5.执行Dao的方法
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
        //6.释放资源
        session.close();
        in.close();
    }
}

xml配置文件：

注解：

采用注解开发时，就不能在同一路径下进行xml开发
解决方案1：删掉xml

解决方案2：把xml放到其他不相关路径上

<!-- 指定带有注解的dao接口所在位置 -->
<mappers>
    <!--<package name="com.itheima.dao"></package>-->
    <!--也不可以<mapper class="com.itheima.dao.IUserDao"></mapper>-->
    <!--使用xml配置<mapper resource="com/itheima/dao/IUserDao.xml"></mapper>-->
</mappers>

3、注解开发CRUD的其他操作

package com.itheima.dao;
import com.itheima.domain.User;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Select;
import java.util.List;
/**
 * 在Mybatis中，针对CRUD共有4个注解
 * @Select @Insert @Update @Delete
 */
public interface IUserDao {
    /**
     * 查询所有用户
     * @return
     */
    @Select("select * from user")
    List<User> findAll();
    /**
     * 删除用户
     * @param userId
     */
    @Delete("delete from user where id = #{id}")
    void deleteUser(Integer userId);

    /**
     * 根据id查询用户
     * @param userId
     * @return
     */
    @Select("select * from user where id = #{id}")
    User findById(Integer userId);
    /**
     * 根据用户名称模糊查询
     * @param username
     * @return
     */
    //@Select("select * from user where username like #{username}")---字符串拼接
    //模糊查询的另外一种写法，固定属性名称value---参数占位符
    @Select("select * from user where username like '%${value}%'")
    List<User> findByName(String username);
    /**
     * 查询总用户数量
     * @return
     */
    @Select("select count(*) from user")
    int findTotal();
}

package com.itheima.test;
import com.itheima.dao.IUserDao;
import com.itheima.domain.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.IOException;
import java.io.InputStream;
import java.util.List;
public class AnnotationCRUDTest {
    private InputStream in;
    private SqlSession sqlSession;
    private IUserDao userDao;
    private SqlSessionFactory factory;
    /**
     * 在测试方法执行之前执行
     * @throws IOException
     */
    @Before
    public void init() throws IOException {
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory
        factory = new SqlSessionFactoryBuilder().build(in);
        //3.使用工厂对象，创建dao对象
        //userDao = new UserDaoImpl(factory);
        sqlSession = factory.openSession();
        //4.获取dao的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }
    /**
     * 释放资源
     * 在测试方法之后执行
     */
    @After
    public void destroy() throws IOException {
        //提交事务
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }
    @Test
    public void testDelete(){
        /*User user = new User();
        user.setId(52);*/
        userDao.deleteUser(52);
    }
    @Test
    public void testFindOne(){
        User user = userDao.findById(53);
        System.out.println(user);
    }
    @Test
    public void testFindByName(){
        //List<User> users = userDao.findByName("%王%");
        List<User> users = userDao.findByName("王");
        for (User user : users) {
            System.out.println(user);
        }
    }
    @Test
    public void testFindTotal(){
        int total = userDao.findTotal();
        System.out.println(total);
    }
}

4、mybatis注解建立实体类属性和数据库表中列的对应关系

package com.itheima.dao;
import com.itheima.domain.User;
import org.apache.ibatis.annotations.*;
import java.util.List;
/**
 * 在Mybatis中，针对CRUD共有4个注解
 * @Select @Insert @Update @Delete
 */
public interface IUserDao {
    /**
     * 查询所有用户
     * @return
     */
    @Select("select * from user")
    @Results(id="userMap",value={
            @Result(id=true,column = "id",property = "userId"),
            @Result(column = "username",property = "userName"),
            @Result(column = "address",property = "userAddress"),
            @Result(column = "sex",property = "userSex"),
            @Result(column = "birthday",property = "userBirthday"),
    })
    List<User> findAll();
    /**
     * 根据id查询用户
     * @param userId
     * @return
     */
    @Select("select * from user where id = #{id}")
    @ResultMap(value="userMap")
    User findById(Integer userId);
    /**
     * 根据用户名称模糊查询
     * @param username
     * @return
     */
    //@Select("select * from user where username like #{username}")---字符串拼接
    //模糊查询的另外一种写法，固定属性名称value---参数占位符
    @Select("select * from user where username like '%${value}%'")
    @ResultMap("userMap")
    List<User> findByName(String username);
}

5、mybatis注解开发一对一的查询配置（多表查询）

package com.itheima.dao;

import com.itheima.domain.Account;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.mapping.FetchType;

import java.util.List;

public interface IAccountDao {
    /**
     * 查询所有账户，并且获取每个账户的用户信息
     * @return
     */
    @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="com.itheima.dao.IUserDao.findById",fetchType= FetchType.EAGER))
    })
    List<Account> findAll();
}

public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;
    //多对一（Mybatis中称为一对一的映射）：一个账户只能属于一个用户
    //一个用户对应多个账户，一个账户只属于一个用户
    private User user;

    public User getUser() {
        return user;
    }

6、Mybatis注解开发一对多的查询配置

一对多：延迟加载

多对一/一对一：立即加载

public interface IUserDao {
    /**
     * 查询所有用户
     * @return
     */
    @Select("select * from user")
    @Results(id="userMap",value={
            @Result(id=true,column = "id",property = "userId"),
            @Result(column = "username",property = "userName"),
            @Result(column = "address",property = "userAddress"),
            @Result(column = "sex",property = "userSex"),
            @Result(column = "birthday",property = "userBirthday"),
            @Result(property = "accounts",column = "id",
                    many=@Many(select = "com.itheima.dao.IAccountDao.findAccountByUid",
                            fetchType = FetchType.LAZY))
    })
    List<User> findAll();

    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println("---每个用户的信息：---");
            System.out.println(user);
            //实现了延迟加载，没有立即查询account
            //System.out.println(user.getAccounts());

        }
    }

public class User implements Serializable {
    private Integer userId;
    private String userName;
    private String userAddress;
    private String userSex;
    private Date userBirthday;
    //包含一对多关系映射：一个用户对应多个账户
    private List<Account> accounts;

    public List<Account> getAccounts() {
        return accounts;
    }

7、mybatis注解开发使用二级缓存

package com.itheima.test;

import com.itheima.dao.IUserDao;
import com.itheima.domain.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.IOException;
import java.io.InputStream;
import java.util.List;

public class AnnotationCRUDTest {
    private InputStream in;
    private SqlSession sqlSession;
    private IUserDao userDao;
    private SqlSessionFactory factory;

    /**
     * 在测试方法执行之前执行
     * @throws IOException
     */
    @Before
    public void init() throws IOException {
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory
        factory = new SqlSessionFactoryBuilder().build(in);
        //3.使用工厂对象，创建dao对象
        //userDao = new UserDaoImpl(factory);
        sqlSession = factory.openSession();
        //4.获取dao的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }

    /**
     * 释放资源
     * 在测试方法之后执行
     */
    @After
    public void destroy() throws IOException {
        //提交事务
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }
    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println("---每个用户的信息：---");
            System.out.println(user);
            //实现了延迟加载，没有立即查询account
            //System.out.println(user.getAccounts());

        }
    }
    @Test
    public void testFindOne(){
        User user = userDao.findById(41);
        System.out.println(user);

        User user2 = userDao.findById(41);
        System.out.println(user2);

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

<configuration>
    <!-- 引入外部配置文件 -->
    <properties resource="jdbcConfig.properties"></properties>
    <!--全局配置：开启二级缓存（默认开启）-->
    <settings>
        <setting name="cacheEnabled" value="true"/>
    </settings>

@CacheNamespace(blocking = true)
public interface IUserDao {