SSM基础-MyBatis缓存

最新推荐文章于 2022-12-16 13:52:44 发布

coder_aji

最新推荐文章于 2022-12-16 13:52:44 发布

阅读量1.1k

点赞数 1

分类专栏： # SSM 文章标签：缓存数据库 mybatis java

本文链接：https://blog.csdn.net/weixin_46899412/article/details/123020218

版权

SSM 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

缓存

什么是缓存？

存储在内存当中的数据；将用户常使用的数据存放在缓存(内存)当中，用户查询数据就不用从磁盘(关系型数据库文件)当中查询，从缓存当中查询，从而提高查询效率，解决了高并发系统的性能问题

为什么使用缓存？

减少和数据库的交互次数，减少系统开销，提高系统效率

什么样的数据能使用缓存？

经常查询并且不常改变的数据

Mybatis缓存

mybatis包含了一个非常强大的查询缓存特性，他可以非常方便的定制和配置缓存。缓存可以极大的提高查询的效率

mybatis系统当中默认定义了两级缓存：一级缓存和二级缓存。默认情况之下，只有一级缓存开启（sqlSession级别的缓存）；二级缓存需要手动开启配置，需要局域namespace级别的缓存。

一级缓存

1.一级缓存也叫本地缓存:与数据库同一次会话期间查询到的数据会放入的本地缓存当中，如果以后需要获取相同的数据直接去缓存当中拿，没必要再去查询数据库。

2.测试一级缓存

创建maven项目，在src\main\resource目录下创建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>
    <settings>
        <!--设置mybatis输出日志-->
        <!--logImpl：表示对日志的控制-->
        <!--STDOUT_LOGGING:将日志输出到控制台上-->
        <setting name="logImpl" value="STDOUT_LOGGING" />

    </settings>
    <environments default="mysql">
        <environment id="mysql">
            <!--配置事务的类型，使用本地事务策略-->
            <transactionManager type="JDBC"></transactionManager>
            <!--是否使用连接池 POOLED表示使用链接池，UNPOOLED表示不使用连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis_demo"/>
                <property name="username" value="root"/>
                <property name="password" value="20220101"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        
    </mappers>
</configuration>

编写数据库中的user表

create database mybatis_demo;
 
use mybatis_demo;
 
CREATE TABLE `user` (
`id` int(11) NOT NULL auto_increment,
`username` varchar(32) NOT NULL COMMENT '用户名称',
`birthday` datetime default NULL COMMENT '生日',
`sex` char(1) default NULL COMMENT '性别',
`address` varchar(256) default NULL COMMENT '地址',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
insert into `user`(`id`,`username`,`birthday`,`sex`,`address`) 
values (1,'老王','2018-02-27 17:47:08','男','北京'),
(2,'熊大','2018-03-02 15:09:37','女','上海'),
(3,'熊二','2018-03-04 11:34:34','女','深圳'),
(4,'光头强','2018-03-04 12:04:06','男','广州');

在src\main\java目录下创建com.qcby.entity包，在包下创建User类以及get,set,toString方法

public class User {
    private Integer user_id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    //...
}

在src\main\java目录下创建com.qcby.dao包，在包下创建UserDao接口

public interface UserDao {

}

在src\main\resource目录下创建mapper文件夹，在文件夹里面创建UserMapper.xml文件

<?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.qcby.dao.UserDao">
    <select id="findAll" resultType="com.qcby.entity.User">
        select * from user where id=1
    </select>
</mapper>

在UserDao中创建新方法

public interface UserDao {
    public User findAll();
}

在SqlMapConfig.xml文件的mapper标签里添加下面内容

<mapper resource="mapper/UserMapper.xml"></mapper>

在src\test\java目录下创建UserTest测试类

public class UserTest {
    private InputStream in = null;
    private SqlSession session = null;
    private UserDao mapper = null;

    @Test
    public void findAll() throws IOException {
        //加载主配置文件，目的是为了构建SqlSessionFactory对象
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建SqlSessionFactory对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //通过SqlSessionFactory工厂对象创建SqlSesssion对象
        session = factory.openSession();
        //通过Session创建UserDao接口代理对象
        mapper = session.getMapper(UserDao.class);

        User user1 = mapper.findAll();
        System.out.println(user1.toString());
        

        User user2 = mapper.findAll();
        System.out.println(user2.toString());

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

        //释放资源
        session.close();
        in.close();
    }
}

测试结果

3.缓存失效的情况

编写UserMapper.xml

<select id="findID" parameterType="java.lang.Integer" resultType="com.qcby.entity.User">
        select * from user where id=#{id}
    </select>

编写UserDao接口，添加新方法

public interface UserDao {
    public User findID(Integer id);
}

sqlSession不同

public class UserTest {
    private InputStream in = null;
    private SqlSession session = null;
    private UserDao mapper = null;
    private SqlSession session2 = null;
    private UserDao mapper2 = null;
    @Test
    public void findAll1() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        session = factory.openSession();
        session2 = factory.openSession();

        mapper = session.getMapper(UserDao.class);
        mapper2 = session2.getMapper(UserDao.class);
        User user1 = mapper.findID(1);
        System.out.println(user1.toString());
        User user2 = mapper2.findID(1);
        System.out.println(user2.toString());
        System.out.println(user1 == user2);
        //释放资源
        session.close();
        session2.close();
        in.close();
    }
}

