22_6mybatis中的缓存

1.mybatis中的延时加载

问题：在一对多中，当我们有一个用户，它有100个账户。
　　在查询用户的时候，要不要把关联的账户查出来？
　　在查询账户的时候，要不要把关联的用户查出来？

　　在查询用户时，用户下的账户信息应该是，什么时候使用，什么时候查询的。
　　在查询账户时，账户的所属用户信息应该是随着账户查询时一起查询出来。

什么是延迟加载
　　在真正使用数据时才发起查询，不用的时候不查询。按需加载（懒加载）
什么是立即加载
　　不管用不用，只要一调用方法，马上发起查询。

总结：在对应的四种表关系中：一对多，多对一，一对一，多对多

　　一对多，多对多：通常情况下我们都是采用延迟加载。
　　多对一，一对一：通常情况下我们都是采用立即加载。

2.实现需求

需求：
　　查询账户(Account)信息并且关联查询用户(User)信息。如果先查询账户(Account)信息即可满足要求，当我们需要查询用户(User)信息时再查询用户(User)信息。把对用户(User)信息的按需去查询就是延迟加载。
　　mybatis第三天实现多表操作时，我们使用了resultMap来实现一对一，一对多，多对多关系的操作。主要是通过 association、collection 实现一对一及一对多映射。association、collection 具备延迟加载功能。

3.使用assocation实现延迟加载

3.1账户的持久层DAO接口

package com.itheima.dao;

import com.itheima.domain.Account;

import java.util.List;

public interface IAccountDao {

    List<Account> findAll();

}

3.2账户的持久层映射文件

<?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.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的内容

       select属性指定的内容：查询用户的唯一标识：

       column属性指定的内容：用户根据id查询时，所需要的参数的值

       -->

        <association property="user" column="uid" javaType="user"

                     select="com.itheima.dao.IUserDao.findById"></association>

    </resultMap>

    <!-- 查询所有 -->

    <select id="findAll" resultMap="accountUserMap">

        select * from account;

    </select>

    <!-- 根据用户id查询账户列表 -->

    <select id="findAccountByUid" resultType="account">

        select * from account where uid = #{uid}

    </select>

</mapper>

select ：填写我们要调用的 select 映射的 id
column ：填写我们要传递给 select 映射的参数

3.3用户的持久层接口和映射文件

package com.itheima.dao;

import com.itheima.domain.User;

import java.util.List;

/**

 * @author 黑马程序员

 * @Company http://www.ithiema.com

 *

 * 用户的持久层接口

 */

public interface IUserDao {

    /**

     * 查询所有用户，同时获取到用户下所有账户的信息

     * @return

     */

    List<User> findAll();

    /**

     * 根据id查询用户信息

     * @param userId

     * @return

     */

    User findById(Integer userId);

}

<?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集合的映射 -->

        <collection property="accounts" ofType="account">

            <id column="aid" property="id"></id>

            <result column="uid" property="uid"></result>

            <result column="money" property="money"></result>

        </collection>

    </resultMap>

    <!-- 查询所有 -->

    <select id="findAll" resultMap="userAccountMap">

        select * from user u left outer join account a on u.id = a.uid

    </select>

    <!-- 根据id查询用户 -->

    <select id="findById" parameterType="INT" resultType="user">

        select * from user where id = #{uid}

    </select>

</mapper>

3.4开启 Mybatis的延迟加载策略

<?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-->

    <properties resource="jdbcConfig.properties"></properties>

    <!--&lt;!&ndash;配置参数&ndash;&gt;-->

    <settings>

        <!--开启Mybatis支持延迟加载-->

        <setting name="lazyLoadingEnabled" value="true"/>

        <setting name="aggressiveLazyLoading" value="false"></setting>

    </settings>

    <!--使用typeAliases配置别名，它只能配置domain中类的别名 -->

    <typeAliases>

        <package name="com.itheima.domain"></package>

    </typeAliases>

    <!--配置环境-->

    <environments default="mysql">

        <!-- 配置mysql的环境-->

        <environment id="mysql">

            <!-- 配置事务 -->

            <transactionManager type="JDBC"></transactionManager>

            <!--配置连接池-->

            <dataSource type="POOLED">

                <property name="driver" value="${jdbc.driver}"></property>

                <property name="url" value="${jdbc.url}"></property>

                <property name="username" value="${jdbc.username}"></property>

                <property name="password" value="${jdbc.password}"></property>

            </dataSource>

        </environment>

    </environments>

    <!-- 配置映射文件的位置 -->

    <mappers>

        <package name="com.itheima.dao"></package>

    </mappers>

