文章目录
MyBatis缓存
分页
在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 resource="jdbc.properties"></properties>
<typeAliases>
<!-- 给单个类起别名 -->
<!-- <typeAlias alias="Student" type="bean.Student"/> -->
<!-- 批量别名定义,包扫描,别名为类名,扫描整个包下的类 -->
<package name="bean" />
</typeAliases>
<!-- 分页插件 -->
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<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>
<mappers>
<!-- 注册sqlmapper文件 -->
<!-- 1.同包 接口和sqlMapper 2.同名 接口和sqlMapper 3.sqlMapper的namespace指向接口的类路径 -->
<!-- <mapper resource="mapper/StudentMapper.xml" /> -->
<!-- <mapper class="mapper.StudentMapper"/> -->
<package name="mapper" />
</mappers>
</configuration>
// 逻辑分页,减少对磁盘的读取,但是占用内存空间大
@Select("select * from student")
public List<Student> findStudentRowBounds(RowBounds rb);
// 分页插件(推荐)
@Select("select * from student")
public List<Student> findStudentPageHelper();
方式1： 使用Map集合来保存分页需要数据，来进行分页
package mapper;
public interface StudentMapper {
// 物理分页,多次读取磁盘,占用内存小
@Select("select * from student limit #{cpage},#{size}")
public List<Student> selectLimit(@Param("cpage") int cpage, @Param("size") int size);
}
package test;
public class Test01 {
public static void main(String[] args) {
SqlSession sqlSession = DaoUtil.getSqlSession();
StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
List<Student> list = studentMapper.selectLimit((1 - 1) * 3, 3);
list.forEach(System.out::println);
DaoUtil.closeSqlSession(sqlSession);
}
}
方式2： 使用RowBounds集合来保存分页需要数据，来进行分页
package mapper;
public interface StudentMapper {
// 逻辑分页,减少对磁盘的读取,但是占用内存空间大
@Select("select * from student")
public List<Student> findStudentRowBounds(RowBounds rb);
}
package test;
public class Test01 {
public static void main(String[] args) {
SqlSession sqlSession = DaoUtil.getSqlSession();
StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
RowBounds rb = new RowBounds((1 - 1) * 3, 3);
List<Student> list = studentMapper.findStudentRowBounds(rb);
list.forEach(System.out::println);
DaoUtil.closeSqlSession(sqlSession);
}
}
方式3： 使用分页插件来进行分页【推荐】
package mapper;
public interface StudentMapper {
// 分页插件(推荐)
@Select("select * from student")
public List<Student> findStudentPageHelper();
}
package test;
public class Test01 {
public static void main(String[] args) {
SqlSession sqlSession = DaoUtil.getSqlSession();
StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
// PageHelper分页插件
// (页码,每页多少个)
// 分页第一页少做一次计算,sql语句也不同
Page<Object> page = PageHelper.startPage(10, 1);
// 获取page对象
System.out.println(page);
List<Student> list = studentMapper.findStudentPageHelper();
// 详细分页对象
PageInfo<Student> pageinfo = new PageInfo<Student>(list, 10);
System.out.println(pageinfo);
list.forEach(System.out::println);
DaoUtil.closeSqlSession(sqlSession);
}
}
延迟加载和立即加载
什么是立即加载？
立即加载是： 不管用不用信息，只要调用，马上发起查询并进行加载
比如： 当我们查询学生信息时，就需要知道学生在哪个班级中，所以就需要立马去查询班级的信息
通常：当 一对一或者 多对一 的时候需要立即加载
什么是延迟加载？
延迟加载是： 在真正使用数据时才发起查询，不用的时候不查询，按需加载（也叫 懒加载）
比如： 在查询班级信息，每个班级都会有很多的学生（假如每个班有100个学生），如果我们只是查看 班级信息，但是学生对象也会加载到内存中，会造成浪费。 所以我门需要进行懒加载，当确实需要查看班级中的学生信息，我门在进行加载班级中的学生信息。
通常： 一对多，或者多对多的是需要使用延迟加载
延迟加载/懒加载的配置
如果设置 lazyLoadingEnabled = false，则禁用延迟加载，会级联加载所有关联对象的数据
如果设置 lazyLoadingEnabled = true，默认情况下mybatis 是按层级延时加载的。
aggressiveLazyLoading = true，mybatis 是按层级延时加载 aggressiveLazyLoading = false，mybatis 按需求加载。
延迟加载的sqlmap
实现：
StudentMapper
@Results({ @Result(column = "classid", property = "classid"),
@Result(column = "classid", property = "clazz", one = @One(select = "mapper.ClazzMapper.selectAll")) })
@Select("select * from student")
public List<Student> findStudentAndClassid();
测试类
public class Test02 {
public static void main(String[] args) {
SqlSession sqlSession = DaoUtil.getSqlSession();
StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
List<Student> list = studentMapper.findStudentAndClassid();
Student stu = list.get(0);
System.out.println(stu);
// list.forEach(System.out::println);
DaoUtil.closeSqlSession(sqlSession);
}
}
发现这里执行了多条sql，但是我只需要List集合中第一个学生的所有数据
这里就需要进行懒加载！
将上面的StudentMapper改为：
// mybatis底层默认立即加载
// FetchType.DEFAULT 从配置文件进行读取加载
// FetchType.EAGER 立即加载
// FetchType.LAZY 延迟加载，懒加载
@Results({ @Result(column = "classid", property = "classid"),
@Result(column = "classid", property = "clazz", one = @One(select = "mapper.ClazzMapper.selectAll", fetchType = FetchType.LAZY)) })
@Select("select * from student")
public List<Student> findStudentAndClassid();
就解决了查询一个Student而执行了多条SQL的问题
缓存
什么是缓存？
缓存（cache），数据交换的缓冲区，当应用程序需要读取数据时，先从数据库中将数据取出，放置在缓冲区中，应用程序从缓冲区读取数据。
特点：数据库取出的数据保存在内存中，具备快速读取和使用。
限制：读取时无需再从数据库获取，数据可能不是最新的；导致数据不一致性。
缓存的术语
针对缓存数据：
命中 需要的数据在缓存中找到结果。
未命中 需要的数据在缓存中未找到，重新获取。
什么是MyBatis 缓存？
功能 减少Java Application 与数 据库的交互次数，从而提升程 序的运行效率；
方式 通过配置和定制。
缓存的适用性
适合使用缓存： 经常查询并且不经常改变的 数据的正确与否对最终结果影响不大的 比如：一个公司的介绍，新闻等
不适合用于缓存： 经常改变的数据 数据的正确与否对最终结果影响很大 比如商品的库存，股市的牌价等
缓存的分类
一级缓存
将数据放在SqlSession对象中，一般默认开启一级缓存
引入案例
StudentMapper
@Select("select * from student where sid=#{v}")
public Student findStudentBySid(int sid);
测试类
情况1：
SqlSession sqlSession = DaoUtil.getSqlSession();
StudentMapper stuMapper = sqlSession.getMapper(StudentMapper.class);
Student s1 = stuMapper.findStudentBySid(10);
System.out.println(s1);
System.out.println();
Student s2 = stuMapper.findStudentBySid(10);
System.out.println(s1 == s2);//true
DaoUtil.closeSqlSession(sqlSession);
从同一个SqlSession的一级缓存中拿的Student是同一个对象
情况2:从两个SqlSession的一级缓存中查询同一个对象，返回的不是同一个Student对象
【发生了一级缓存失效】
SqlSession sqlSession1 = DaoUtil.getSqlSession();
StudentMapper stuMapper1 = sqlSession1.getMapper(StudentMapper.class);
Student s1 = stuMapper1.findStudentBySid(10);
System.out.println(s1);
for (int i = 0; i < 100; i++) {
System.out.print(".");
}
System.out.println();
SqlSession sqlSession2 = DaoUtil.getSqlSession();
StudentMapper stuMapper2 = sqlSession2.getMapper(StudentMapper.class);
Student s2 = stuMapper2.findStudentBySid(10);
System.out.println(s2);
System.out.println(s1 == s2);// false
情况3:
清空SQLSession后，查询的不是同一个Student对象
【发生了一级缓存失效】
SqlSession sqlSession = DaoUtil.getSqlSession();
StudentMapper stuMapper = sqlSession.getMapper(StudentMapper.class);
Student s1 = stuMapper.findStudentBySid(10);
System.out.println(s1);
for (int i = 0; i < 100; i++) {
System.out.print(".");
}
System.out.println();
sqlSession.clearCache();//清空SqlSession()
Student s2 = stuMapper.findStudentBySid(10);
System.out.println(s2);
System.out.println(s1 == s2);// false
DaoUtil.closeSqlSession(sqlSession);
关闭sqlsession 或者清空sqlsession缓存都可以实现
注意：当调用sqlsession的修改，添加，删除，commit（），close（） 等方法时， 就会清空一级缓存
一级缓存的配置
一级缓存的工作流程
一级缓存失效的情况
1.不同SqlSession对应不同的一级缓存
2.同一个SqlSession单查询条件不同
3.同一个SqlSession两次查询期间执行了任何一次增删改操作
4.同一个SqlSession两次查询期间手动清空了缓存
案例：
MappertStudent
@Insert("insert into student(sname) values (#{sname})")
public int addStudent(Student s);
@Select("select * from student where sid=#{v}")
public Student findStudentBySid(int sid);
package test;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import bean.Student;
import dao.DaoUtil;
import mapper.StudentMapper;
public class Test03 {
public static void main(String[] args) {
SqlSession sqlSession = DaoUtil.getSqlSession();
StudentMapper stuMapper = sqlSession.getMapper(StudentMapper.class);
Student s1 = stuMapper.findStudentBySid(10);
System.out.println(s1);
for (int i = 0; i < 100; i++) {
System.out.print(".");
}
stuMapper.addStudent(new Student());
System.out.println();
// sqlSession.clearCache();//清空SqlSession()
Student s2 = stuMapper.findStudentBySid(10);
System.out.println(s2);
System.out.println(s1 == s2);// false
}
}
这里在两个查询之间进行了插入insert数据操作，就使一级缓存失效了，第二次查询的数据不是从缓存中拿，而是从数据库中去查询。
二级缓存
二级缓存就是在SqlSessionFactory，然后通过同一个Factory工厂，去获得相同的Cache，通过namespace去拿到对应的Student对象
XML实现
在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 resource="jdbc.properties"></properties>
<settings>
<!-- 全局启用或者禁用延迟加载
<setting name=" lazyLoadingEnabled" value="true" />
当启用时有延迟加载属性的对象会在被调用时按需进行加载，如果设置为false,会按层级进行延迟加载,默认为true
<setting name=" aggressiveLazyLoading" value="true" /> -->
<setting name="cacheEnabled" value="true"/>
</settings>
<typeAliases>
<!-- 给单个类起别名 -->
<!-- <typeAlias alias="Student" type="bean.Student"/> -->
<!-- 批量别名定义,包扫描,别名为类名,扫描整个包下的类 -->
<package name="bean" />
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<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>
<mappers>
<!-- 注册sqlmapper文件 -->
<!-- 1.同包 接口和sqlMapper 2.同名 接口和sqlMapper 3.sqlMapper的namespace指向接口的类路径 -->
<!-- <mapper resource="mapper/StudentMapper.xml" /> -->
<!-- <mapper class="mapper.StudentMapper"/> -->
<package name="mapper" />
</mappers>
</configuration>
step1:
设置为true
<settings>
<!-- 全局启用或者禁用延迟加载
<setting name=" lazyLoadingEnabled" value="true" />
当启用时有延迟加载属性的对象会在被调用时按需进行加载，如果设置为false,会按层级进行延迟加载,默认为true
<setting name=" aggressiveLazyLoading" value="true" /> -->
<setting name="cacheEnabled" value="true"/>
</settings>
step2:
表明这个映射文件开启了二级缓存
<cache/>
step3:
useCache="true"表明这条查询用到了二级缓存
<select id="findStudent" parameterType="int"
resultType="student" useCache="true">
select * from student where sid = #{value}
</select>
注解实现
step1:
<?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="jdbc.properties"></properties>
<settings>
<!-- 全局启用或者禁用延迟加载
<setting name=" lazyLoadingEnabled" value="true" />
<setting name=" aggressiveLazyLoading" value="true" /> -->
<setting name="cacheEnabled" value="true"/>
</settings>
<typeAliases>
<!-- 给单个类起别名 -->
<!-- <typeAlias alias="Student" type="bean.Student"/> -->
<!-- 批量别名定义,包扫描,别名为类名,扫描整个包下的类 -->
<package name="bean" />
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<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>
<mappers>
<!-- 注册sqlmapper文件 -->
<!-- 1.同包 接口和sqlMapper 2.同名 接口和sqlMapper 3.sqlMapper的namespace指向接口的类路径 -->
<!-- <mapper resource="mapper/StudentMapper.xml" /> -->
<!-- <mapper class="mapper.StudentMapper"/> -->
<package name="mapper" />
</mappers>
</configuration>
step2:
在接口前面加上@CacheNamespace(blocking = true)，表示这个接口中的所有查询都是二级缓存
package mapper;
//让此处的所有内容都为二级缓存
@CacheNamespace(blocking = true)
public interface StudentMapper {
@Select("select * from student where sid=#{v}")
public Student findStudentBySid(int sid);
}
案例：
说明使用到了二级缓存，需要实体类实现序列化接口
序列化后的两个student对象不是同一个对象，二级缓存的数据存在磁盘上。
二级缓存的缺点
当数据库服务器和客户端是通过网络传输的，这里用二级缓存是为了减少由于网络环境不好加载时间。主要是为了解决数据库不在本机，且网络不稳定带来的问题,但是现在不推荐使用
1.Mybatis 的二级缓存相对于一级缓存来说， 实现了缓存数据的共享，可控性也更强；
2.极大可能会出现错误数据，有设计上的缺陷， 安全使用的条件比较苛刻；
3.分布式环境下，必然会出现读取到错误 数据，所以不推荐使用。
分布式就是同一个数据库连接多台服务器，给多个用户服务。二级缓存在分布式情况下必然会出错，二级缓存绝对不可能用。
但是现在基本不用，弊端如下：
案例完整代码：
bean.Student实体类
package bean;
import java.io.Serializable;
import java.util.Date;
public class Student implements Serializable{
private int sid;
private String sname;
private Date birthday;
private String Ssex;
private int classid;
private Clazz clazz;
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getSsex() {
return Ssex;
}
public void setSsex(String ssex) {
Ssex = ssex;
}
public int getClassid() {
return classid;
}
public void setClassid(int classid) {
this.classid = classid;
}
public Clazz getClazz() {
return clazz;
}
public void setClazz(Clazz clazz) {
this.clazz = clazz;
}
public Student(int sid, String sname, Date birthday, String ssex, int classid, Clazz clazz) {
super();
this.sid = sid;
this.sname = sname;
this.birthday = birthday;
Ssex = ssex;
this.classid = classid;
this.clazz = clazz;
}
public Student() {
super();
}
@Override
public String toString() {
return "Student [sid=" + sid + ", sname=" + sname + ", birthday=" + birthday + ", Ssex=" + Ssex + ", classid="
+ classid + ", clazz=" + clazz + "]";
}
}
Daoutil工具类
package dao;
import java.io.IOException;
import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
public class DaoUtil {
static SqlSessionFactory factory = null;
static {
try {
// 1.读取配置文件
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
// 2.生产sqlSession的工厂
factory = new SqlSessionFactoryBuilder().build(is);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static SqlSession getSqlSession() {
// 3.返回sqlSession对象
return factory.openSession();
}
public static void closeSqlSession(SqlSession sqlSession) {
// 4.释放资源
sqlSession.close();
}
}
StudentMapper
package mapper;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.CacheNamespace;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.DeleteProvider;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.InsertProvider;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Options;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.SelectProvider;
import org.apache.ibatis.annotations.Update;
import org.apache.ibatis.annotations.UpdateProvider;
import org.apache.ibatis.jdbc.SQL;
import org.apache.ibatis.mapping.FetchType;
import org.apache.ibatis.session.RowBounds;
import bean.Student;
//让此处的所有内容都为二级缓存
@CacheNamespace(blocking = true)
public interface StudentMapper {
@Insert("insert into student(sname) values (#{sname})")
public int addStudent(Student s);
// 物理分页,多次读取磁盘,占用内存小
@Select("select * from student limit #{cpage},#{size}")
public List<Student> selectLimit(@Param("cpage") int cpage, @Param("size") int size);
// 逻辑分页,减少对磁盘的读取,但是占用内存空间大
@Select("select * from student")
public List<Student> findStudentRowBounds(RowBounds rb);
// 分页插件(推荐)
@Select("select * from student")
public List<Student> findStudentPageHelper();
// mybatis底层默认立即加载
// FetchType.DEFAULT 从配置文件进行读取加载
// FetchType.EAGER 立即加载
// FetchType.LAZY 延迟加载，懒加载
@Results({ @Result(column = "classid", property = "classid"),
@Result(column = "classid", property = "clazz", one = @One(select = "mapper.ClazzMapper.selectAll", fetchType = FetchType.LAZY)) })
@Select("select * from student")
public List<Student> findStudentAndClassid();
@Select("select * from student where sid=#{v}")
public Student findStudentBySid(int sid);
}
测试类
package test;
import org.apache.ibatis.session.SqlSession;
import bean.Student;
import dao.DaoUtil;
import mapper.StudentMapper;
public class Test04 {
public static void main(String[] args) {
SqlSession sqlSession1 = DaoUtil.getSqlSession();
StudentMapper stuMapper1 = sqlSession1.getMapper(StudentMapper.class);
Student s1 = stuMapper1.findStudentBySid(10);
System.out.println(s1);
DaoUtil.closeSqlSession(sqlSession1);
SqlSession sqlSession2 = DaoUtil.getSqlSession();
StudentMapper stuMapper2 = sqlSession2.getMapper(StudentMapper.class);
Student s2 = stuMapper2.findStudentBySid(10);
System.out.println(s1);
DaoUtil.closeSqlSession(sqlSession2);
}
}
自定义缓存的分类
总结(面试题汇总)：
一级缓存和二级缓存的区别：
一级缓存指的是一个对象存到了SqlSession里面了，它是内存式的缓存，写在内存上的
二级缓存指的是缓存在SqlSessionFactory里面了，它是写在磁盘上的
二级缓存不用的原因：
分布式环境下，必然会出现读取到错误 数据，所以不推荐使用。
分页查询
• 什么是缓存
• 数据交换的缓冲区，当应用程序需要读取数据时，先从数据库中将数据取出，放置在缓冲区中，应用程序从缓冲区读取数据；
• 什么是一级缓存
• 相对同一个 SqlSession 对象而言的缓存；
• 什么是二级缓存
• 一个 namespace 下的所有操作语句，都影响着同一个Cache；
• 自定义缓存的方式
• 实现 org. apache. ibatis. cache. Cache 接口自定义缓存；
• 引入 Redis 等第三方内存库作为 MyBatis 缓存。
补充：
缓存击穿、雪崩、穿透
缓存击穿、雪崩、穿透
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
