您的位置: 首页  >  文章  >  Mybatis缓存

Mybatis缓存

分类: 文章 • 2024-03-14 13:23:16

延迟加载（懒加载）

延迟加载就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载。好处就是先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。坏处就是因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗时间，所以可能造成用户等待时间变长，造成用户体验下降。
在MyBatis多表查询之一对一中，如果我们在查询订单表中的订单信息时，暂时不需要订单表关联的用户信息的话，但是实际测试结果是用户信息也被关联（resultMap）的查询出来，这时就可以使用MyBatis提供的懒加载来实现。
Mybatis缓存

public class Orders {
private int id;
private int userId;
private String number;
private String createTime;
private String note;
private User user;
}

public class User {
    private int id;
    private String username;
    private String birthday;
    private String sex;
    private String address;
}

sqlMapConfig.xml

<!--配置懒加载  -->
<settings>
    <!--打开延迟加载的开关  -->
    <setting name="lazyLoadingEnabled" value="true"/>
    <!--将积极加载改为消极加载及按需加载  -->
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>

OrderDao.xml

    <resultMap id="findOrdersUser" type="com.luhui.bean.Orders">
        <id column="id" property="id"/>
        <result column="user_id" property="userId" />
        <result column="number" property="number" />
        <result column="createtime" property="createTime" />
        <result column="note" property="note" />
        <association property="user" javaType="com.luhui.bean.User"  select="findUserById" column="user_id"/>
    </resultMap>
    
    <select id="findOrdersLazyUser" resultMap="findOrdersUser">
        select * from orders
    </select>
    
    <select id="findUserById" parameterType="int" resultType="com.luhui.bean.User">
        select * from t_user where id = #{id}
    </select>

OrderDao.java

public List<Orders> findOrdersLazyUser();
public User findUserById(int id);

测试代码

@Test
public void test17(){
    SqlSession sqlSession = SqlSessionFactoryUtils.openSqlSession();
    OrderDao orderDao = sqlSession.getMapper(OrderDao.class);
    List<Orders> ordersList = orderDao.findOrdersLazyUser();
    sqlSession.commit();
    sqlSession.close();
}

一级缓存

Mybatis提供查询缓存，用于减轻数据压力，提高数据库性能。Mybatis提供一级缓存（默认开启），和二级缓存（默认关闭）。
一级缓存是sqlSession级别的缓存。在操作数据库时需要构造sqlSession对象，在对象中有一个数据结构(HashMap),用于存储缓存数据。不同的sqlSession之间的缓存区域(HashMap)是互不影响的。一级缓存是SqlSession级别的缓存，只要SqlSession 没有flush或close，它就存在。当调用 SqlSession 的修改，添加，删除，commit()，close()等方法时，就会清空一级缓存。
一级缓存的原理图：
Mybatis缓存
1）第一次查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，如果没有，从数据库查询用户信息。得到用户信息，将用户信息存储到一级缓存中；
2）如果sqlSession去执行commit操作（执行插入、更新、删除），清空SqlSession中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息；
3）第二次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，缓存中有，直接从缓存中获取用户信息。

@Test
public void test18(){
    SqlSession sqlSession = SqlSessionFactoryUtils.openSqlSession();
    OrderDao orderDao = sqlSession.getMapper(OrderDao.class);
    User user = orderDao.findUserById(1);
    System.out.println(user);
    User user2 = orderDao.findUserById(1);
    System.out.println(user2);
    sqlSession.commit();
    sqlSession.close();
}

Mybatis缓存
我们可以发现，虽然在上面的代码中我们查询了两次，但最后只执行了一次数据库操作，这就是 MyBatis提供给我们的一级缓存在起作用了。因为一级缓存的存在，导致第二次查询id为1的记录时，并没有发出sql语句从数据库中查询数据，而是从一级缓存中查询。
测试一级缓存的清空：

