1.mybatis延迟加载策略
什么是延迟加载?
延迟加载就是在需要用到数据时才进行加载,不需要用到数据时就不加载数据。延迟加载也称懒加载.
好处: 先从单表查询,需要时再从关联表去关联查询,大大提高数据库性能,因为查询单表要比关联查询多张表速度要快。
坏处: 因为只有当需要用到数据时,才会进行数据库查询,这样在大批量数据查询时,因为查询工作也要消耗
时间,所以可能造成用户等待时间变长,造成用户体验下降。
开启懒加载
<settings>
<!-- 开启全局懒加载-->
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="aggressiveLazyLoading" value="false"/>
</settings>
association延迟加载
1.在IScoreDao接口中增加
List<Score> findAllScoreWithStudentLazy();
2.在IScoreDao.xml 中增加
<!-- 定义封装StudentScore和user的resultMap -->
<resultMap id="findAllScoreWithStudentLazyMap" type="Score">
<id property="scoreid" column="scoreid"></id>
<result property="coursename" column="coursename"></result>
<result property="score" column="score"></result>
<!-- 一对一的关系映射:配置封装Student的内容-->
<association property="student" javaType="Student"
select="com.wgz.dao.IStudentDao.findStudentById" column="studentid" fetchType="lazy">
</association>
</resultMap>
<select id="findAllScoreWithStudentLazy" resultMap="findAllScoreWithStudentLazyMap">
select * from score_tb;
</select>
select:为我们调用其他映射的id
column:为传递的参数
javaType:为查询到的java 数据类型
fetchType:是否使用懒加载,如果不设置与全局设置保持一致
3.测试
IScoreDao scoreDao = sqlSession.getMapper(IScoreDao.class);
List<Score> scoreList = scoreDao.findAllScoreWithStudentLazy();
for (Score score:scoreList){
// 不调用学生相关信息,不请求查数据库
System.out.println("score:"+score.getScore());
// 调用学生信息,发起二次请求查询学生相关的数据库
//System.out.println("student:"+score.getStudent());
}
collection延迟加载
1.在IStudentDao增加
/**
* 延迟加载学生的成绩
* @return
*/
List<Student> findAllStudentWithScoreListLazy();
2.在IStudentDao.xml 中增加
<!--
一对多懒加载
-->
<resultMap id="findAllStudentWithScoreListLazyMap" type="Student">
<id property="id" column="id"></id>
<result property="name" column="name"></result>
<result property="sex" column="name"></result>
<result property="age" column="age"></result>
<result property="height" column="height"></result>
<result property="birthday" column="birthday"></result>
<collection property="scoreList" column="id" select="com.wgz.dao.IScoreDao.findScoreByStudentId" fetchType="lazy">
</collection>
</resultMap>
<select id="findAllStudentWithScoreListLazy" resultMap="findAllStudentWithScoreListLazyMap">
select * from student_tb
</select>
3.测试
// 方式一 通过代理:
IStudentDao studentDao = sqlSession.getMapper(IStudentDao.class);
List<Student> studentList = studentDao.findAllStudentWithScoreListLazy();
for (Student student:studentList){
// 不调用学生成绩相关信息,不请求查数据库
System.out.println("Student:"+student.getName());
// 调用学生成绩信息,发起二次请求查询学生成绩相关的数据库
System.out.println("ScoreList:"+student.getScoreList());
}
2.mybatis的缓存
缓存是一般的ORM 框架都会提供的功能,目的就是提升查询的效率和减少数据库的压力。跟Hibernate 一样,MyBatis 也有一级缓存和二级缓存,并且预留了集成第三方缓存的接口。
一级缓存基于sqlSession,二级缓存基于namespace
一级缓存
一级缓存是 SqlSession 级别的缓存,只要 SqlSession 没有 flush 或 close,它就存在。一旦发生增删改,缓存立即失效
测试
IStudentDao studentDao = sqlSession.getMapper(IStudentDao.class);
// 两次查询操作,只有第一次调用sql
Student student = studentDao.findStudentById(45);
student = studentDao.findStudentById(45);
Student student1 = new Student();
student1.setName("xiaoming");
student1.setId(46);
student1.setSex("F");
// studentDao.updateStudent(student1);
// System.out.println("----------------");
//清空缓存
sqlSession.clearCache();
//当同一个session 发生了 增删改时 那么换粗立即失效 === sqlSession.clearCache();
student = studentDao.findStudentById(45);
二级缓存
二级缓存是 mapper 映射级别的缓存,多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句,多个
SqlSession 可以共用二级缓存,二级缓存是跨 SqlSession 的。
缓存流程图
二级缓存的开启
1.在mybatis开启
<settings>
<!--开启二级缓存-->
<setting name="cacheEnabled" value="true"/>
</settings>
2.在mapper 中开启二级缓存
<mapper namespace="com.wgz.dao.IStudentDao">
<!--开启二级缓存-->
<cache >
<property name="eviction" value="LRU" />
<property name="flushInterval" value="6000000" />
<property name="size" value="1024" />
<property name="readOnly" value="false" />
</cache>
</mapper>
-
-
eviction
- 缓存回收策略,有这几种回收策略
- LRU - 最近最少回收,移除最长时间不被使用的对象
- FIFO - 先进先出,按照缓存进入的顺序来移除它们
- SOFT - 软引用,移除基于垃圾回收器状态和软引用规则的对象
- WEAK - 弱引用,更积极的移除基于垃圾收集器和弱引用规则的对象
默认是 LRU 最近最少回收策略
flushinterval
缓存刷新间隔,缓存多长时间刷新一次,默认不清空,设置一个毫秒值readOnly
: 是否只读;true 只读,MyBatis 认为所有从缓存中获取数据的操作都是只读操作,不会修改数据。MyBatis 为了加快获取数据,直接就会将数据在缓存中的引用交给用户。不安全,速度快。读写(默认):MyBatis 觉得数据可能会被修改size
: 缓存存放多少个元素type
: 指定自定义缓存的全类名(实现Cache 接口即可)blocking
: 若缓存中找不到对应的key,是否会一直blocking,直到有对应的数据进入缓存。
3.使用缓存
<!--使用resultMap-->
<select id="findStudentById" parameterType="java.lang.Integer" resultType="student" useCache="true">
select * from student_tb where id=#{id}
</select>
4测试
// 3.获取session
SqlSession sqlSession1 = sqlSessionFactory.openSession();
// 4.使用sqlSession 创建代理对象
IStudentDao studentDao1 = sqlSession1.getMapper(IStudentDao.class);
Student student1 = studentDao1.findStudentById(45);
System.out.println("student1:"+student1);
//清空缓存
sqlSession1.close();
// 获取新的SqlSession 但是sql 语句没有执行,这是应为 可以去二级缓存去取,多个session 共享缓存
SqlSession sqlSession2 = sqlSessionFactory.openSession();
IStudentDao studentDao2 = sqlSession2.getMapper(IStudentDao.class);
Student student2=studentDao2.findStudentById(45);
System.out.println("student2:"+student2);
注意
-
一级二级缓存调用顺序:先查二级缓存,再查一级缓存,再查数据库;即使在一个sqlSession中,也会先查二级缓存;一个namespace中的查询更是如此;
-
使用二级缓存的实体类必须实现序列化;方便存储
3mybatis基于注解的开发
mybatis常用注解
@Insert:实现新增
@Update:实现更新
@Delete:实现删除
@Select:实现查询
@Result:实现结果集封装
@Results:可以与@Result 一起使用,封装多个结果集
@ResultMap:实现引用@Results 定义的封装
@One:实现一对一结果集封装
@Many:实现一对多结果集封装
@SelectProvider: 实现动态 SQL 映射
@CacheNamespace:实现注解二级缓存的使用
基于注解的增删改查
/**
* 查找所有学生
* @return
*/
@Select({"select * from student_tb"})
@Results(id = "studentMap",value = {@Result(id = true,property = "id",column = "id"),
@Result(property = "name",column = "name"),
@Result(property = "sex",column = "sex"),
@Result(property = "age",column = "age"),
@Result(property = "height",column = "height"),
@Result(property = "birthday",column = "birthday")
})
List<Student> findAllStudent();
/**
* 根据 查询学生
* @param id
* @return
*/
@Select("select * from student_tb where id = #{id}")
@ResultMap(value = "studentMap")
Student findStudentById(int id);
/**
* 保存学生
* @param student
*/
@Insert(" insert into student_tb (name,age,sex,height,birthday)values (#{name},#{age},#{sex},#{height},#{birthday})")
@SelectKey(keyColumn = "id",keyProperty = "id",resultType = Integer.class,before = false,statement = " select last_insert_id()")
int saveStudent(Student student);
/**
* 删除学生
* @param id
* @return
*/
@Delete("delete from student_tb where id = #{id}")
int deleteStudentById(int id);
/**
* 更新学生
* @param student
* @return
*/
@Update("update student_tb set name=#{name},age=#{age},height=#{height},sex=#{sex},birthday=#{birthday} where id=#{id}")
int updateStudent(Student student);
/**
* 根据名称模糊查询
* @param likeName
* @return
*/
@Select(" select * from student_tb where name like #{likeName}")
@ResultType(Student.class)
List<Student> findStudentListByName(String likeName);
复杂映射的开发
@Results 注解
代替的是标签<resultMap>
该注解中可以使用单个@Result 注解,也可以使用@Result 集合
@Results({@Result(), @Result() })或@Results(@Result())
@Resutl 注解
代替了 <id>标签和<result>标签
@Result 中 属性介绍:
id 是否是主键字段
column 数据库的列名
property 需要装配的属性名
one 需要使用的@One 注解(@Result(one=@One)()))
many 需要使用的@Many 注解(@Result(many=@many)()))
@One 注解(一对一)
代替了<assocation>标签,是多表查询的关键,在注解中用来指定子查询返回单一对象。
@One 注解属性介绍:
select 指定用来多表查询的 sqlmapper
fetchType 会覆盖全局的配置参数 lazyLoadingEnabled。。
使用格式:
@Result(column=" ",property="",one=@One(select=""))
@Many 注解(多对一)
代替了<Collection>标签,是是多表查询的关键,在注解中用来指定子查询返回对象集合。
注意:聚集元素用来处理“一对多”的关系。需要指定映射的 Java 实体类的属性,属性的 javaType
(一般为 ArrayList)但是注解中可以不定义;
使用格式:
@Result(property="",column="",many=@Many(select=""))
一对一复杂关系映射
IScoreDao2的注解配置,使用one代替assocation
public interface IScoreDao2 {
@Select("select * from score_tb where studentid = #{studentid}")
@ResultType(Score.class)
Score findScoreById(int studentid);
@Select("select * from score_tb")
@Results(id = "scoreMap1",value = {
@Result(id = true,property = "scoreid",column ="scoreid" ),
@Result(property = "coursename",column ="coursename" ),
@Result(property = "score",column ="score" ),
@Result(property = "student",column = "studentid",one = @One(select = "com.wgz.dao.IStudentDao.findStudentById",fetchType = FetchType.LAZY))
})
List<Score> findAllScoreWithStudentOne();
}
一对多注解式懒加载
IStudentDao2配置
@Select("select * from student_tb")
@Results(id = "studentMap2",value = {@Result(id = true,property = "id",column = "id"),
@Result(property = "sex",column = "sex"),
@Result(property = "age",column = "age"),
@Result(property = "height",column = "height"),
@Result(property = "birthday",column = "birthday"),
@Result(property = "scoreList",column = "id",many = @Many(select = "com.wgz.dao.IScoreDao2.findScoreById",fetchType = FetchType.LAZY)),
})
List<Student> findAllStudentWithScoreList();
注解式开启缓存
// 开启缓存
@CacheNamespace(blocking = true)
olumn = “age”),
@Result(property = “height”,column = “height”),
@Result(property = “birthday”,column = “birthday”),
@Result(property = “scoreList”,column = “id”,many = @Many(select = “com.wgz.dao.IScoreDao2.findScoreById”,fetchType = FetchType.LAZY)),
})
List findAllStudentWithScoreList();
### 注解式开启缓存
// 开启缓存
@CacheNamespace(blocking = true)