sqlSession相同，查询条件不同

public void findAll1() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        session = factory.openSession();
        mapper = session.getMapper(UserDao.class);
        User user1 = mapper.findID(1);
        System.out.println(user1.toString());
        User user2 = mapper.findID(2);
        System.out.println(user2.toString());
        System.out.println(user1 == user2);
        //释放资源
        session.close();
        in.close();
    }

sqlSession相同，两次查询之间执行了增删改操作！

编写UserMapper.xml文件，添加以下删除语句

<delete id="delete" parameterType="java.lang.Integer">
        delete from user where id=#{id}
    </delete>

编写UserDao接口，新增delete方法

public interface UserDao {
    //删除
    public int delete(Integer id);
}

编写UserTest

public void findAll1() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        session = factory.openSession();
        mapper = session.getMapper(UserDao.class);
        User user1 = mapper.findID(1);
        System.out.println(user1.toString());
        //删除操作
        mapper.delete(3);
        User user2 = mapper.findID(1);
        System.out.println(user2.toString());
        System.out.println(user1 == user2);
        //释放资源
        session.close();
        in.close();
    }

sqlSession相同，手动清除一级缓存

public void findAll1() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        session = factory.openSession();
        mapper = session.getMapper(UserDao.class);
        User user1 = mapper.findID(1);
        System.out.println(user1.toString());
        //清除缓存
        session.clearCache();
        User user2 = mapper.findID(1);
        System.out.println(user2.toString());
        System.out.println(user1 == user2);
        //释放资源
        session.close();
        in.close();
    }

二级缓存

MyBatis的二级缓存非常强大，它不同于一级缓存只存在于 SqlSession 的生命周期中，而是可以理解为存在于 SqlSessionFactory 的生命周期中。

1. 在SqlMapConfig.xml配置文件中开启二级缓存，放到settings标签下

<!‐‐ 开启二级缓存 ‐‐>
<settings>
    <!--开启二级缓存-->
    <setting name="cacheEnabled" value="true"/>
</settings>

2. 在UserDao.xml配置文件声明使用二级缓存，放到mapper标签下

<!--使用二级缓存-->
<cache eviction="FIFO"  #收回策略
        flushInterval="6000" #刷新间隔
        size="512"  #引用数目
        readOnly="true"/>  #只读

3.参数的具体细节

eviction(收回策略)

LRU(最近最少使用的):移除最长时间不被使用的对象，这是默认值。
FIFO(先进先出):按对象进入缓存的顺序来移除它们。
SOFT(软引用):移除基于垃圾回收器状态和软引用规则的对象。
WEAK(弱引用):更积极地移除基于垃圾收集器状态和弱引用规则的对象。

flushinterval(刷新间隔)

可以被设置为任意的正整数，而且它们代表一个合理的毫秒形式的时间段。 
默认情况不设置，即没有刷新间隔，缓存仅仅在调用语句时刷新。

size(引用数目)

可以被设置为任意正整数，要记住缓存的对象数目和运行环境的可用内存资源数目。默认值是1024 。

readOnly(只读)

属性可以被设置为 true 或 false。
只读的缓存会给所有调用者返回缓存对象的相同实例，因此这些对象不能被修改， 这提供了很重要的性能优势。 
可读写的缓存会通过序列化返回缓存对象的拷贝，这种方式会慢一些，但是安全，因此默认是 false。

4. 在select标签上使用二级缓存

编写UserMapper.xml文件，给select标签添加userCache属性并设置从true

<select id="findID" useCache="true" parameterType="java.lang.Integer" resultType="com.qcby.entity.User">
        select * from user where id=#{id}
    </select>

编写User Test

public class UserTest {
    private InputStream in = null;
    private SqlSession session = null;
    private UserDao mapper = null;
    private SqlSession session2 = null;
    private UserDao mapper2 = null;
    @Test
    public void findAll1() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        session = factory.openSession();
        session2 = factory.openSession();
        mapper = session.getMapper(UserDao.class);
        mapper2 = session2.getMapper(UserDao.class);
        User user1 = mapper.findID(1);
        session.commit();
        System.out.println(user1.toString());

        User user2 = mapper2.findID(1);
        session.commit();
        System.out.println(user2.toString());
        System.out.println(user1 == user2);
        //释放资源
        session.close();
        in.close();
    }
}