Mybatis的缓存
1 缓存的概念
什么是缓存？
存在于内存中的临时数据。
为什么使用缓存？
减少和数据库的交互次数，提高执行效率。
什么样的数据能使用缓存，什么样的数据不能使用？
适用于缓存：
经常查询并且不经常改变的。
数据的正确与否对最终结果影响不大的。
不适用于缓存：
经常改变的数据.
数据的正确与否对最终结果影响很大的。
例如：商品的库存，银行的汇率，股市的牌价。
2 Mybatis中的一级缓存
Mybatis中的一级缓存和二级缓存
一级缓存：
它指的是Mybatis中SqlSession对象的缓存。
当我们执行查询之后，查询的结果会同时存入到SqlSession为我们提供一块区域中。
该区域的结构是一个Map。当我们再次查询同样的数据，mybatis会先去sqlsession中
查询是否有，有的话直接拿出来用。
当SqlSession对象消失时，mybatis的一级缓存也就消失了。
1.点击File选择New并点击Project。如图所示：
2.选择Maven工程和JDK的版本，点击Next。如图所示：
3.填写项目名称和保存的地址，并点击Finish。如图所示：
4.导入相应的依赖jar包的代码如下：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.txw</groupId>
<artifactId>day04_02cache</artifactId>
<version>1.0-SNAPSHOT</version>
<!--打包的方式-->
<packaging>jar</packaging>
<!--导入mybatis的依赖jar包的坐标-->
<dependencies>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<!--导入mysql的依赖jar包的坐标-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
<!--导入log4j的依赖jar包的坐标-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<!--导入junit的依赖jar包的坐标-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!--导入lombok的依赖jar包的坐标-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
</dependency>
</dependencies>
</project>
5.编写用户实体类的代码如下：
package com.txw.domain;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* 用户的实体类
* @author：Adair
* @QQ：1578533828
*/
@Data // 自动生成set和get方法
@SuppressWarnings("all") // 注解警告信息
public class User implements Serializable {
private Integer id; // 用户的id
private String username; // 用户的名称
private String address; // 用户的地址
private String sex; // 用户的性别
private Date birthday; // 用户的地址
}
6.编写用户实体类的持久层接口代码如下：
package com.txw.dao;
import com.txw.domain.User;
import java.util.List;
/**
* 用户的持久层接口
* @author：Adair
* @QQ：1578533828
*/
@SuppressWarnings("all") // 注解警告信息
public interface UserDao {
/**
* 查询所有用户，同时获取到用户下所有账户的信息
* @return
*/
List<User> findAll();
/**
* 根据id查询用户信息
* @param userId
* @return
*/
User findById(Integer userId);
}
7.在resources目录下创建jdbcConfig.properties的代码如下：
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.59.130:3306/mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456
8.在resources目录下创建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>
<!--使用typeAliases配置别名，它只能配置domain中类的别名 -->
<typeAliases>
<package name="com.txw.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.txw.dao"></package>
</mappers>
</configuration>
9.在resources目录下创建com.txw,dao.UserDao.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.txw.dao.UserDao">
<!-- 查询所有 -->
<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>
</mapper>
10.编写测试的代码如下：
package com.txw.test;
import com.txw.dao.UserDao;
import com.txw.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;
/**
* User的测试
* @author：Adair
* @QQ：1578533828
*/
@SuppressWarnings("all") // 注解警告信息
public class UserTest {
private InputStream in;
private SqlSessionFactory factory;
private SqlSession sqlSession;
private UserDao userDao;
@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(UserDao.class);
}
@After // 用于在测试方法执行之后执行
public void destroy()throws Exception{
// 提交事务
//sqlSession.commit();
// 6.释放资源
sqlSession.close();
in.close();
}
/**
* 测试一级缓存
*/
@Test
public void testFirstLevelCache(){
User user1 = userDao.findById(1);
System.out.println(user1);
// sqlSession.close();
//再次获取SqlSession对象
// sqlSession = factory.openSession();
sqlSession.clearCache(); // 此方法也可以清空缓存
userDao = sqlSession.getMapper(UserDao.class);
User user2 = userDao.findById(1);
System.out.println(user2);
System.out.println(user1 == user2);
}
}
运行结果如图所示：
3 触发清空一级缓存的情况
1.在用户的持久层接口添加方法的代码如下：
package com.txw.dao;
import com.txw.domain.User;
import java.util.List;
/**
* 用户的持久层接口
* @author：Adair
* @QQ：1578533828
*/
@SuppressWarnings("all") // 注解警告信息
public interface UserDao {
/**
* 查询所有用户，同时获取到用户下所有账户的信息
* @return
*/
List<User> findAll();
/**
* 根据id查询用户信息
* @param userId
* @return
*/
User findById(Integer userId);
/**
* 更新用户信息
* @param user
*/
void updateUser(User user);
}
2.在UserDao.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.txw.dao.UserDao">
<!-- 查询所有 -->
<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>
3.编写测试的代码如下：
package com.txw.test;
import com.txw.dao.UserDao;
import com.txw.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;
/**
* User的测试
* @author：Adair
* @QQ：1578533828
*/
@SuppressWarnings("all") // 注解警告信息
public class UserTest {
private InputStream in;
private SqlSessionFactory factory;
private SqlSession sqlSession;
private UserDao userDao;
@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(UserDao.class);
}
@After // 用于在测试方法执行之后执行
public void destroy()throws Exception{
// 提交事务
//sqlSession.commit();
// 6.释放资源
sqlSession.close();
in.close();
}
/**
* 测试一级缓存
*/
@Test
public void testFirstLevelCache(){
User user1 = userDao.findById(1);
System.out.println(user1);
// sqlSession.close();
//再次获取SqlSession对象
// sqlSession = factory.openSession();
sqlSession.clearCache(); // 此方法也可以清空缓存
userDao = sqlSession.getMapper(UserDao.class);
User user2 = userDao.findById(1);
System.out.println(user2);
System.out.println(user1 == user2);
}
/**
* 测试缓存的同步
*/
@Test
public void testClearlCache(){
// 1.根据id查询用户
User user1 = userDao.findById(1);
System.out.println(user1);
// 2.更新用户信息
user1.setUsername("update user clear cache");
user1.setAddress("贵州省六盘水时");
userDao.updateUser(user1);
// 3.再次查询id为1的用户
User user2 = userDao.findById(1);
System.out.println(user2);
System.out.println(user1 == user2);
}
}
测试缓存的同步运行结果如图所示：
一级缓存是 SqlSession范围的缓存，当调用 SqlSession 的修改，添加，删除，commit()，close()等方法时，就会清空一级缓存。 
第一次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 1 的用户信息，如果没有，从数据库查询用户信息。
得到用户信息，将用户信息存储到一级缓存中。
如果 sqlSession去执行commit 操作（执行插入、更新、删除），清空 SqlSession 中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。
第二次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 1 的用户信息，缓存中有，直接从缓存中获取用户信息。
4 mybatis的二级缓存
二级缓存:
它指的是Mybatis中SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。
二级缓存的使用步骤：
第一步：让Mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）
第二步：让当前的映射文件支持二级缓存（在IUserDao.xml中配置）
第三步：让当前的操作支持二级缓存（在select标签中配置）
二级缓存的结构图：
首先开启 mybatis的二级缓存。
sqlSession1 去查询用户信息，查询到用户信息会将查询数据存储到二级缓存中。
如果 SqlSession3 去执行相同 mapper映射下 sql，执行 commit 提交，将会清空该 mapper 映射下的二级缓存区域的数据。
sqlSession2 去查询与 sqlSession1 相同的用户信息，首先会去缓存中找是否存在数据，如果存在直接从缓存中取出数据。
1.修改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.txw.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.txw.dao"></package>
</mappers>
</configuration>
2.修改IUserDao.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.txw.dao.UserDao">
<!--开启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>
3.编写测试的代码如下：
package com.txw.test;
import com.txw.dao.UserDao;
import com.txw.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;
/**
* User的测试二级缓存
* @author：Adair
* @QQ：1578533828
*/
@SuppressWarnings("all") // 注解警告信息
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();
UserDao dao1 = sqlSession1.getMapper(UserDao.class);
User user1 = dao1.findById(1);
System.out.println(user1);
sqlSession1.close();//一级缓存消失
SqlSession sqlSession2 = factory.openSession();
UserDao dao2 = sqlSession2.getMapper(UserDao.class);
User user2 = dao2.findById(1);
System.out.println(user2);
sqlSession2.close();
System.out.println(user1 == user2);
}
}
运行结果如图所示：
经过上面的测试，我们发现执行了两次查询，并且在执行第一次查询后，我们关闭了一级缓存，再去执行第二次查询时，我们发现并没有对数据库发出 sql语句，所以此时的数据就只能是来自于我们所说的二级缓存。
二级缓存的注意事项:
当我们在使用二级缓存时，所缓存的类一定要实现 java.io.Serializable 接口，这种就可以使用序列化方式来保存对象。
如果不是实现 java.io.Serializable接口，会报如下的错误！
org.apache.ibatis.cache.CacheException: Error serializing object. Cause: java.io.NotSerializableException: com.txw.domain.User
at org.apache.ibatis.cache.decorators.SerializedCache.serialize(SerializedCache.java:102)
at org.apache.ibatis.cache.decorators.SerializedCache.putObject(SerializedCache.java:56)
at org.apache.ibatis.cache.decorators.LoggingCache.putObject(LoggingCache.java:51)
at org.apache.ibatis.cache.decorators.SynchronizedCache.putObject(SynchronizedCache.java:45)
at org.apache.ibatis.cache.decorators.TransactionalCache.flushPendingEntries(TransactionalCache.java:122)
at org.apache.ibatis.cache.decorators.TransactionalCache.commit(TransactionalCache.java:105)
at org.apache.ibatis.cache.TransactionalCacheManager.commit(TransactionalCacheManager.java:44)
at org.apache.ibatis.executor.CachingExecutor.close(CachingExecutor.java:61)
at org.apache.ibatis.session.defaults.DefaultSqlSession.close(DefaultSqlSession.java:264)
at com.txw.test.SecondLevelCacheTest.testFirstLevelCache(SecondLevelCacheTest.java:42)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:26)
at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:27)
at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:33)
at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230)
at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58)
Caused by: java.io.NotSerializableException: com.txw.domain.User
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
at java.util.ArrayList.writeObject(ArrayList.java:766)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at java.io.ObjectStreamClass.invokeWriteObject(ObjectStreamClass.java:1155)
at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1496)
at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1432)
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1178)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
at org.apache.ibatis.cache.decorators.SerializedCache.serialize(SerializedCache.java:97)
... 33 more
扫一扫
1931
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
