Mybatis(7)延迟加载、缓存及注解
1、延迟加载
延迟加载:
就是在需要用到数据时才进行加载,不需要用到数据时就不加载数据。延迟加载也称懒加载.
**好处:**先从单表查询,需要时再从关联表去关联查询,大大提高数据库性能,因为查询单表要比关联查询多张表速
度要快。
坏处 :
因为只有当需要用到数据时,才会进行数据库查询,这样在大批量数据查询时,因为查询工作也要消耗
时间,所以可能造成用户等待时间变长,造成用户体验下降
2、Mybatis缓存
像大多数的持久化框架一样,Mybatis 也提供了缓存策略,通过缓存策略来减少数据库的查询次数,从而提
高性能。
Mybatis 中缓存分为一级缓存,二级缓存。
2.1、一级缓存
一级缓存是SqlSession级别的缓存,只要SqlSession没有flush、close或clearCache,那么缓存就会存在。
2.1.1、测试一级缓存的存在
测试方法
@Test
public void testFindOne(){
//通过id查找用户
User user1 = uesrdao.findById(48);
System.out.println(user1.hashCode());
//sqlSession.clearCache();
User user2 = uesrdao.findById(48);
System.out.println(user2.hashCode());
System.out.println(user1 == user2);
}
运行结果:
Opening JDBC Connection
Created connection 278934944.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@10a035a0]
==> Preparing: select * from user where id=?
> Parameters: 48(Integer)
< Total: 1
1832580921
1832580921
true
分析
上面的结果显示虽然我们进行了两次查询,但是只执行了一次数据库操作。这就是一级缓存在起作用,因为一级缓存的存在所以在第二次查询id = 48时,没有进行数据库的操作,而是直接从一级缓存中读取数据。
2.1.2、一级缓存
一级缓存是SqlSession级别的缓存,当调用SqlSession缓存的 添加,更新、删除、commit()、close()等操作时,会清空一级缓存。
第一次sqlsession对象执行查询操作id = 48时,先去缓存中查询是否存在有id=48的用户信息,没有就执行sql语句,然后从数据库中查询数据。
得到用户信息后就把用户信息储存在一级缓存中。
准确来说,存入一级缓存的是由查询语句返回的对象,而不是具体的数据
第二次发起查询用户 id 为 1 的用户信息,先去找缓存中是否有 id 为 1 的用户信息,缓存中有,直接从缓存
中获取用户信息。
如果 sqlSession 去执行 commit 操作(执行插入、更新、删除),清空 SqlSession 中的一级缓存,这样
做的目的为了让缓存中存储的是最新的信息,避免脏读。
2.1.3、对清除缓存的操作
@Test
public void testFindOne(){
//通过id查找用户
User user1 = uesrdao.findById(48);
System.out.println(user1.hashCode());
sqlSession.clearCache();
User user2 = uesrdao.findById(48);
System.out.println(user2.hashCode());
System.out.println(user1 == user2);
}
执行结果:
Opening JDBC Connection
Created connection 278934944.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@10a035a0]
==> Preparing: select * from user where id=?
> Parameters: 48(Integer)
< Total: 1
1832580921
==> Preparing: select * from user where id=?
> Parameters: 48(Integer)
< Total: 1
369241501
false
清空缓存后查询数据库的信息,查询了两次。
2.2、二级缓存
二级缓存是 mapper 映射级别的缓存,多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句,多个
SqlSession 可以共用二级缓存,二级缓存是跨 SqlSession 的。
及可以认为二级缓存是依赖于SqlSessionFactory,SqlSessionFactory对象产生时,就存在,并且由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。
二级缓存的使用步骤:
第一步:让Mybatis框架支持二级缓存(在SqlMapConfig.xml中配置)在configuration标签中开启setting标签
setting标签
设置名
描述
有效值
默认值
cacheEnabled
全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存。
true | false
true
因为 cacheEnabled 的取值默认就为 true,所以这一步可以省略不配置。为 true 代表开启二级缓存;为
false 代表不开启二级缓存。
第二步:让当前的映射文件支持二级缓存(在IUserDao.xml中配置)
在mapper标签中写
cache标签表示当前这个 mapper 映射将使用二级缓存,区分的标准就看 mapper 的 namespace 值。
第三步:让当前的操作支持二级缓存(在select标签中配置)
在mapper标签中写
select * from user where id=#{id}
将 UserDao.xml 映射文件中的select标签中设置 useCache=”true”代表当前这个 statement 要使用
二级缓存,如果不使用二级缓存可以设置为 false。
注意:针对每次查询都需要最新的数据 sql,要设置成 useCache=false,禁用二级缓存。
第四步:添加测试类
package test;
import dao.IUserDao;
import domain.QueryVo;
import domain.User;
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 org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.InputStream;
import java.util.Date;
import java.util.List;
public class CacheTest {
/**
* 测试mybatis的CRUD操作
*/
InputStream in;
SqlSessionFactory build;
@Before
public void init() throws Exception {
in = Resources.getResourceAsStream("SqlMapConfig.xml");
build = new SqlSessionFactoryBuilder().build(in);
}
@After
public void destory() throws Exception {
in.close();
}
@Test
public void testFindOne(){
SqlSession sqlSession1 = build.openSession();
IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);
User user1 = dao1.findById(41);
System.out.println(user1);
sqlSession1.close();//一级缓存消失
SqlSession sqlSession2 = build.openSession();
IUserDao dao2 = sqlSession2.getMapper(IUserDao.class);
User user2 = dao2.findById(41);
System.out.println(user2);
sqlSession2.close();
System.out.println(user1 == user2);
}
}
执行结果:
Opening JDBC Connection
Created connection 929776179.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@376b4233]
==> Preparing: select * from user where id=?
> Parameters: 41(Integer)
< Total: 1
User{id=41, username=‘老王’, birthday=Tue Feb 27 17:47:08 CST 2018, sex=‘男’, address=‘北京’}
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@376b4233]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@376b4233]
Returned connection 929776179 to pool.
Cache Hit Ratio [dao.IUserDao]: 0.5
User{id=41, username=‘老王’, birthday=Tue Feb 27 17:47:08 CST 2018, sex=‘男’, address=‘北京’}
false
经过上面的测试,我们发现执行了两次查询,并且在执行第一次查询后,我们关闭了一级缓存,再去执行第二
次查询时,我们发现并没有对数据库发出 sql 语句,所以此时的数据就只能是来自于我们所说的二级缓存。
然而两次的User对象却不相同,这是因为二级缓存存储的是对应的具体数据
{id=41, username=‘老王’, birthday=Tue Feb 27 17:47:08 CST 2018, sex=‘男’, address=‘北京’}
等到再次查询时才会new新的对象。
2.2.1、二级缓存的注意事项
当我们在使用二级缓存时,所缓存的类一定要实现 java.io.Serializable 接口,这种就可以使用序列化
方式来保存对象。
/**
*
*
Title: User
*
Description: 用户的实体类
*/
public class User implements Serializable {
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
}
3、Mybatis关于注解的开发
3.1、mybatis常用注解说明
@Insert:实现新增
@Update:实现更新
@Delete:实现删除
@Select:实现查询
@Result:实现结果集封装
@Results:可以与@Result 一起使用,封装多个结果集
@ResultMap:实现引用@Results 定义的封装
@One:实现一对一结果集封装
@Many:实现一对多结果集封装
@SelectProvider: 实现动态 SQL 映射
@CacheNamespace:实现注解二级缓存的使用
3.2、用注解实现CRUD操作
3.2.1、编写实体类
E:\java\idea\SSM\ssm01_mybatis_annotation\src\main\java\domain\User.java
package domain;
import java.io.Serializable;
import java.util.Date;
public class User implements Serializable {
private Integer id;
private String username;
private String address;
private String sex;
private Date birthday;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", address='" + address + '\'' +
", sex='" + sex + '\'' +
", birthday=" + birthday +
'}';
}
}
3.2.2、编写主配置文件
E:\java\idea\SSM\ssm01_mybatis_annotation\src\main\resources\SqlMapConfig.xml
/p>
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
3.2.3、编写持久化接口
E:\java\idea\SSM\ssm01_mybatis_annotation\src\main\java\dao\IUserDao.java
package dao;
import domain.User;
import org.apache.ibatis.annotations.*;
import java.util.List;
/**
* 在mybatis中针对注解有四个注解
*@Select()、@Insert()、@Update()、@Delete()
*/
@CacheNamespace(blocking = true)
public interface IUserDao {
/**
* 查询所有
* @return
*/
@Select(value = "select * from user")
List findAll();
/**
* 添加用户
* @param user
*/
@Insert("insert into user (username,address,sex,birthday) values(#{username},#{address},#{sex},#{birthday})")
void addUser(User user);
/**
* 根据id删除指定用户
* @param id
*/
@Delete("delete from user where id = #{id}")
void deleteUser(int id);
/**
* 更新用户数据
* @param user
*/
@Update("update user set username = #{username},address = #{address},sex = #{sex},birthday = #{birthday} where id = #{id}")
void updateUser(User user);
@Select("select * from user where id = #{id}")
User findById(int id);
/**
* 模糊查询
* @param name
* @return
*/
//@Select("select * from user where username like #{str}")
@Select("select * from user where username like '%${value}%'")
List findByName(String name);
/**
*
* @return
*/
@Select("select count(id) from user")
int findTotal();
}
3.2.4、编写相应测试类
package test;
import dao.IUserDao;
import domain.User;
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 org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.InputStream;
import java.util.Date;
import java.util.List;
public class AnnotationTest {
InputStream in;
SqlSessionFactory factory;
SqlSession sqlSession;
IUserDao userDao;
@Before
public void init() throws Exception {
in = Resources.getResourceAsStream("SqlMapConfig.xml");
factory = new SqlSessionFactoryBuilder().build(in);
sqlSession = factory.openSession();
userDao = sqlSession.getMapper(IUserDao.class);
}
@After
public void destory() throws Exception {
sqlSession.commit();
sqlSession.close();
in.close();
}
@Test
public void testFindAll(){
List users = userDao.findAll();
for (User user:users){
System.out.println(user);
}
}
@Test
public void testAddUser(){
User user = new User();
user.setUsername("wf");
user.setBirthday(new Date());
user.setSex("男");
user.setAddress("中国");
userDao.addUser(user);
}
@Test
public void testDeleteUser(){
userDao.deleteUser(49);
}
@Test
public void testUpdateUser(){
User user = new User();
user.setId(50);
user.setUsername("gx");
user.setBirthday(new Date());
user.setSex("女");
user.setAddress("中国");
userDao.updateUser(user);
}
@Test
public void testFindById(){
User user = userDao.findById(50);
System.out.println(user);
}
@Test
public void testFindByName(){
//List users = userDao.findByName("%王%");
List users = userDao.findByName("王");
for (User user:users){
System.out.println(user);
}
}
@Test
public void testFindTotal(){
int a = userDao.findTotal();
System.out.println(a);
}
}
3.4、mybatis基于注解的二级缓存
3.4.1、在SqlMapConfig中开启二级缓存支持
3.4.2、在持久层接口中使用注解配置二级缓存
/**
*
*
Title: IUserDao
*
Description: 用户的持久层接口
*/
@CacheNamespace(blocking=true)//mybatis 基于注解方式实现配置二级缓存
public interface IUserDao {}