缓存惹的祸？探讨MyBatis二级缓存的四个不推荐之处

最新推荐文章于 2024-02-23 13:31:22 发布
最新推荐文章于 2024-02-23 13:31:22 发布
阅读量1.6k 收藏 9
点赞数 1
文章标签： 缓存 mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49768044/article/details/131472652
版权

在这里插入图片描述

文章目录

在使用 MyBatis 框架时，可以选择开启二级缓存来提高性能。但是，使用 MyBatis 的二级缓存需要谨慎，并且在大多数情况下，并不推荐使用二级缓存。以下是一些原因：

1. 数据不一致性

二级缓存是跨会话的，可能存在多个会话同时操作同一数据的情况。当其中一个会话修改了数据后，其他会话获取到的仍然是缓存中的旧数据，导致数据不一致的问题。

下面是一个示例代码，用于说明 MyBatis 的二级缓存可能导致的数据不一致性问题。

假设有一个 User 类和对应的 UserMapper 接口，用于操作用户数据表。我们将演示在开启了 MyBatis 的二级缓存情况下，同时进行并发的更新操作时可能出现的数据不一致性问题。

首先是 User 类的定义：

public class User {
    private Long id;
    private String name;

    // 构造函数、getter 和 setter 方法省略
}

接下来是 UserMapper 接口和对应的 XML 配置文件：

UserMapper.java：

public interface UserMapper {
    User getUserById(Long id);

    void updateUser(User user);
}

UserMapper.xml：

<mapper namespace="com.example.UserMapper">
    <cache type="org.apache.ibatis.cache.impl.PerpetualCache" />

    <select id="getUserById" resultType="com.example.User">
        SELECT * FROM users WHERE id = #{id}
    </select>

    <update id="updateUser">
        UPDATE users SET name = #{name} WHERE id = #{id}
    </update>
</mapper>

现在，我们将演示两个并发的会话同时更新同一个用户的姓名，并观察可能出现的数据不一致性问题。

public class Main {
    public static void main(String[] args) throws IOException {
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession sqlSessionA = sqlSessionFactory.openSession();
        SqlSession sqlSessionB = sqlSessionFactory.openSession();

        try {
            UserMapper userMapperA = sqlSessionA.getMapper(UserMapper.class);
            UserMapper userMapperB = sqlSessionB.getMapper(UserMapper.class);

            // 会话A更新用户姓名为"Alice"
            User userA = userMapperA.getUserById(1L);
            userA.setName("Alice");
            userMapperA.updateUser(userA);
            sqlSessionA.commit();

            // 会话B查询用户姓名，预期是"Alice"，但实际可能是旧值
            User userB = userMapperB.getUserById(1L);
            System.out.println(userB.getName());  // 输出结果可能是旧的姓名，而不是"Alice"
        } finally {
            sqlSessionA.close();
            sqlSessionB.close();
        }
    }

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        return new SqlSessionFactoryBuilder().build(inputStream);
    }
}

在上述示例中，我们使用 SqlSessionFactory 创建了两个会话 sqlSessionA 和 sqlSessionB，它们分别执行并发的更新和查询操作。

在会话A中，我们使用 UserMapper 更新用户的姓名为"Alice"，并提交事务。然后，在会话B中，我们使用相同的 UserMapper 查询用户的姓名，预期结果应该是"Alice"。然而，由于开启了 MyBatis 的二级缓存且会话B还未失效，会话B仍然从二级缓存中获取到的是旧的用户信息，导致最终输出结果可能是旧的姓名，而不是预期的"Alice"。

这就是因为二级缓存导致的数据不一致性问题，会话B无法获得最新的数据。

要解决这个问题，可以使用 sqlSession.clearCache() 方法手动清除会话B中的二级缓存，以确保再次查询时能够从数据库获取最新的数据。

// 会话B查询用户姓名，预期是"Alice"
sqlSessionB.clearCache();  // 手动清除二级缓存
User userB = userMapperB.getUserById(1L);
System.out.println(userB.getName());  // 输出结果为"Alice"

需要注意的是，在实际应用中，具体的数据不一致性问题可能更加复杂，涉及到分布式环境、集群部署、缓存管理策略等因素。因此，在使用 MyBatis 的二级缓存时，需要根据具体的应用场景和需求来评估并合理处理数据一致性的问题。

