Mybatis从浅入深-Plus（IDEA版通俗易懂）
每个成功者都有一个开始。敢于开始，才能找到成功的路。你好，我是梦阳辰！期待与你相遇！java
01.使用注解开发
引入：
你们以前都学过面向对象编程，也学习过接口，但在真正的开发中，不少时候咱们会选择面向接口编程spring
根本缘由∶解耦，可拓展，提升复用，分层开发中，上层不用管具体的实现，你们都遵照共同的标准，使得开发变得容易，规范性更好sql
在一个面向对象的系统中，系统的各类功能是由许许多多的不一样对象协做完成的。在这种状况下，各个对象内部是如何实现本身的,对系统设计人员来说就不那么重要了;数据库
而各个对象之间的协做关系则成为系统设计的关键。小到不一样类之间的通讯，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工做内容。面向接口编程就是指按照这种思想来编程。
关于接口的理解apache
接口从更深层次的理解，应是定义(规范，约束）与实现(名实分离的原则）的分离。-接口的自己反映了系统设计人员对系统的抽象理解。编程
接口应有两类:缓存
第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class);安全
第二类是对一个个体某一方面的抽象，即造成一个抽象面(interface) ;session
一个体有可能有多个抽象面。抽象体与抽象面是有区别的。
三个面向的区别：
面向对象是指，咱们考虑问题时，以对象为单位，考虑它的属性及方法．
面向过程是指，咱们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现．
接口设计与非接口设计是针对复用技术而言的，与面向对象(过程)不是一个问题.更多的体现就是对系统总体的架构
使用注解开发：
它们映射的语句能够不用 XML 来配置，而可使用 Java 注解来配置。好比，上面的 XML 示例能够被替换成以下的配置：
package org.mybatis.example;public interface BlogMapper {
@Select("SELECT * FROM blog WHERE id = #{id}")
Blog selectBlog(int id);}
使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不只力不从心，还会让你本就复杂的 SQL 语句更加混乱不堪。 所以，若是你须要作一些很复杂的操做，最好用 XML 来映射语句。
选择何种方式来配置映射，以及认为是否应该要统一映射语句定义的形式，彻底取决于你和你的团队。 换句话说，永远不要拘泥于一种方式，你能够很轻松的在基于注解和 XML 的语句映射方式间自由移植和切换。
1.注解在接口上实现
**
* 接口操做user表 */public interface UserMapper {
@Select("select * from user")
List<User> selectUser();}
2.须要在核心配置文件中绑定接口。
<!--绑定接口--> <mappers> <mapper class="com.mengyangchen.dao.UserMapper"/> </mappers>
测试：
@Test
public void test(){
//1.获取SqlSession对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
//方式一：getMapper
//2.执行sql,获取sql,面向接口编程，获取UserMapper接口（之前是实现接口的实现类，如今是配置文件）
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = mapper.selectUser();
/*String sqlId = "com.mengyangchen.dao.UserDao"+"."+"selectUser";
List<User> userList = sqlSession.selectList(sqlId);*/
for(User user:userList){
System.out.println(user);
}
//3.关闭SqlSession
sqlSession.close();
}
本质：反射机制实现
底层：动态代理。
Mybatis详细的执行流程
多debug，多看底层源码。
注解完成增删改查
接口：
//方法存在多个参数，全部的参数前面必须加上@Param("id")注解,引用对象不须要写
@Select("select * from user where id=#{id}")
User selectUserById(@Param("id") int id);
@Insert("insert into user(id,name,pwd) values(#{id},#{name},#{password})")
int insertUser(User user);
测试：
@Test
public void selectUserById(){
//1.获取SqlSession对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
//方式一：getMapper
//2.执行sql,获取sql,面向接口编程，获取UserMapper接口（之前是实现接口的实现类，如今是配置文件）
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = mapper.selectUserById(1);
System.out.println(user);
sqlSession.close();
}
@Test
public void insertUser(){
//1.获取SqlSession对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
//方式一：getMapper
//2.执行sql,获取sql,面向接口编程，获取UserMapper接口（之前是实现接口的实现类，如今是配置文件）
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int num = mapper.insertUser(new User(3,"meng","123456"));
if(num>0){
System.out.println("插入成功！");
}
sqlSession.commit();
sqlSession.close();
}
#{},${}的区别
#{}能够防止sql注入。
02.Lombok
Lombok项目是一个Java库，它会自动插入您的编辑器和构建工具中，从而使您的Java更加生动有趣。
永远不要再写另外一个getter或equals方法，带有一个注释的您的类有一个功能全面的生成器，自动化您的日志记录变量等等。
Lombok是一款Java开发插件，使得Java开发者能够经过其定义的一些注解来消除业务工程中冗长和繁琐的代码，尤为对于简单的Java模型对象(POJO)。在开发环境中使用Lombok插件后，Java开发人员能够节省出重复构建，诸如hashCode和equals这样的方法以及各类业务对象模型的accessor和ToString等方法的大量时间。对于这些方法，它可以在编译源代码期间自动帮咱们生成这些方法，并无如反射那样下降程序的性能。
使用步骤：
1.在idea中安装Lombok插件
2.在项目中导入Lombokjar包
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok --><dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.12</version> <scope>provided</scope></dependency>
Lombok含有的注解：
@Getter and @Setter@FieldNameConstants@ToString@EqualsAndHashCode@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog@Data@Builder@SuperBuilder@Singular@Delegate@Value@Accessors@Wither@With@SneakyThrows@val@var
结果：
import lombok.Data;@Datapublic class User {
private Integer id;
private String name;
private String password;
}
自动帮咱们写了getter或equals等方法。
@Data:无参构造，get,set,toString,hashcode,equals
无参和全部参数：
注意：了解便可。
03.多对一处理
多个学生，对应一个老师。
对于学生而言：关联…
多个学生关联一个老师（多对一）
对于老师而言：
集合
一个老师，有不少学生（一对多）
多对一：
实体类
public class Student {
private Integer id;
private String name;
//学生须要关联一个老师
private Teacher teacher;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Teacher getTeacher() {
return teacher;
}
public void setTeacher(Teacher teacher) {
this.teacher = teacher;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", teacher=" + teacher +
'}';
}}
public class Teacher {
private Integer id;
private String name;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Teacher{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}}
环境搭建:
1.新建实体类Teacher,Student
2.创建Mapper接口
3.创建Mapper.xml文件
4.在核心配置文件中绑定注册咱们的mapper接口或者文件。
5.测试是否成功。
public interface TeacherMapper {
@Select("select * from teacher where id=#{tid}")
Teacher selectTeacherById(@Param("tid") int id);}
<mappers> <mapper class="com.mengyangchen.dao.TeacherMapper"/> <mapper class="com.mengyangchen.dao.StudentMapper"/></mappers>
public class MyTest {
@Test
public void test(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
Teacher teacher = mapper.selectTeacherById(1);
System.out.println(teacher);
sqlSession.close();
}}
嵌套查询(按照查询嵌套处理）（子查询）：
select语句的嵌套。
这里测试的时候出现异常：
org.apache.ibatis.binding.bindingexception: invalid bound statement (not found)
问题出在：我在建立包的时候
采用的是：
com.mengyangchen.dao
改成一个一个的建立便可。
<?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"><!--绑定一个对应的Dao/Mapper接口--><!--之前是写一个类实现Dao接口，如今绑定便可--><mapper namespace="com.mengyangchen.dao.StudentMapper"><!--sql语句嵌套思路： 1.查询全部的学生信息 2.根据查询出来的学生的tid,寻找对应的老师-->
<resultMap id="studentTeacher" type="student">
<result property="id" column="id"/>
<result property="name" column="name"/>
<!--复杂的属性，咱们须要单独处理 对象association 集合collection-->
<association property="teacher" column="tid" javaType="Teacher" select="selectTeacherById"/>
</resultMap><select id="selectStudentInfo" resultMap="studentTeacher">
select * from student</select>
<select id="selectTeacherById" resultType="teacher">
select * from teacher where id=#{id}
</select></mapper>
结果：
联表查询（按照结果嵌套处理）：
<?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"><!--绑定一个对应的Dao/Mapper接口--><!--之前是写一个类实现Dao接口，如今绑定便可--><mapper namespace="com.mengyangchen.dao.StudentMapper"><!--sql语句嵌套思路： 1.查询全部的学生信息 2.根据查询出来的学生的tid,寻找对应的老师--> <resultMap id="studentTeacher" type="student"> <result property="id" column="id"/> <result property="name" column="name"/> <!--复杂的属性，咱们须要单独处理 对象association 集合collection--> <association property="teacher" column="tid" javaType="Teacher"> <result property="name" column="teacherName"/> </association> </resultMap><select id="selectStudentInfo" resultMap="studentTeacher"> select s.id id, s.name name,t.name teacherName from student s inner join teacher t on s.tid = t.id</select></mapper>
测试:
@Test
public void studentTest(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
List<Student> list = mapper.selectStudentInfo();
for (Student student:list) {
System.out.println(student);
}
sqlSession.close();
}
04.一对多处理
一个老师对应多个学生
对于老师而言就是一对多。
实体类：
public class Teacher {
private Integer id;
private String name;
//一个老师有多个学生
private List<Student> student;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Student> getStudent() {
return student;
}
public void setStudent(List<Student> student) {
this.student = student;
}
@Override
public String toString() {
return "Teacher{" +
"id=" + id +
", name='" + name + '\'' +
", student=" + student +
'}';
}}
public class Student {
private Integer id;
private String name;
private Integer tid;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getTid() {
return tid;
}
public void setTid(Integer tid) {
this.tid = tid;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", tid=" + tid +
'}';
}}
接口：
public interface TeacherMapper {
Teacher selectTeacherById(@Param("tid") int id);}
配置文件：
<?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"><!--绑定一个对应的Dao/Mapper接口--><!--之前是写一个类实现Dao接口，如今绑定便可--><mapper namespace="com.mengyangchen.dao.TeacherMapper"> <!--查询语句--> <!--id相对于之前的书写，表示重写的方法名（之前在方法中执行链接数据库等操做，如今不须要了，只须要执行sql--> <!--resultType返回结果--> <!--按照结果嵌套查询--><select id="selectTeacherById" resultMap="teacherStudent"> select s.id id, s.name name,t.name teacherName from student s inner join teacher t on s.tid = t.id</select> <resultMap id="teacherStudent" type="teacher"> <result property="name" column="teacherName"/> <collection property="student" ofType="Student"> <result property="id" column="id"/> <result property="name" column="name"/> </collection> </resultMap></mapper>
05.动态sql
动态 SQL 是 MyBatis 的强大特性之一。若是你使用过 JDBC 或其它相似的框架，你应该能理解根据不一样条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，能够完全摆脱这种痛苦。
若是你以前用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 SQL 元素可能会感受似曾相识。在 MyBatis 以前的版本中，须要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了以前的大部分元素，大大精简了元素种类，如今要学习的元素种类比原来的一半还要少。
ifchoose (when, otherwise)trim (where, set)foreach
使用动态 SQL 最多见情景是根据条件包含 where 子句的一部分。好比：
<select id="findActiveBlogWithTitleLike"
resultType="Blog">
SELECT * FROM BLOG
WHERE state = ‘ACTIVE’ <if test="title != null">
AND title like #{title}
</if></select>
动态sql之if
实现根据不一样条件查询数据！
实体类：
package com.mengyangchen.pojo;import java.util.Date;public class Blog {
private String id;
private String title;
private String author;
private Date createTime;//属性名和字段名不一致
private Integer views;
public Blog() {
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Integer getViews() {
return views;
}
public void setViews(Integer views) {
this.views = views;
}
@Override
public String toString() {
return "Blog{" +
"id=" + id +
", title='" + title + '\'' +
", author='" + author + '\'' +
", createTime=" + createTime +
", views=" + views +
'}';
}}
接口：
package com.mengyangchen.dao;import com.mengyangchen.pojo.Blog;import java.util.List;import java.util.Map;public interface BlogMapper {
/*插入数据*/
int insertBlog(Blog blog);
/*查询博客*/
List<Blog> queryBlogIf(Map map);}
配置文件：
<?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.mengyangchen.dao.BlogMapper">
<insert id="insertBlog" parameterType="blog">
insert into mybatis.blog (id,title,author,create_time,views) values (#{id},#{title},#{author},#{createTime},#{views});
</insert>
<select id="queryBlogIf" parameterType="map" resultType="blog">
select * from mybatis.blog where 1=1
<if test="title !=null">
and title like "%"#{title}"%"
</if>
<if test="author != null">
and author like "%"#{author}"%"
</if>
</select></mapper>
属性名和字段名不一致，一个是下划线，一个为驼峰。
<?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="db.properties">
<property name="username" value="root"/><!--一配置文件中为准-->
<property name="password" value="123456"/>
</properties>
<!--标准日志实现-->
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
<!--是否开启自动驼峰命名规则映射-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
<!--别名-->
<typeAliases>
<package name="com.mengyangchen.pojo"/>
</typeAliases>
<environments default="development">
<environment id="development">
<!--事务管理-->
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/><!--&是xml的转义字符（即为&）-->
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments><mappers>
<mapper class="com.mengyangchen.dao.BlogMapper"/></mappers></configuration>
动态sql之trim (where, set)
前面几个例子已经方便地解决了一个臭名昭著的动态 SQL 问题。如今回到以前的 “if” 示例，此次咱们将 “state = ‘ACTIVE’” 设置成动态条件，看看会发生什么。
<select id="findActiveBlogLike"
resultType="Blog">
SELECT * FROM BLOG
WHERE <if test="state != null">
state = #{state}
</if>
<if test="title != null">
AND title like #{title}
</if>
<if test="author != null and author.name != null">
AND author_name like #{author.name}
</if></select>
若是没有匹配的条件会怎么样？最终这条 SQL 会变成这样：
SELECT * FROM BLOG WHERE
这会致使查询失败。若是匹配的只是第二个条件又会怎样？这条 SQL 会是这样:
SELECT * FROM BLOG WHERE AND title like ‘someTitle’
这个查询也会失败。这个问题不能简单地用条件元素来解决。这个问题是如此的难以解决，以致于解决过的人不会再想碰到这种问题。
MyBatis 有一个简单且适合大多数场景的解决办法。而在其余场景中，能够对其进行自定义以符合需求。而这，只须要一处简单的改动：
<select id="findActiveBlogLike"
resultType="Blog">
SELECT * FROM BLOG <where>
<if test="state != null">
state = #{state}
</if>
<if test="title != null">
AND title like #{title}
</if>
<if test="author != null and author.name != null">
AND author_name like #{author.name}
</if>
</where></select>
where 元素只会在子元素返回任何内容的状况下才插入 “WHERE” 子句。并且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。
上个例子改完后：
<?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.mengyangchen.dao.BlogMapper">
<insert id="insertBlog" parameterType="blog">
insert into mybatis.blog (id,title,author,create_time,views) values (#{id},#{title},#{author},#{createTime},#{views});
</insert>
<select id="queryBlogIf" parameterType="map" resultType="blog">
select * from mybatis.blog <where>
<if test="title !=null">
title like "%"#{title}"%"
</if>
<if test="author != null">
and author like "%"#{author}"%"
</if>
</where>
</select>
</mapper>
若是 where 元素与你指望的不太同样，你也能够经过自定义 trim 元素来定制 where 元素的功能。好比，和 where 元素等价的自定义 trim 元素为：
<trim prefix="WHERE" prefixOverrides="AND |OR "> ...</trim>
prefixOverrides 属性会忽略经过管道符分隔的文本序列（注意此例中的空格是必要的）。上述例子会移除全部 prefixOverrides 属性中指定的内容，而且插入 prefix 属性中指定的内容。
用于动态更新语句的相似解决方案叫作 set。set 元素能够用于动态包含须要更新的列，忽略其它不更新的列。好比：
解决了最后一个条件不须要,的问题。
<update id="updateAuthorIfNecessary">
update Author <set>
<if test="username != null">username=#{username},</if>
<if test="password != null">password=#{password},</if>
<if test="email != null">email=#{email},</if>
<if test="bio != null">bio=#{bio}</if>
</set>
where id=#{id}</update>
这个例子中，set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。
来看看与 set 元素等价的自定义 trim 元素吧：
<trim prefix="SET" suffixOverrides=","> ...</trim>
动态sql之choose (when, otherwise)
有时候，咱们不想使用全部的条件，而只是想从多个条件中选择一个使用。针对这种状况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句。
仍是上面的例子，可是策略变为：传入了 “title” 就按 “title” 查找，传入了 “author” 就按 “author” 查找的情形。若二者都没有传入，就返回标记为 featured 的 BLOG
<select id="findActiveBlogLike"
resultType="Blog">
SELECT * FROM BLOG WHERE state = ‘ACTIVE’ <choose>
<when test="title != null">
AND title like #{title}
</when>
<when test="author != null and author.name != null">
AND author_name like #{author.name}
</when>
<otherwise>
AND featured = 1
</otherwise>
</choose></select>
与if的区别只会执行一个条件。
练习：
<select id="queryBlogChoose" parameterType="map" resultType="blog">
select * from blog <where>
<choose>
<when test="title != null">
title = #{title}
</when>
<when test="author != null">
and author = #{author}
</when>
<otherwise>
and views= #{views}
</otherwise>
</choose>
</where>
</select>
@Test
public void queryBlogChoose(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
Map map = new HashMap();
map.put("title","Mybatis你好！");
map.put("author","梦阳辰");
List<Blog> list = mapper.queryBlogChoose(map);
for (Blog blog:list) {
System.out.println(blog);
}
}
动态sql之foreach
06.sql片断
将一些通用的sql片断提取出来。实现sql代码的复用。
07.缓存
1.什么是缓存？
存在内存中的临时数据。
将用户常常查询的数据放在缓存（(内存）中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提升查询效率，解决了高并发系统的性能问题。
2.为何使用缓存?
减小和数据库的交互次数，减小系统开销，提升系统效率。
3.什么样的数据能使用缓存?
常常查询而且不常常改变的数据。
Mybatis缓存
MyBatis包含一个很是强大的查询缓存特性，它能够很是方便地定制和配置缓存。缓存能够极大的提高查询效率。
MyBatis系统中默认定义了两级缓存:一级缓存和二级缓存
默认状况下，只有一级缓存开启。(SqlSession级别的缓存，也称为本地缓存)。
二级缓存须要手动开启和配置，他是基于namespace级别的缓存。
为了提升扩展性，MyBatis定义了缓存接口Cache。咱们能够经过实现Cache接口来自定义二级缓存
一级缓存
MyBatis 内置了一个强大的事务性查询缓存机制，它能够很是方便地配置和定制。 为了使它更增强大并且易于配置，咱们对 MyBatis 3 中的缓存实现进行了许多改进。
默认状况下，只启用了本地的会话缓存，它仅仅对一个会话中的数据进行缓存。
一级缓存也叫本地缓存:SqlSession
与数据库同一次会话期间查询到的数据会放在本地缓存中。
之后若是须要获取相同的数据，直接从缓存中拿，没必须再去查询数据库;
测试步骤:
1.开启日志!
2.测试在一个Sesion中查询两次相同记录
3.查看日志输出
映射语句文件中的全部 select 语句的结果将会被缓存。
映射语句文件中的全部 insert、update 和 delete 语句会刷新缓存。
缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不须要的缓存。
缓存不会定时进行刷新（也就是说，没有刷新间隔）。
缓存会保存列表或对象（不管查询方法返回哪一种）的 1024 个引用。
缓存会被视为读/写缓存，这意味着获取到的对象并非共享的，能够安全地被调用者修改，而不干扰其余调用者或线程所作的潜在修改。
缓存失效的状况：
1.查询不一样的内容
2.增删改操做，可能会改变原来的数据，因此会刷新缓存。
3.查询不一样的Mapper.xml
4.手动清除缓存。
sqlSession.clearCache();//手动清理缓存
一级缓存存在于sqlsession得到到关闭，默认开启（有效期在得到链接到关闭链接）。
二级缓存
二级缓存也叫全局缓存，一级缓存做用域过低了，因此诞生了二级缓存·
基于namespace级别的缓存，一个名称空间，对应一个二级缓存;
工做机制
一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中;
若是当前会话关闭了，这个会话对应的一级缓存就没了;可是咱们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中;
新的会话查询信息，就能够从二级缓存中获取内容;
不一样的mapper查出的数据会放在本身对应的缓存(map）中;
默认状况下，只启用了本地的会话缓存（一级缓存），它仅仅对一个会话中的数据进行缓存。 要启用全局的二级缓存，只须要在你的 SQL 映射文件中添加一行：
<cache/>
缓存只做用于 cache 标签所在的映射文件中的语句。若是你混合使用 Java API 和 XML 映射文件，在共用接口中的语句将不会被默认缓存。你须要使用 @CacheNamespaceRef 注解指定缓存做用域。
这些属性能够经过 cache 元素的属性来修改。好比：
<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>
这个更高级的配置建立了一个 FIFO 缓存，每隔 60 秒刷新，最多能够存储结果对象或列表的 512 个引用，并且返回的对象被认为是只读的，所以对它们进行修改可能会在不一样线程中的调用者产生冲突。
可用的清除策略有：
LRU – 最近最少使用：移除最长时间不被使用的对象。
FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。
默认的清除策略是 LRU。
步骤：
1.开启全局缓存（默认开启）。
2.在要使用二级缓存的Mapper中开启
3.问题：咱们须要将实体类序列化！不然会报错。
implements Serializable
只要开启了二级缓存，在同一个Mapper下就有效。
全部的数据都会先放在一级缓存中。
只有当会话提交，或者关闭的时候，才会提交到二级缓存中！
缓存的原理
自定义缓存
EhCache 是一个纯Java的进程内缓存框架，具备快速、精干等特色，是Hibernate中默认的CacheProvider。
1.导包
第三方缓存<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache --><dependency> <groupId>org.mybatis.caches</groupId> <artifactId>mybatis-ehcache</artifactId> <version>1.1.0</version></dependency>
除了上述自定义缓存的方式，你也能够经过实现你本身的缓存，或为其余第三方缓存方案建立适配器，来彻底覆盖缓存行为。
<cache type="com.domain.something.MyCustomCache"/>
这个示例展现了如何使用一个自定义的缓存实现。type 属性指定的类必须实现 org.apache.ibatis.cache.Cache 接口，且提供一个接受 String 参数做为 id 的构造器。 这个接口是 MyBatis 框架中许多复杂的接口之一，可是行为却很是简单。
public interface Cache {
String getId();
int getSize();
void putObject(Object key, Object value);
Object getObject(Object key);
boolean hasKey(Object key);
Object removeObject(Object key);
void clear();}
放假回家已经好几天啦，感受要学习的东西还不少。加油,下一篇spring见！
- 1. Mybatis从浅入深（IDEA版通俗易懂）
- 2. 浅拷贝&深拷贝（通俗易懂）
- 3. 通俗易懂的mybatis入门
- 4. Node.js入门-通俗易懂版
- 5. 深入浅出、通俗易懂的讲解CAN bus。
- 6. 通俗易懂的Mybatis工作原理
- 7. MyBatis原理分析（通俗易懂）
- 8. MQ(通俗易懂)
- 9. springsecurity通俗易懂
- 10. 通俗易懂ElasticSearch
- 更多相关文章...
- • XSD 简易元素 - XML Schema 教程
- • SQL 通配符 - SQL 教程
- • 算法总结-深度优先算法
- • YAML 入门教程
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 安装cuda+cuDNN
- 2. GitHub的使用说明
- 3. phpDocumentor使用教程【安装PHPDocumentor】
- 4. yarn run build报错Component is not found in path “npm/taro-ui/dist/weapp/components/rate/index“
- 5. 精讲Haproxy搭建Web集群
- 6. 安全测试基础之MySQL
- 7. C/C++编程笔记：C语言中的复杂声明分析，用实例带你完全读懂
- 8. Python3教程(1)----搭建Python环境
- 9. 李宏毅机器学习课程笔记2：Classification、Logistic Regression、Brief Introduction of Deep Learning
- 10. 阿里云ECS配置速记
- 1. Mybatis从浅入深（IDEA版通俗易懂）
- 2. 浅拷贝&深拷贝（通俗易懂）
- 3. 通俗易懂的mybatis入门
- 4. Node.js入门-通俗易懂版
- 5. 深入浅出、通俗易懂的讲解CAN bus。
- 6. 通俗易懂的Mybatis工作原理
- 7. MyBatis原理分析（通俗易懂）
- 8. MQ(通俗易懂)
- 9. springsecurity通俗易懂
- 10. 通俗易懂ElasticSearch