文章目录
MyBatis缓存
分页
在Mybatis的配置文件中进行声明该插件：
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 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>
java
// 逻辑分页,减少对磁盘的读取,但是占用内存空间大
@Select("select * from student")
public List<Student> findStudentRowBounds(RowBounds rb);
// 分页插件(推荐)
@Select("select * from student")
public List<Student> findStudentPageHelper();方式1： 使用Map集合来保存分页需要数据，来进行分页
java
package mapper;
public interface StudentMapper {
// 物理分页,多次读取磁盘,占用内存小
@Select("select * from student limit #{cpage},#{size}")
public List<Student> selectLimit(@Param("cpage") int cpage, @Param("size") int size);
}
java
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集合来保存分页需要数据，来进行分页
java
package mapper;
public interface StudentMapper {
// 逻辑分页,减少对磁盘的读取,但是占用内存空间大
@Select("select * from student")
public List<Student> findStudentRowBounds(RowBounds rb);
}
java
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();
}
java
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
java
@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();测试类
java
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改为：
java
// 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
java
@Select("select * from student where sid=#{v}")
public Student findStudentBySid(int sid);测试类
情况1：
java
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对象
【发生了一级缓存失效】
java
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对象
【发生了一级缓存失效】
java
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
java
@Insert("insert into student(sname) values (#{sname})")
public int addStudent(Student s);
@Select("select * from student where sid=#{v}")
public Student findStudentBySid(int sid);
java
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
<?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
<?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)，表示这个接口中的所有查询都是二级缓存
java
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实体类
java
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工具类
java
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
java
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);
}测试类
java
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 缓存。
补充：
缓存击穿、雪崩、穿透
缓存击穿、雪崩、穿透