2. 内存占用

二级缓存需要将查询结果缓存在内存中，对于大量数据或者查询频繁的场景，会占用较大的内存空间。当系统内存有限时，使用二级缓存可能导致内存溢出的问题。

当使用 MyBatis 的二级缓存时，会将查询的结果对象缓存在内存中，以便在后续的查询中直接使用，从而减少数据库访问次数，提高性能。但是，如果数据量较大或者缓存管理不当，二级缓存可能会占用过多的内存。

下面是一个示例代码，用于说明 MyBatis 二级缓存可能导致的内存占用问题。

首先是 User 类的定义：

public class User {
    private Long id;
    private String name;

    // 构造函数、getter 和 setter 方法省略
}

接下来是 UserMapper 接口和对应的 XML 配置文件：

UserMapper.java：

public interface UserMapper {
    List<User> getAllUsers();
}

UserMapper.xml：

<mapper namespace="com.example.UserMapper">
    <cache type="org.apache.ibatis.cache.impl.PerpetualCache" />

    <select id="getAllUsers" resultType="com.example.User">
        SELECT * FROM users
    </select>
</mapper>

现在，我们将演示在大量查询的情况下，二级缓存可能导致的内存占用问题。

public class Main {
    public static void main(String[] args) throws IOException {
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession sqlSessionA = sqlSessionFactory.openSession();
        SqlSession sqlSessionB = sqlSessionFactory.openSession();

        try {
            UserMapper userMapperA = sqlSessionA.getMapper(UserMapper.class);
            UserMapper userMapperB = sqlSessionB.getMapper(UserMapper.class);

            // 会话A查询所有用户
            List<User> usersA = userMapperA.getAllUsers();

            // 会话B查询所有用户，预期从二级缓存中获取
            List<User> usersB = userMapperB.getAllUsers();

            // 输出结果的内存占用大小
            System.out.println("会话A结果大小：" + ObjectSizeCalculator.getObjectSize(usersA));
            System.out.println("会话B结果大小：" + ObjectSizeCalculator.getObjectSize(usersB));
        } finally {
            sqlSessionA.close();
            sqlSessionB.close();
        }
    }

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        return new SqlSessionFactoryBuilder().build(inputStream);
    }
}

在上述示例中，我们使用 SqlSessionFactory 创建了两个会话 sqlSessionA 和 sqlSessionB，它们分别执行相同的查询操作。

在会话A中，我们使用 UserMapper 查询所有的用户，并将结果存储在名为 usersA 的列表中。

在会话B中，我们使用相同的 UserMapper 再次查询所有的用户，预期会从二级缓存中获取到结果。将结果存储在名为 usersB 的列表中。

最后，我们使用 ObjectSizeCalculator.getObjectSize() 方法分别计算 usersA 和 usersB 的内存占用大小，并输出结果。

运行示例代码，我们可以观察到会话A和会话B的查询结果是相同的，即从二级缓存中获取。但是，由于缓存中缓存了大量的用户对象，因此会话B查询结果的内存占用大小可能较大。

这其中涉及到整个查询结果集的存储，包括用户对象及其关联对象等，如果数据量较大，二级缓存可能导致内存的过度占用，从而影响系统的性能和稳定性。

为了解决这个问题，可以采取以下策略：

  1. 调整二级缓存的配置，例如使用 LRU（最近最少使用）策略、设置合理的缓存大小等，以平衡内存占用和性能之间的权衡。
  2. 考虑在查询中使用分页来限制缓存的大小，只查询需要的数据量，避免加载过多的数据到内存中。
  3. 根据具体业务场景，评估是否真正需要使用二级缓存，有些查询可能更适合直接从数据库获取最新数据。

需要根据实际情况和具体需求来评估并合理处理二级缓存可能导致的内存占用问题。

3. 延迟问题

由于需要维护缓存的一致性，二级缓存可能引入一定的延迟。当数据发生更新时，会导致缓存失效，下一次查询需要重新从数据库加载数据，可能引起稍微的延迟。

当使用 MyBatis 的二级缓存时，由于缓存的存在，可能会导致数据的延迟更新问题。这意味着在数据库中执行更新操作后，其他会话或线程可能仍然使用旧的缓存数据，而不是最新的数据库数据。