@Test
public void test19(){
    SqlSession sqlSession = SqlSessionFactoryUtils.openSqlSession();
    OrderDao orderDao = sqlSession.getMapper(OrderDao.class);
    com.luhui.bean.User user = orderDao.findUserById(1);
    System.out.println(user);
    sqlSession.clearCache();        //此方法也可以清空缓存
    com.luhui.bean.User user2 = orderDao.findUserById(1);
    System.out.println(user2);
    sqlSession.commit();
    sqlSession.close();
}

Mybatis缓存
测试缓存的同步：

<select id="updateUser" parameterType="com.luhui.bean.User">
     UPDATE t_user set username = #{username} where id = #{id}
</select>

public void updateUser(User user);

测试代码：

@Test
public void test20(){
    SqlSession sqlSession = SqlSessionFactoryUtils.openSqlSession();
    OrderDao orderDao = sqlSession.getMapper(OrderDao.class);
    com.luhui.bean.User user = orderDao.findUserById(1);
    System.out.println(user);
    user.setUsername("测试数据");
    orderDao.updateUser(user);
    com.luhui.bean.User user2 = orderDao.findUserById(1);
    System.out.println(user2);
    sqlSession.commit();
    sqlSession.close();
}

Mybatis缓存
6.3、二级缓存
二级缓存是mapper级别的缓存，多个sqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨sqlSession的。
Mybatis缓存
1）首先开启mybatis的二级缓存。
2）sqlSession1去查询用户id为1的用户信息，查询到用户信息会将查询数据存储到二级缓存中。
3）如果SqlSession3去执行相同 mapper下sql，执行commit提交，清空该 mapper下的二级缓存区域的数据。
4）sqlSession2去查询用户id为1的用户信息，去缓存中找是否存在数据，如果存在直接从缓存中取出数据。

在SqlMapConfig.xml文件开启二级缓存
    <settings>
    <!-- 开启二级缓存的支持 -->
    	<setting name="cacheEnabled" value="true"/>
    </settings>

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

配置相关的Mapper映射文件

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

    <!-- 开启二级缓存的支持 -->
    <cache />
配置statement上面的useCache属性
<!-- 根据 id 查询 -->
<select id="findUserById" parameterType="int" resultType="com.luhui.bean.User" useCache="true">
    select * from t_user where id = #{id}
</select>

将OrderDao.xml映射文件中的标签中设置useCache=”true”代表当前这个statement要使用二级缓存，如果不使用二级缓存可以设置为false。
注：若每次查询都需要最新的数据sql，要设置成useCache=false，禁用二级缓存。

@Test
public void test21(){
    SqlSession sqlSession = SqlSessionFactoryUtils.openSqlSession();
    OrderDao orderDao = sqlSession.getMapper(OrderDao.class);
    com.luhui.bean.User user = orderDao.findUserById(1);
    System.out.println(user);
    sqlSession.close();         //一级缓存消失
    SqlSession sqlSession1 = SqlSessionFactoryUtils.openSqlSession();
    OrderDao orderDao1 = sqlSession1.getMapper(OrderDao.class);
    com.luhui.bean.User user2 = orderDao1.findUserById(1);
    System.out.println(user2);
    sqlSession1.commit();
    sqlSession1.close();
}

经过上面的测试，我们发现执行了两次查询，并且在执行第一次查询后，我们关闭了一级缓存，再去执行第二次查询时，我们发现并没有对数据库发出sql语句，所以此时的数据就只能是来自于我们所说的二级缓存。
当我们在使用二级缓存时，所缓存的类一定要实现 java.io.Serializable 接口，这种就可以使用序列化方式来保存对象。
注：二级缓存与一级缓存区别，二级缓存的范围更大，多个sqlSession可以共享一个UserMapper的二级缓存区域。UserMapper有一个二级缓存区域（按namespace分），其它mapper也有自己的二级缓存区域（按namespace分）。

相关推荐