</configuration>

3.5编写测试只查账户信息不查用户信息

package com.itheima.test;

import com.itheima.dao.IAccountDao;

import com.itheima.domain.Account;

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;

import java.util.List;

public class AccountTest {

    private InputStream in;

    private SqlSession sqlSession;

    private IAccountDao accountDao;

    @Before//用于在测试方法执行之前执行

    public void init()throws Exception{

        //1.读取配置文件，生成字节输入流

        in = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2.获取SqlSessionFactory

        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);

        //3.获取SqlSession对象

        sqlSession = factory.openSession(true);

        //4.获取dao的代理对象

        accountDao = sqlSession.getMapper(IAccountDao.class);

    }

    @After//用于在测试方法执行之后执行

    public void destroy()throws Exception{

        //提交事务

        // sqlSession.commit();

        //6.释放资源

        sqlSession.close();

        in.close();

    }

    /**

     * 测试查询所有

     */

    @Test

    public void testFindAll(){

        List<Account> accounts = accountDao.findAll();

    }

}

如果不配置这个

   <settings>

        <!--开启Mybatis支持延迟加载-->

        <setting name="lazyLoadingEnabled" value="true"/>

        <setting name="aggressiveLazyLoading" value="false"></setting>

    </settings>

4.Mybaits中缓存的概念

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

Mybatis中的一级缓存和二级缓存

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

二级缓存:
　　它指的是Mybatis中SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。
　　二级缓存的使用步骤：
　　　　第一步：让Mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）
　　　　第二步：让当前的映射文件支持二级缓存（在IUserDao.xml中配置）
　　　　第三步：让当前的操作支持二级缓存（在select标签中配置）

4.1证明一级缓存的存在

一级缓存是 SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就存在。

4.2user实体类

package com.itheima.domain;

import java.io.Serializable;

import java.util.Date;

import java.util.List;

public class User implements Serializable {

    private Integer id;

    private String username;

    private String address;

    private String sex;

    private Date birthday;

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getAddress() {

        return address;

    }

    public void setAddress(String address) {

        this.address = address;

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex;

    }

    public Date getBirthday() {

        return birthday;

    }

    public void setBirthday(Date birthday) {

        this.birthday = birthday;

    }

//    @Override

//    public String toString() {

//        return "User{" +

//                "id=" + id +

//                ", username='" + username + '\'' +

//                ", address='" + address + '\'' +

//                ", sex='" + sex + '\'' +

//                ", birthday=" + birthday +

//                '}';

//    }

}

4.3编写用户持久层Dao接口

package com.itheima.dao;

import com.itheima.domain.User;

import java.util.List;

public interface IUserDao {

    /**

     * 查询所有用户，同时获取到用户下所有账户的信息

     * @return

     */

    List<User> findAll();

    /**

     * 根据id查询用户信息

     * @param userId

     * @return

     */

    User findById(Integer userId);

}

4.4编写用户持久层映射文件

<?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">

    <!-- 查询所有 -->

    <select id="findAll" resultType="user">

        select * from user

    </select>

    <!-- 根据id查询用户 -->

    <select id="findById" parameterType="INT" resultType="user">

        select * from user where id = #{uid}

    </select>

</mapper>

4.5测试方法

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.InputStream;

import java.util.List;

/**

 * @author 黑马程序员

 * @Company http://www.ithiema.com

 */

public class UserTest {

    private InputStream in;

    private SqlSession sqlSession;

    private IUserDao userDao;

    private SqlSessionFactory factory;

    @Before//用于在测试方法执行之前执行

    public void init() throws Exception {

        //1.读取配置文件，生成字节输入流

        in = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2.获取SqlSessionFactory

        factory = new SqlSessionFactoryBuilder().build(in);

        //3.获取SqlSession对象

        sqlSession = factory.openSession(true);

        //4.获取dao的代理对象

        userDao = sqlSession.getMapper(IUserDao.class);

    }

    @After//用于在测试方法执行之后执行

    public void destroy() throws Exception {

        //提交事务

        // sqlSession.commit();

        //6.释放资源

        sqlSession.close();

        in.close();

    }