下面是一个示例代码，用于说明 MyBatis 二级缓存可能导致的延迟更新问题。

首先是 User 类的定义：

public class User {
    private Long id;
    private String name;

    // 构造函数、getter 和 setter 方法省略
}

接下来是 UserMapper 接口和对应的 XML 配置文件：

UserMapper.java：

public interface UserMapper {
    User getUserById(Long id);

    void updateUser(User user);
}

UserMapper.xml：

<mapper namespace="com.example.UserMapper">
    <cache type="org.apache.ibatis.cache.impl.PerpetualCache" />

    <select id="getUserById" resultType="com.example.User">
        SELECT * FROM users WHERE id = #{id}
    </select>

    <update id="updateUser">
        UPDATE users SET name = #{name} WHERE id = #{id}
    </update>
</mapper>

现在，我们将演示在更新操作后，二级缓存可能导致的延迟更新问题。

public class Main {
    public static void main(String[] args) throws IOException {
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession sqlSessionA = sqlSessionFactory.openSession();
        SqlSession sqlSessionB = sqlSessionFactory.openSession();

        try {
            UserMapper userMapperA = sqlSessionA.getMapper(UserMapper.class);
            UserMapper userMapperB = sqlSessionB.getMapper(UserMapper.class);

            // 会话A查询用户，将缓存起来
            User userA = userMapperA.getUserById(1L);
            System.out.println("会话A查询结果：" + userA);

            // 会话B也查询相同的用户
            User userB = userMapperB.getUserById(1L);
            System.out.println("会话B查询结果：" + userB);

            // 会话A更新用户名称
            userA.setName("New Name");
            userMapperA.updateUser(userA);
            sqlSessionA.commit();

            // 会话B再次查询相同的用户
            User userBUpdated = userMapperB.getUserById(1L);
            System.out.println("会话B查询更新后的结果：" + userBUpdated);
        } finally {
            sqlSessionA.close();
            sqlSessionB.close();
        }
    }

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        return new SqlSessionFactoryBuilder().build(inputStream);
    }
}

在上述示例中，我们使用 SqlSessionFactory 创建了两个会话 sqlSessionA 和 sqlSessionB，它们分别执行相同的查询和更新操作。

在会话A中，我们使用 UserMapper 查询id为1的用户，并将结果存储在名为 userA 的对象中。然后，我们输出会话A查询结果。

在会话B中，我们使用相同的 UserMapper 再次查询id为1的用户，并将结果存储在名为 userB 的对象中。然后，我们输出会话B查询结果。

接下来，在会话A中，我们更新 userA 对象的名称，并执行更新操作。然后，我们提交事务。

最后，在会话B中，我们再次查询id为1的用户，并将结果存储在名为 userBUpdated 的对象中。然后，我们输出会话B查询更新后的结果。

运行示例代码，我们可以观察到以下现象：

  • 在会话A查询之后，会话B再次查询相同的数据时，由于使用了二级缓存，因此会直接从缓存中获取到数据，而不是最新的数据库数据。
  • 在会话A更新数据后，会话B再次查询相同的数据时，由于缓存的存在，可能仍然获取到旧的缓存数据，而没有获取到最新的数据库数据。

这就是二级缓存可能导致的延迟更新问题。这对于需要及时获取最新数据的场景来说，可能是一个潜在的风险。

为了解决这个问题，可以采取以下策略：

  1. 可以通过手动清除缓存或者设置合理的刷新策略，确保在更新操作后及时刷新缓存数据。
  2. 根据具体业务需求，评估是否真正需要使用二级缓存。有些场景可能更适合关闭二级缓存，直接从数据库获取最新数据。

需要根据实际情况和具体需求来评估并合理处理二级缓存可能导致的延迟更新问题。

4. 不适用于复杂查询

二级缓存适用于简单且频繁被访问的查询，对于复杂的查询语句、多表关联查询等，缓存的效果可能并不理想。这是因为复杂查询涉及多个表或者多个条件，缓存的命中率较低，反而增加了额外的开销。

