SSM框架之Mybatis（7）延迟加载、缓存及注解

绝地灬酷狼 2022-04-24 09:24 174阅读 0赞

# 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);
    }

执行结果：

清空缓存后查询数据库的信息，查询了两次。

### 2.2、二级缓存 ###

二级缓存是 mapper 映射级别的缓存，多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句，多个  
SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的。

及可以认为二级缓存是依赖于SqlSessionFactory，SqlSessionFactory对象产生时，就存在，并且由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。

**二级缓存的使用步骤：**  
**第一步**：让Mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）在configuration标签中开启setting标签

setting标签

<table> 
 <thead> 
  <tr> 
   <th>设置名</th> 
   <th>描述</th> 
   <th>有效值</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>cacheEnabled</td> 
   <td>全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存。</td> 
   <td>true | false</td> 
   <td>true</td> 
  </tr> 
 </tbody> 
</table>

因为 cacheEnabled 的取值默认就为 true，所以这一步可以省略不配置。为 true 代表开启二级缓存；为  
false 代表不开启二级缓存。

**第二步**：让当前的映射文件支持二级缓存（在IUserDao.xml中配置）

在mapper标签中写

cache标签表示当前这个 mapper 映射将使用二级缓存，区分的标准就看 mapper 的 namespace 值。

**第三步**：让当前的操作支持二级缓存（在select标签中配置）

在mapper标签中写

<mapper namespace="dao.IUserDao">
    	<cache/>
        
        <select id="findById" parameterType="int" resultType="domain.User" useCache="true">
            select * from user where id=#{id}
        </select>
    </mapper>

将 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 接口，这种就可以使用序列化  
方式来保存对象。

/** * * <p>Title: User</p> * <p>Description: 用户的实体类</p> */
    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

<?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="jdbcConfig.properties"/>
    
        <typeAliases>
            <package name="domain"/>
        </typeAliases>
        
        <environments default="mysql">
            <environment id="mysql">
                <transactionManager type="JDBC"></transactionManager>
                <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>
            <package name="dao"/>
        </mappers>
    </configuration>

#### 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<User> 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<User> 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<User> 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<User> users = userDao.findByName("%王%");
            List<User> 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中开启二级缓存支持 ####

<settings>
    
    <setting name="cacheEnabled" value="true"/>
    </settings>

#### 3.4.2、在持久层接口中使用注解配置二级缓存 ####

/** * * <p>Title: IUserDao</p> * <p>Description: 用户的持久层接口</p> */
    @CacheNamespace(blocking=true)//mybatis 基于注解方式实现配置二级缓存
    public interface IUserDao { }