    /**

     * 测试一级缓存

     */

    @Test

    public void testFirstLevelCache() {

        User user1 = userDao.findById(41);

        System.out.println(user1);

        sqlSession.close();

        sqlSession = factory.openSession();

        userDao = sqlSession.getMapper(IUserDao.class);

        User user2 = userDao.findById(41);

        System.out.println(user2);

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

    }

}

如果关闭了sqlSession，可以看出不是同一个对象，并且可以看到数据库查询了两次。如果不关闭sqlSession会怎么样呢？

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.InputStream;

import java.util.List;

/**

 * @author 黑马程序员

 * @Company http://www.ithiema.com

 */

public class UserTest {

    private InputStream in;

    private SqlSession sqlSession;

    private IUserDao userDao;

    private SqlSessionFactory factory;

    @Before//用于在测试方法执行之前执行

    public void init() throws Exception {

        //1.读取配置文件，生成字节输入流

        in = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2.获取SqlSessionFactory

        factory = new SqlSessionFactoryBuilder().build(in);

        //3.获取SqlSession对象

        sqlSession = factory.openSession(true);

        //4.获取dao的代理对象

        userDao = sqlSession.getMapper(IUserDao.class);

    }

    @After//用于在测试方法执行之后执行

    public void destroy() throws Exception {

        //提交事务

        // sqlSession.commit();

        //6.释放资源

        sqlSession.close();

        in.close();

    }

    /**

     * 测试一级缓存

     */

    @Test

    public void testFirstLevelCache() {

        User user1 = userDao.findById(41);

        System.out.println(user1);

//        sqlSession.close();

//        sqlSession = factory.openSession();

//        userDao = sqlSession.getMapper(IUserDao.class);

        User user2 = userDao.findById(41);

        System.out.println(user2);

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

    }

}

如果不关闭sqlSession，对象时同一个，说明应用了缓存中的对象，并且数据库只被查询了一次。

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.InputStream;

import java.util.List;

/**

 * @author 黑马程序员

 * @Company http://www.ithiema.com

 */

public class UserTest {

    private InputStream in;

    private SqlSession sqlSession;

    private IUserDao userDao;

    private SqlSessionFactory factory;

    @Before//用于在测试方法执行之前执行

    public void init() throws Exception {

        //1.读取配置文件，生成字节输入流

        in = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2.获取SqlSessionFactory

        factory = new SqlSessionFactoryBuilder().build(in);

        //3.获取SqlSession对象

        sqlSession = factory.openSession(true);

        //4.获取dao的代理对象

        userDao = sqlSession.getMapper(IUserDao.class);

    }

    @After//用于在测试方法执行之后执行

    public void destroy() throws Exception {

        //提交事务

        // sqlSession.commit();

        //6.释放资源

        sqlSession.close();

        in.close();

    }

    /**

     * 测试一级缓存

     */

    @Test

    public void testFirstLevelCache() {

        User user1 = userDao.findById(41);

        System.out.println(user1);

        sqlSession.clearCache();//此方法也可以清空缓存

        User user2 = userDao.findById(41);

        System.out.println(user2);

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

    }

}

4.6 一级缓存的分析

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

4.7测试一级缓存的清空

package com.itheima.dao;

import com.itheima.domain.User;

import java.util.List;

public interface IUserDao {

    /**

     * 查询所有用户，同时获取到用户下所有账户的信息

     * @return

     */

    List<User> findAll();

    /**

     * 根据id查询用户信息

     * @param userId

     * @return

     */

    User findById(Integer userId);

    /**

     * 更新用户信息

     * @param user

     */

    void updateUser(User user);

}

<?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">

    <!-- 查询所有 -->

    <select id="findAll" resultType="user">

        select * from user

    </select>

    <!-- 根据id查询用户 -->

    <select id="findById" parameterType="INT" resultType="user">

        select * from user where id = #{uid}

    </select>

    <!-- 更新用户信息-->

    <update id="updateUser" parameterType="user">

        update user set username=#{username},address=#{address} where id=#{id}

    </update>

</mapper>

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.InputStream;

import java.util.List;

/**

 * @author 黑马程序员

 * @Company http://www.ithiema.com

 */

public class UserTest {

    private InputStream in;

    private SqlSession sqlSession;

    private IUserDao userDao;

    private SqlSessionFactory factory;