MyBatis 的二级缓存主要适用于经常被重复查询的简单查询场景。
对于复杂查询，二级缓存可能会导致缓存的命中率下降，甚至产生错误的结果。因此，在复杂查询的情况下，不建议使用 MyBatis 的二级缓存。

下面是一个示例代码，用于演示在复杂查询场景下，MyBatis 的二级缓存可能产生错误结果的情况。

假设我们有一个 User 类和一个 Order 类，它们之间的关系是一对多。具体代码如下：

public class User {
    private Long id;
    private String name;
    private List<Order> orders;

    // 构造函数、getter 和 setter 方法省略
}

public class Order {
    private Long id;
    private String orderNumber;
    private Long userId;

    // 构造函数、getter 和 setter 方法省略
}

接下来是对应的 UserMapper 接口和 XML 配置文件：

UserMapper.java：

public interface UserMapper {
    User getUserById(Long id);
}

UserMapper.xml：

<mapper namespace="com.example.UserMapper">
    <resultMap id="userResultMap" type="com.example.User">
        <id property="id" column="id" />
        <result property="name" column="name" />
        <collection property="orders" ofType="com.example.Order">
            <id property="id" column="order_id" />
            <result property="orderNumber" column="order_number" />
            <result property="userId" column="user_id" />
        </collection>
    </resultMap>

    <select id="getUserById" resultMap="userResultMap">
        SELECT u.id, u.name, o.id AS order_id, o.order_number, o.user_id
        FROM users u
        LEFT JOIN orders o ON u.id = o.user_id
        WHERE u.id = #{id}
    </select>
</mapper>

现在，我们将演示在复杂查询场景下，二级缓存可能产生错误结果的问题。

public class Main {
    public static void main(String[] args) throws IOException {
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession sqlSessionA = sqlSessionFactory.openSession();
        SqlSession sqlSessionB = sqlSessionFactory.openSession();

        try {
            UserMapper userMapperA = sqlSessionA.getMapper(UserMapper.class);
            UserMapper userMapperB = sqlSessionB.getMapper(UserMapper.class);

            // 会话A查询用户和订单
            User userA = userMapperA.getUserById(1L);
            System.out.println("会话A查询结果：" + userA.getName() + " - " + userA.getOrders());

            // 会话B也查询相同的用户和订单
            User userB = userMapperB.getUserById(1L);
            System.out.println("会话B查询结果：" + userB.getName() + " - " + userB.getOrders());

            // 会话A更新订单状态
            // ...

            // 会话B再次查询相同的用户和订单
            User userBUpdated = userMapperB.getUserById(1L);
            System.out.println("会话B查询更新后的结果：" + userBUpdated.getName() + " - " + userBUpdated.getOrders());
        } finally {
            sqlSessionA.close();
            sqlSessionB.close();
        }
    }

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        return new SqlSessionFactoryBuilder().build(inputStream);
    }
}

在上述示例中，我们使用 UserMapper 查询id为1的用户以及与其关联的订单。分别在会话A和会话B中执行相同的查询操作，并输出结果。

接下来，在会话A中执行一些更新操作（比如更新订单状态），然后提交事务。

最后，在会话B中再次执行相同的查询操作，并输出结果。

运行示例代码，我们可以观察到以下现象：

  • 在会话A查询之后，会话B再次查询相同的数据时，由于使用了二级缓存，因此会直接从缓存中获取到数据，而不是最新的数据库数据。
  • 由于二级缓存无法感知复杂查询中关联数据的变化，因此会导致会话B中的 orders 集合仍然是旧的缓存数据，而不是最新的数据库数据。

这就是在复杂查询场景下，MyBatis 的二级缓存可能产生错误结果的问题。由于二级缓存无法感知关联数据的变化，当关联数据发生更新时，会导致缓存的数据不一致。

针对复杂查询场景，建议关闭 MyBatis 的二级缓存，通过手动清除缓存或设置合理的刷新策略，确保查询结果的准确性。

尽管 MyBatis 提供了二级缓存功能，但在大多数情况下，我们更推荐通过合理优化 SQL 查询、数据库索引等手段来提高性能。如果需要缓存查询结果，可以考虑使用其他缓存方案，如 Redis、Memcached 等，这些方案通常提供更好的可扩展性和缓存管理机制。同时，使用本地缓存（一级缓存）来减少数据库查询次数也是一个不错的选择。综上所述，根据具体场景选择合适的缓存方案是很重要的。

