复习持久层框架Mybatis
什么是Mybatis？
MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
1、MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。
如何获取Mybatis？
maven仓库
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.2</version>
</dependency>
1.2、持久化
数据持久化：持久化就是将程序的数据在持久状态和瞬时状态转化的过程
内存：断电即失
数据库（jdbc），io文件持久化。
生活eg：冷藏，罐头
为什么需要持久化？
内存断电即失，有一些对象不能让他丢掉。
内存太贵
1.3、持久层
Dao层、service层、Controller层
完成持久化工作的代码块
层界限十分明显。
1.4、为什么需要Mybatis？
帮助程序员将数据存入到数据库中。
传统的JDBC代码太复杂了，简化。框架。自动化
不用Mybatis也可以，更容易上手，技术没有高低之分。
Mybatis特性：
简单易学，灵活，不会对应程序产生影响，解除Sql和代码的分离，提供映射标签，提供对象关系映射标签，提供xml标签。
最重要的一点：使用的人多！
2、第一个Mybatis程序
思路：搭建环境–>导入Mybatis–>编写代码–>测试
CREATE DATABASE `mybatis`;
USE `mybatis`;
CREATE TABLE `user`(
`id` INT(20) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
`pwd` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO `user` (`id`,`name`,`pwd`) VALUES
(1,'kiki','123456'),
(2,'张三','123456'),
(3,'李四','123456')
SELECT * FROM USER
2.1、新建项目
2.2、创建一个模块
编写mybatis核心配置文件
参考官网：https://mybatis.org/mybatis-3/zh/getting-started.html
<?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>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<mappers>
<!--每一个mapper.xml需要在mybatis核心配置文件中注册-->
<mapper resource="com/kiki/dao/UserMapper.xml"/>
</mappers>
</configuration>
定义mybatisUtils工具类
package com.kiki.utils;
/**
* @author kiki
* @version 1.0
* @create 2020/7/3 17:51
*/
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 java.io.IOException;
import java.io.InputStream;
/**
* sqlSessionFactory 构建 sqlSession
*/
public class MybatisUtils {
//提升作用域
private static SqlSessionFactory sqlSessionFactory;
//一初始化就加载
static {
try {
//1、获取sqlSessionFactory对象
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
e.printStackTrace();
}
}
public static SqlSession getSqlSession(){
SqlSession sqlSession = sqlSessionFactory.openSession();
return sqlSession;
}
}
2.3、编写代码
实体类
package com.kiki.pojo;
/**
* @author kiki
* @version 1.0
* @create 2020/7/3 18:03
*/
public class User {
private int id;
private String name;
private String pwd;
public User() {
}
public User(int id, String name, String pwd) {
this.id = id;
this.name = name;
this.pwd = pwd;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", pwd='" + pwd + '\'' +
'}';
}
}
Dao接口
package com.kiki.dao;
import com.kiki.pojo.User;
import java.util.List;
/**
* @author kiki
* @version 1.0
* @create 2020/7/3 18:06
*/
public interface UserDao {
List<User> getUserList();
}
接口实现类由原来的UserDaoImpl转变为一个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">
<!--namespace绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.kiki.dao.UserDao">
<!--id与dao中方法名一致
resultType返回值类型，全限定类名
-->
<select id="getUserList" resultType="com.kiki.pojo.User">
select * from mybatis.user
</select>
</mapper>
2.4、测试
package com.kiki.dao;
import com.kiki.pojo.User;
import com.kiki.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
/**
* @author kiki
* @version 1.0
* @create 2020/7/3 18:40
*/
public class UserDaoTest {
@Test
public void test(){
//1、获得sqlSession对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
//2、执行sql
UserDao mapper = sqlSession.getMapper(UserDao.class);
List<User> userList = mapper.getUserList();
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
}
3、CRUD
3.1、namespace
namespace中的包名要和Dao/Mapper接口的包名一致
3.2、select
id：就是对应的namespace中的方法名
resultType：sql语句执行的返回值
parameterType：参数类型
package com.kiki.dao;
import com.kiki.pojo.User;
import java.util.List;
/**
* @author kiki
* @version 1.0
* @create 2020/7/3 18:06
*/
public interface UserMapper {
//获取全部用户
List<User> getUserList();
//根据id查询用户
User getUserById(int id);
//insert一个用户
int addUser(User user);
//修改用户
int updateUserById(User user);
//删除用户
int deleteUserById(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">
<!--namespace绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.kiki.dao.UserMapper">
<!--id与dao中方法名一致
resultType返回值类型，全限定类名
-->
<select id="getUserList" resultType="com.kiki.pojo.User">
select * from mybatis.user
</select>
<select id="getUserById" parameterType="int" resultType="com.kiki.pojo.User">
select * from mybatis.user where id = #{id}
</select>
<insert id="addUser" parameterType="com.kiki.pojo.User" >
insert into mybatis.user(id,name,pwd) values(#{id},#{name},#{pwd})
</insert>
<update id="updateUserById" parameterType="com.kiki.pojo.User">
update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id}
</update>
<delete id="deleteUserById" parameterType="int">
delete from mybatis.user where id=#{id}
</delete>
</mapper>
package com.kiki.dao;
import com.kiki.pojo.User;
import com.kiki.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
/**
* @author kiki
* @version 1.0
* @create 2020/7/3 18:40
*/
public class UserDaoTest {
@Test
public void test(){
//1、获得sqlSession对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
//2、方式1执行sql
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = mapper.getUserList();
//方式2
// List<User> userList = sqlSession.selectList("com.kiki.dao.UserDao.getUserList");
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
@Test
public void test2(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = mapper.getUserById(1);
System.out.println(user);
sqlSession.close();
}
@Test
public void test3(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int count = mapper.addUser(new User(4, "kiki4", "123456"));
//必须提交事务，增删改
sqlSession.commit();
sqlSession.close();
}
@Test
public void test4(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
mapper.updateUserById(new User(4,"小灰灰","123123"));
//必须提交事务，增删改
sqlSession.commit();
sqlSession.close();
}
@Test
public void test5(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
mapper.deleteUserById(4);
//必须提交事务，增删改
sqlSession.commit();
sqlSession.close();
}
}
注意点：增删改需要提交事务
7、万能Map
假设我们的实体类，或者数据库中的表，字段或者参数过多
我们可以考虑使用map
//万能的map
int addUser2(Map<String,Object> map);
<insert id="addUser" parameterType="com.kiki.pojo.User" >
insert into mybatis.user(id,name,pwd) values(#{id},#{name},#{pwd})
</insert>
<!--对象中的属性，可以直接取出来
传递map的key
-->
<insert id="addUser2" parameterType="map">
insert into mybatis.user(id,name,pwd) values(#{userId},#{userName},#{password})
</insert>
@Test
public void test31(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
Map<String,Object> map = new HashMap<String, Object>();
map.put("userId",5);
map.put("userName","Hello");
map.put("password","2222222");
//必须提交事务，增删改
sqlSession.commit();
sqlSession.close();
}
Map传递参数，直接在sql中取出key即可！[parameterType=“map”]
对象传递参数，直接在sql中取对象的属性即可！[]
只有一个基本类型参数的情况下，可以直接在sql中取到!
8、思考业务中出现的问题
1、模糊查询
<select id="getUserLike" resultType="com.kiki.pojo.User">
select * from mybatis.user where name like "%"#{value}"%"
</select>
确保用户能传的值是一个固定的，防止sql注入
4、配置解析
1、mybatis核心配置文件
configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）
2、环境配置（environments）
注意：尽管可以配置多个环境，但是每个SqlSessionFactory实例只能选择一种环境
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
<environment id="test">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
3、属性（properties）
一般通过properties属性来实现引用配置文件
编写配置文件db.properties
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=123456
4、类型别名（typeAliases）
类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。
<typeAliases>
<!--可以给实体类起别名 ，这样在mapper.xml文件中就可以直接使用别名，简便-->
<!--<typeAlias type="com.kiki.pojo.User" alias="User"/>-->
<!--也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean
每一个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。
-->
<package name="com.kiki.pojo"/>
</typeAliases>
建议：
当实体类较少的时候建议使用第一种反之建议使用第二种
第一种可以自定义别名，而第二种则需要加注解才能自定义别名
5、设置（settings）
6、plugins
7、映射器（mappers）
<mappers>
<mapper resource="com/kiki/dao/UserMapper.xml"/>
<!--<mapper class="com.kiki.dao.UserMapper"/>-->
<!-- <package name="com.kiki.dao"/>-->
</mappers>
如果使用class，或者package：则需要注意接口和它的mapper配置文件必须同名
还需要接口和它的mapper配置文件必须在同一个包下
注意：建议使用resource
8、生命周期和作用域
5、解决属性名和字段名不一致的问题
1、resultMap
结果集映射
id name pwd
id name password
<!--<!–结果集映射–>
<resultMap id="UserMap" type="User">
<!–column数据库中的列
property实体类中的属性
–>
<result column="id" property="id"/>
<result column="name" property="name"/>
<result column="pwd" property="password"/>
</resultMap>
<select id="getUserById" resultMap="UserMap">
select * from mybatis.user where id = #{id}
</select>-->
6、日志
6.1、如果一个数据库操作，出现了异常，我们需要排错，日志就是我们最好的帮手
在mybatis核心配置文件（mybatis-config）中配置日志
<settings>
标准的日志工厂实现
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
6.2、Log4j
1、先导入Log4j的包
<!--日志-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
src/main/resource/log4j.properties
@Test
public void testLog4j(){
logger.info("info:进入了testLog4j");
logger.debug("debug:进入了testLog4j");
logger.error("error:进入了testLog4j");
}
7、分页
1、使用mybatis完成分页
<!--分页-->
<select id="getUserByLimit" parameterType="map" resultType="User" >
select * from mybatis.user limit #{startIndex},#{pageSize}
</select>
@Test
public void getUserByLimit(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
Map<String,Integer> map = new HashMap<String, Integer>();
map.put("startIndex",0);
map.put("pageSize",2);
List<User> users = mapper.getUserByLimit(map);
for (User user : users) {
System.out.println(user);
}
sqlSession.close();
}
2、RowBounds
不再使用SQL实现分页
<select id="getUserByRowBounds" resultType="User" >
select * from mybatis.user
</select>
@Test
public void getUserByRowBounds(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
RowBounds rowBounds = new RowBounds(1, 2);
List<User> userList = sqlSession.selectList("com.kiki.dao.UserMapper.getUserByRowBounds",null,rowBounds);
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
3、分页插件
mybatis PageHelper
4、注解开发
4.1面向接口编程：解耦，上层不用管具体的实现
4.2、使用注解开发
使用java注解
本质：反射机制，底层使用的动态代理
@Select("select * from user")
List<User> getUsers();
mybatis-config.xml
<mappers>
<!--绑定接口-->
<mapper class="com.kiki.dao.UserMapper"/>
</mappers>
5、debug调试查看mybatis执行流程
@Param（）注解
@Select("select * from user")
List<User> getUsers();
//方法存在多个参数，所有参数前面加@param注解
@Select("select * from user where id=#{id}")
User getUserById(@Param("id") int id);
@Insert("insert into user(id,name,pwd) values(#{id},#{name},#{pwd})")
int addUser(User user);
@Update("update user set name=#{name},pwd=#{pwd} where id=#{id}")
int updateUser(User user);
@Delete("delete from user where id=#{id}")
int deleteUserById(@Param("id") int id);
9、Lombok
1、安装lombok插件
2、项目导入jar
10、多对一、一对多
按照查询嵌套处理
<?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.kiki.dao.StudentMapper">
<!--
SELECT s.`id`,s.`name`,t.`name` FROM student s,teacher t where s.`tid`=t.`id`
思路：
1、查询所有的学生信息
2、根据查询出来学生tid寻找对应的老师
-->
<select id="getStudent" resultMap="StudentTeacher">
select * from student
</select>
<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="getTeacher"/>
</resultMap>
<select id="getTeacher" resultType="teacher">
select * from teacher where id=#{id}
</select>
</mapper>
按照结果嵌套处理
<!--按照结果嵌套处理
1、
-->
<select id="getStudent2" resultMap="StudentTeacher2">
SELECT s.id sid,s.name sname,t.name tname
FROM student s,teacher t
where s.tid=t.id
</select>
<resultMap id="StudentTeacher2" type="student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<association property="teacher" javaType="Teacher">
<result property="name" column="tname"/>
</association>
</resultMap>
11、一对多处理
eg：一个老师拥有多个学生
按结果嵌套查询
<!--按结果嵌套查询-->
<select id="getTeacher1" resultMap="TeacherStudent" parameterType="int">
select s.id sid,s.name sname,t.name tname,t.id tid
from student s,teacher t
where s.tid = t.id and t.id=#{tid}
</select>
<resultMap id="TeacherStudent" type="teacher">
<result property="id" column="tid"/>
<result property="name" column="tname"/>
<!--
javaType="" 指定属性的类型
集合中的泛型信息，我们使用ofType获取
-->
<collection property="students" ofType="Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<result property="tid" column="tid"/>
</collection>
</resultMap>
按照查询嵌套处理
<select id="getTeacher2" resultMap="TeacherStudent2">
select * from teacher where id = #{tid}
</select>
<resultMap id="TeacherStudent2" type="Teacher">
<result property="id" column="id"/>
<result property="name" column="name"/>
<collection property="students" column="id" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId">
</collection>
</resultMap>
<select id="getStudentByTeacherId" resultType="student">
select * from student where tid=#{tid}
</select>
总结：
1、关联association多对一 （多个属于一个）
2、集合collection 一对多（一个包含多个）
3、javaType和ofType
1、javaType用来指定实体类中属性的类型
2、ofType用来指定映射到List或者集合中的pojo类型，也即是泛型中约束类型
注意点：
1、保证sql的可读性，尽量保证通俗易懂
2、注意一对多和多对一中，属性名和字段的问题
3、如果问题不好排查错误，可以使用日志，建议使用log4j
12、动态SQL
什么是动态SQL：根据不同的条件生成不同的SQL语句
IF
//查询博客
List<Blog> queryBlogIF(Map map);
<select id="queryBlogIF" parameterType="map" resultType="blog">
select *
from blog
where 1=1
<if test="title!=null">
and title=#{title}
</if>
<if test="author!=null">
and author = #{author}
</if>
</select>
@Test
public void queryBlogIF(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap map = new HashMap();
map.put("title","java基础");
List<Blog> blogs = mapper.queryBlogIF(map);
for (Blog blog : blogs) {
System.out.println(blog);
}
sqlSession.close();
}
choose（when，otherwise）
如果条件都满足，则只会取第一个，若when中的都不满足，则必须要指定otherwise中的
<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>
trim（where，set）
<select id="queryBlogIF" parameterType="map" resultType="blog">
select *
from blog
<where>
<if test="title!=null">
and title=#{title}
</if>
<if test="author!=null">
and author = #{author}
</if>
</where>
</select>
<update id="updateBlog" parameterType="map">
update blog
<set>
<if test="title!=null">
title=#{title},
</if>
<if test="author!=null">
author=#{author}
</if>
</set>
where id = #{id}
</update>
动态SQL本质还是SQL语句，只是我们可以在SQL层面，去执行一个逻辑代码
foreach
<select id="selectPostIn" resultType="domain.blog.Post">
SELECT *
FROM POST P
WHERE ID in
<foreach item="item" index="index" collection="list"
open="(" separator="," close=")">
#{item}
</foreach>
</select>
SELECT *
FROM POST P
WHERE ID in （1，2，3）
//查询id为1,2,3的信息
List<Blog> queryBlogForeach(Map map);
<!--foreach
我们现在传递一个万能的map，这个map中可以存在一个集合
-->
<select id="queryBlogForeach" parameterType="map" resultType="blog">
select * from blog
<where>
<foreach collection="ids" index="index" item="id" open="and (" separator="or" close=")">
id=#{id}
</foreach>
</where>
</select>
@Test
public void queryBlogForeach(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap map = new HashMap();
ArrayList<Integer> ids = new ArrayList<Integer>();
ids.add(1);
ids.add(2);
map.put("ids",ids);
mapper.queryBlogForeach(map);
sqlSession.close();
}
SQL片段
有的时候可能会将一些公共的部分抽取出来，方便复用！
<sql id="if-title-author">
<if test="title!=null">
and title=#{title}
</if>
<if test="author!=null">
and author = #{author}
</if>
</sql>
<select id="queryBlogIF" parameterType="map" resultType="blog">
select *
from blog
<where>
<include refid="if-title-author"></include>
</where>
</select>
注意事项：
最好基于单表来定义SQL片段
不要存在where标签
动态SQL就是在拼接SQL语句，我们只需要保证SQL的正确性，按照SQL的格式，进行排列组合就可以了
步骤：
1、先在MySQL中写出完整的sql，再去对应的去修改成为我们的动态sql去实现通用就可以了
13、缓存
1、什么是缓存 [ Cache ]？
存在内存中的临时数据。
将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。
2、为什么使用缓存？
减少和数据库的交互次数，减少系统开销，提高系统效率。
3、什么样的数据能使用缓存？
经常查询并且不经常改变的数据。
@Test
public void testCache(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = mapper.queryUserById(1);
System.out.println(user);
System.out.println("=============================");
User user1 = mapper.queryUserById(1);
System.out.println(user1);
System.out.println(user==user1);
sqlSession.close();
}
一级缓存失效的四种情况
1.sqlSession不同
每个sqlSession中的缓存相互独立
2、增删 操作
3、查询不同的Mapper.xml
4、手动清理缓存，sqlSession.clearCache(); 清除缓存
一级缓存是默认开启的，只在一次SqlSession中有效，也就是在拿到连接到关闭连接这个区间段
一级缓存就是一个Map
二级缓存
二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
基于namespace级别的缓存，一个名称空间，对应一个二级缓存；
工作机制
一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中；
新的会话查询信息，就可以从二级缓存中获取内容；
不同的mapper查出的数据会放在自己对应的缓存（map）中；
1、开启全局缓存 【mybatis-config.xml】
2、在*Mapper.xml文件中
使用二级缓存
<cache
eviction="FIFO"
flushInterval="60000"
size="512"
readOnly="true"/>
测试
@Test
public void testCache2(){
SqlSession sqlSession1 = MybatisUtils.getSqlSession();
SqlSession sqlSession2 = MybatisUtils.getSqlSession();
UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
User user1 = mapper1.queryUserById(1);
System.out.println(user1);
sqlSession1.close();
System.out.println("=============================");
User user2 = mapper2.queryUserById(1);
System.out.println(user2);
System.out.println(user1==user2);
sqlSession2.close();
}
总结：
1、只要开启了二级缓存，在同一个Mapper下就有效
2、所有的数据都会 先放在 一级缓存中
3、只有当会话提交或者关闭的时候，才会提交到二级缓存中
13.5缓存原理
ehcache
Ehcache是一个纯Java进程内缓存框架，具有快速、精干等特点，是Hibernate默认的CacheProvider，主要面向通用缓存。
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-ehcache</artifactId>
<version>1.1.0</version>
</dependency>