    @Before//用于在测试方法执行之前执行

    public void init() throws Exception {

        //1.读取配置文件，生成字节输入流

        in = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2.获取SqlSessionFactory

        factory = new SqlSessionFactoryBuilder().build(in);

        //3.获取SqlSession对象

        sqlSession = factory.openSession(true);

        //4.获取dao的代理对象

        userDao = sqlSession.getMapper(IUserDao.class);

    }

    @After//用于在测试方法执行之后执行

    public void destroy() throws Exception {

        //提交事务

        // sqlSession.commit();

        //6.释放资源

        sqlSession.close();

        in.close();

    }

    /**

     * 测试一级缓存

     */

    @Test

    public void testFirstLevelCache() {

        User user1 = userDao.findById(41);

        System.out.println(user1);

        sqlSession.clearCache();//此方法也可以清空缓存

        User user2 = userDao.findById(41);

        System.out.println(user2);

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

    }

    /**

     * 测试一级缓存

     */

    @Test

    public void testClearCache() {

        //1.根据id查询用户

        User user1 = userDao.findById(41);

        System.out.println(user1);

        //2.更新用户信息

        user1.setUsername("update user clear cache");

        user1.setAddress("beijing");

        userDao.updateUser(user1);

        //3.再次查询id为41的用户

        User user2 = userDao.findById(41);

        System.out.println(user2);

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

    }

}

4.8二级缓存

二级缓存是 mapper 映射级别的缓存，多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句，多个SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的。

4.9开启二级缓存

第一步：在 SqlMapConfig.xml

<?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-->

    <properties resource="jdbcConfig.properties"></properties>

    <settings>

        <setting name="cacheEnabled" value="true"/>

    </settings>

    <!--使用typeAliases配置别名，它只能配置domain中类的别名 -->

    <typeAliases>

        <package name="com.itheima.domain"></package>

    </typeAliases>

    <!--配置环境-->

    <environments default="mysql">

        <!-- 配置mysql的环境-->

        <environment id="mysql">

            <!-- 配置事务 -->

            <transactionManager type="JDBC"></transactionManager>

            <!--配置连接池-->

            <dataSource type="POOLED">

                <property name="driver" value="${jdbc.driver}"></property>

                <property name="url" value="${jdbc.url}"></property>

                <property name="username" value="${jdbc.username}"></property>

                <property name="password" value="${jdbc.password}"></property>

            </dataSource>

        </environment>

    </environments>

    <!-- 配置映射文件的位置 -->

    <mappers>

        <package name="com.itheima.dao"></package>

    </mappers>

</configuration>

第二步：配置相关的Mapper映射文

<?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支持二级缓存-->

    <cache/>

    <!-- 查询所有 -->

    <select id="findAll" resultType="user">

        select * from user

    </select>

    <!-- 根据id查询用户 -->

    <select id="findById" parameterType="INT" resultType="user" useCache="true">

        select * from user where id = #{uid}

    </select>

    <!-- 更新用户信息-->

    <update id="updateUser" parameterType="user">

        update user set username=#{username},address=#{address} where id=#{id}

    </update>

</mapper>

4.10测试

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.InputStream;

/**

 * @author 黑马程序员

 * @Company http://www.ithiema.com

 */

public class SecondLevelCacheTest {

    private InputStream in;

    private SqlSessionFactory factory;

    @Before//用于在测试方法执行之前执行

    public void init() throws Exception {

        //1.读取配置文件，生成字节输入流

        in = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2.获取SqlSessionFactory

        factory = new SqlSessionFactoryBuilder().build(in);

    }

    @After//用于在测试方法执行之后执行

    public void destroy() throws Exception {

        in.close();

    }

    /**

     * 测试一级缓存

     */

    @Test

    public void testFirstLevelCache() {

        SqlSession sqlSession1 = factory.openSession(true);

        IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);

        User user1 = dao1.findById(41);

        System.out.println(user1);

        sqlSession1.close();

        SqlSession sqlSession2 = factory.openSession(true);

        IUserDao dao2 = sqlSession2.getMapper(IUserDao.class);

        User user2 = dao2.findById(41);

        System.out.println(user2);

        sqlSession2.close();

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

    }

}

因为两个对象的内存地址不一样，而数据库查询方法只调用了一次，所以可以看出二级缓存存入的不是对象二是数据，所以共享的是数据。

巴特西