ai_todo
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
深入理解MyBatis中的一级缓存与二级缓存
08-30
主要给大家深入的介绍了关于MyBatis中一级缓存与二级缓存的相关资料，文中详细介绍MyBatis中一级缓存与二级缓存的工作原理及使用，对大家具有一定的参考性学习价值，需要的朋友们下面来一起看看吧。
为什么？Mybatis的一级和二级缓存都不建议使用？
m0_63437643的博客
09-11 197
在这个实验中，我们引入了两张新的表，一张class，一张classroom。通常我们会为每个单表创建单独的映射文件，由于MyBatis的二级缓存是基于namespace的，多表查询语句所在的namspace无法感应到其他namespace中的语句对多表查询中涉及的表进行的修改，引发脏数据问题。sqlSession2更新了id为1的学生的姓名，从凯伦改为了小岑，但sqlSession1之后的查询中，id为1的学生的名字还是凯伦，出现了脏数据，也证明了之前的设想，一级缓存只在数据库会话层面共享。
美团二面：为什么不推荐使用 MyBatis 二级缓存？大部分人都答不上来！
最新发布
浩浩的博客
02-23 848
mybatis缓存
深入了解MyBatis二级缓存
08-26
今天小编就为大家分享一篇关于深入了解MyBatis二级缓存，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
mybatis plus使用redis作为二级缓存的方法
08-25
主要介绍了mybatis plus使用redis作为二级缓存的方法，本文给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
redis与ssm整合方法（mybatis二级缓存）
08-28
本文给大家介绍redis与ssm整合方法（mybatis二级缓存）。主要是利用redis去做mybatis的二级缓存，mybaits映射文件中所有的select都会刷新已有缓存，如果不存在就会新建缓存，所有的insert，update操作都会更新缓存
Mybatis 缓存
YiLynn的博客
05-23 418
Mybatis 缓存优点： 1、易于上手和掌握，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验。 2、sql写在xml里，便于统一管理和优化， 解除sql与程序代码的耦合。 3、提供映射标签，支持对象与数据库的orm字段关系映射 4、 提供对象关系映射标签，支持对象关系组建维护5、提供xml标签，支持编写动态sql。 6、速度相对于Hibernate的速度较快 Myba...
Mybatis二级缓存的缺陷
热门推荐
lixianhe的博客
06-30 1万+
Mybatis二级缓存的缺陷
Mybatis二级缓存应用场景和局限性
qq_40842756的博客
08-25 836
二级缓存应用场景 对查询频率高，变化频率低的数据建议使用二级缓存。 对于访问多的查询请求且用户对查询结果实时性要求不高，此时可采用mybatis二级缓存技术降低数据库访问量，提高访问速度，业务场景比如：耗时较高的统计分析sql、电话账单查询sql等。 实现方法如下： 通过设置刷新间隔时间，由mybatis每隔一段时间自动清空缓存，根据数据变化频率设置缓存刷新间隔flushInterval，比如设置为30分钟、60分钟、24小时等，根据需求而定。 mybatis局限性 mybatis二级缓存对细粒度的数
【MyBatis】为什么不推荐使用 MyBatis 二级缓存
九师兄
11-07 362
仅供自己学习。建议大家去看原文。为了增加查询的性能，mybatis 提供了二级缓存架构，分为一级缓存和二级缓存。这两级缓存最大的区别就是：一级缓存是会话级别的，只要出了这个 SqlSession，缓存就没用了。而二级缓存可以跨会话，多个会话可以使用相同的缓存！一级缓存使用简单，默认就开启。二级缓存需要手动开启，相对复杂，而且要注意的事项也多，否则可能有隐患。
讲讲MyBatis中二级缓存的缺点？
越努力越幸运。
01-09 400
所以，考虑是否要用二级缓存的时候，我们需要综合考虑应用程序的性能需求、数据变化的频率以及数据一致性的要求等等因素。首先，可能会出现数据不一致的问题。因为如果我们在一个地方改了数据，但是缓存里的数据没有及时更新，其他地方拿到的数据就可能是过时的，这样就可能引发错误。还有，如果我们的数据变化不是很频繁，即使缓存里的数据不是最新的，也不会对应用产生太大的影响，这时候也可以考虑用二级缓存。还有，如果我们应用里有很多频繁的写操作，可能会导致缓存一直失效，这样就得不偿失了，可能还会增加数据库的压力。
MyBatis 二级缓存 关联刷新实现
01-20
MyBatis 二级缓存 关联刷新实现1、MyBatis缓存介绍2、二级缓存问题2.1、数据不一致问题验证2.2、问题处理思路3、关联缓存刷新实现 1、MyBatis缓存介绍  Mybatis提供对缓存的支持，但是在没有配置的默认情况下，它只...
Mybatis一级缓存与二级缓存
若鱼的专栏
09-10 781
一级缓存 作用范围是SqlSession，当创建SqlSession的时候，会创建Executor，父类BaseExecutor中有一个localCache，查询结果就是缓存在这个localCache中。 如果SqlSession执行了增删改就会刷新缓存 二级缓存 作用范围是namespace，当框架启动的时候会去解析每一个mapper.xml，一个mapper.xml有一个与之对应的namespace，一个xml中会有多个MappedStatement，每个查询的MappedStatement都会关联一个
Mybaits一级缓存和二级缓存分别是什么，区别是什么
qq_45582730的博客
09-18 1505
Mybaits一级缓存和二级缓存分别是什么，区别是什么
面试官：为什么不推荐使用 MyBatis 二级缓存？
m0_71777195的博客
06-18 359
在查询到结果后，会调用 SqlSession 的 commit 方法进行提交（如果开启事务的话，提交 SqlSession 走的不是这里了，但最终填充二级缓存的地方是一样的。springboot 集成 mybatis 的话，如果没有开启事务，每次执行查询，都会创建新的 SqlSession，所以即使是在同一个方法中进行查询操作，那也是跨会话的。针对这种情况，mybatis通过一级缓存来解决：在同一次查询会话(SqlSession)中如果出现相同的语句及参数，就会从缓存中取出，不再走数据库查询。
Mybatis 为什么不要用二级缓存
baeryu4478的博客
07-30 539
https://www.cnblogs.com/liouwei4083/p/6025929.html mybatis 二级缓存不推荐使用 一 mybatis的缓存使用。 大体就是首先根据你的sqlid，参数的信息自己算出一个key值，然后你查询的时候，会先把这个key值去缓存中找看有没有value，如果有，直接返回出来，就不查询db了。如果没有，那么查询db，然后将key，...
Mybaits一级缓存和二级缓存分别是什么，区别是什么？
qq_52025132的博客
09-17 1885
实现缓存接口，引入第三方缓存引入【Redis等第三方内存库作为mybatis的缓存】。
mybatis二级缓存深入理解
weixin_43832689的博客
06-26 748
mybatis二级缓存深入理解 在我们日常项目中使用，我们常常不会选择使用MyBatis的二级缓存，因为当你不熟悉二级缓存的时候。由于使用不当很容易造成脏读，下面我们就来看看二级缓存的槽点和亮点。 首先我们得知道二级缓存需要做什么 二级缓存(应用级缓存、跨线程)不同于一级缓存(会话级缓存、线程不安全)，所以他的命中率比一级缓存命中率更高 其中二级缓存有几个比较核心的知识点： 1、存储方式： ​ 1)、内存：这是我们最常用的方式，简单快捷；弊端就是不能持久化，并且容量有限。 ​ 2)、硬盘：虽然可以持久化
mybatis一级缓存和二级缓存和三级缓存?
07-11
MyBatis一级缓存和二级缓存区别如下： 一级缓存是SqlSession级别的缓存，当我们发起一次查询时，MyBatis会先到SqlSession缓存中查询是否有这个结果，如果有，直接返回缓存结果，如果没有，就去数据库中查询结果，查询完结果后，将结果放入SqlSession缓存中。 二级缓存是Mapper级别的缓存，当我们发起一次查询时，MyBatis会先到Mapper缓存中查询是否有这个结果，如果有，直接返回缓存结果，如果没有，就去数据库中查询结果，查询完结果后，将结果放入Mapper缓存中。二级缓存通常会开启，但是并不是所有的Mapper都需要开启二级缓存，需要根据具体情况进行配置。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值