精华内容
下载资源
问答
  • MyBatis缓存的使用 MyBatis的缓存分为一级缓存和二级缓存,一级缓存默认是开启的,而且不能关闭 至于一级缓存为什么不能关闭,MyBatis核心开发人员做出了解释:MyBatis的一些关键特性(例如通过<association>...

    MyBatis缓存的使用


    MyBatis的缓存分为一级缓存和二级缓存,一级缓存默认是开启的,而且不能关闭
    至于一级缓存为什么不能关闭,MyBatis核心开发人员做出了解释:MyBatis的一些关键特性(例如通过<association>和建立级联映射、避免循环引用(circular references)、加速重复嵌套查询等)都是基于MyBatis一级缓存实现的,而且 MyBatis结果集 映射相关代码 重度依赖CacheKey,所以目前MyBatis不支持关闭一级缓存

    MyBatis提供了一个配置参数localCacheScope,用于控制一级缓存的级别,该参数的取值为SESSION、STATEMENT
    当指定localCacheScope参数值为SESSION时,缓存对整个SqlSession有效,只有执行DML语句(更新语句)时,缓存才会被清除
    当localCacheScope值为STATEMENT时,缓存仅对当前执行的语句有效,当语句执行完毕后,缓存就会被清空

    MyBatis的一级缓存,用户只能控制缓存的级别,并不能关闭

    MyBatis二级缓存的使用比较简单,只需要以下几步:

    1. 在MyBatis 主配置文件中 指定cacheEnabled属性值为true
      在这里插入图片描述2. 在MyBatis Mapper配置文件中,配置缓存策略、缓存刷新频率、缓存的容量等属性
      在这里插入图片描述3. 在配置Mapper时,通过 useCache属性 指定 Mapper执行时 是否使用缓存。另外,还可以通过flushCache属性指定Mapper执行后是否刷新缓存
      在这里插入图片描述

    通过上面的配置,MyBatis的二级缓存就可以生效了
    执行查询操作时,查询结果 会缓存到 二级缓存中,执行更新操作后,二级缓存会被清空

    展开全文
  • Mybatis缓存

    千次阅读 多人点赞 2021-02-16 15:39:15
    Mybatis缓存缓存的基本概念Mybatis一级缓存证明一级缓存的存在编写用户持久层 Dao 接口编写用户持久层映射文件编写测试方法一级缓存的分析测试一级缓存的清空添加updateUser方法测试缓存的同步Mybatis二级缓存二级...

    缓存的基本概念

    缓存是存在于内存中的临时数据。
    使用缓存减少和数据库的交互次数,提高执行效率。
    适用于缓存:
    (1)经常查询并且不经常改变的。
    (2)数据的正确与否对最终结果影响不大的。
    不适用于缓存:
    (1)经常改变的数据
    (2)数据的正确与否对最终结果影响很大的。
    例如:商品的库存,银行的汇率,股市的牌价。

    Mybatis一级缓存

    一级缓存:
    它指的是Mybatis中SqlSession对象的缓存。
    当我们执行查询之后,查询的结果会同时存入到SqlSession为我们提供一块区域中。
    该区域的结构是一个Map。当我们再次查询同样的数据,mybatis会先去sqlsession中
    查询是否有,有的话直接拿出来用。
    当SqlSession对象消失时,mybatis的一级缓存也就消失了。

    一级缓存是 SqlSession 级别的缓存,只要 SqlSession 没有 flush 或 close,它就存在。

    证明一级缓存的存在

    编写用户持久层 Dao 接口

    IUserDao:

    package com.keafmd.dao;
    import com.keafmd.domain.User;
    import java.util.List;
    
    /**
     * Keafmd
     *
     * @ClassName: IUserDao
     * @Description: 用户的持久层接口
     * @author: 牛哄哄的柯南
     * @date: 2021-02-06 19:29
     */
    
    public interface IUserDao {
        /**
         * 查询所有用户,同时获取到用户下所有账户的信息
         * @return
         */
        List<User> findAll();
    
    
        /**
         * 根据id查新用户信息
         * @param id
         * @return
         */
        User findById(Integer id);
    
    }
    

    编写用户持久层映射文件

    IUserDao.xml:

    <?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.keafmd.dao.IUserDao">
    
    
        <!--配置查询所有-->
        <select id="findAll" resultType="user">
            select * from user
        </select>
    
        <!--根据id查询用户-->
        <select id="findById" parameterType="Integer" resultType="user">
            select * from user where id = #{id}
        </select>
    
    </mapper>
    

    编写测试方法

    MybatisTest:

    package com.keafmd.test;
    
    import com.keafmd.dao.IUserDao;
    import com.keafmd.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.List;
    
    /**
     * Keafmd
     *
     * @ClassName: MybatisTest
     * @Description: 测试类,测试crud操作
     * @author: 牛哄哄的柯南
     * @date: 2021-02-08 15:24
     */
    public class UserTest {
    
        private InputStream in;
        private SqlSessionFactory factory;
        private SqlSession sqlSession;
        private IUserDao userDao;
    
        @Before // 用于在测试方法执行前执行
        public void init()throws Exception{
            //1.读取配置文件,生成字节输入流
            in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.创建SqlSessionFactory工厂
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            factory = builder.build(in);
            //3.使用工厂生产SqlSession对象
            sqlSession = factory.openSession(true); //里面写个true,下面每次就不用了写 sqlsession.commit(); 了
            //4.使用SqlSession创建Dao接口的代理对象
            userDao = sqlSession.getMapper(IUserDao.class);
        }
    
        @After // 用于在测试方法执行后执行
        public void destory() throws Exception{
            //提交事务
            //sqlSession.commit();
            //6.释放资源
            sqlSession.close();
            in.close();
        }
    
    
        /**
         * 测试一级缓存
         */
        @Test
        public void testFirstLevelCache(){
            User user1 = userDao.findById(41);
            System.out.println(user1);
            User user2 = userDao.findById(41);
            System.out.println(user2);
            System.out.println(user1==user2);
        }
    
    }
    

    运行结果:

    2021-02-16 15:52:44,863 359    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
    2021-02-16 15:52:45,164 660    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 905735620.
    2021-02-16 15:52:45,168 664    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==>  Preparing: select * from user where id = ?
    2021-02-16 15:52:45,200 696    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==> Parameters: 41(Integer)
    2021-02-16 15:52:45,227 723    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - <==      Total: 1
    com.keafmd.domain.User@400cff1a
    com.keafmd.domain.User@400cff1a
    true
    

    我们可以看到,只发起了一次查询,相当于第一次是查询,而第二次是从缓存中取得。

    一级缓存的分析

    一级缓存是 SqlSession 范围的缓存,当调用 SqlSession 的修改,添加,删除,commit(),close()等方法时,就会清空一级缓存。

    举个例子:
    在这里插入图片描述
    第一次发起查询用户 id 为 1 的用户信息,先去找缓存中是否有 id 为 1 的用户信息,如果没有,从数据库查询用户信息。
    得到用户信息,将用户信息存储到一级缓存中。
    如果 sqlSession 去执行 commit 操作(执行插入、更新、删除),清空 SqlSession 中的一级缓存,这样做的目的为了让缓存中存储的是最新的信息,避免脏读。
    第二次发起查询用户 id 为 1 的用户信息,先去找缓存中是否有 id 为 1 的用户信息,缓存中有,直接从缓存中获取用户信息。

    测试一级缓存的清空

    改变下测试代码:

    /**
     * 测试一级缓存
     */
    @Test
    public void testFirstLevelCache(){
        User user1 = userDao.findById(41);
        System.out.println(user1);
    
        /*sqlSession.close();
    
        //再次获取sqlSession对象
        sqlSession = factory.openSession();*/
    
        sqlSession.clearCache();//此方法也可以清空缓存
    
        userDao = sqlSession.getMapper(IUserDao.class);
    
        User user2 = userDao.findById(41);
        System.out.println(user2);
    
        System.out.println(user1==user2);
    }
    

    运行结果:

    2021-02-16 16:14:57,171 194    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
    2021-02-16 16:14:57,498 521    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 93314457.
    2021-02-16 16:14:57,503 526    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==>  Preparing: select * from user where id = ?
    2021-02-16 16:14:57,541 564    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==> Parameters: 41(Integer)
    2021-02-16 16:14:57,560 583    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - <==      Total: 1
    com.keafmd.domain.User@57175e74
    2021-02-16 16:14:57,561 584    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==>  Preparing: select * from user where id = ?
    2021-02-16 16:14:57,561 584    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==> Parameters: 41(Integer)
    2021-02-16 16:14:57,562 585    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - <==      Total: 1
    com.keafmd.domain.User@c540f5a
    false
    2021-02-16 16:14:57,563 586    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@58fdd99]
    2021-02-16 16:14:57,563 586    [           main] DEBUG source.pooled.PooledDataSource  - Returned connection 93314457 to pool.
    
    Process finished with exit code 0
    

    我们可以看到这样就发起了两次查询,我们用这两种方式都可以清空缓存。

    添加updateUser方法

    IUserDao:

    package com.keafmd.dao;
    import com.keafmd.domain.User;
    import java.util.List;
    
    /**
     * Keafmd
     *
     * @ClassName: IUserDao
     * @Description: 用户的持久层接口
     * @author: 牛哄哄的柯南
     * @date: 2021-02-06 19:29
     */
    
    public interface IUserDao {
        /**
         * 查询所有用户,同时获取到用户下所有账户的信息
         * @return
         */
        List<User> findAll();
    
    
        /**
         * 根据id查新用户信息
         * @param id
         * @return
         */
        User findById(Integer id);
    
        /**
         * 更新用户信息
         * @param user
         */
        void updateUser(User user);
    
    
    }
    

    IUserDao.xml:

    <?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.keafmd.dao.IUserDao">
    
        <!--配置查询所有-->
        <select id="findAll" resultType="user">
            select * from user
        </select>
    
        <!--根据id查询用户-->
        <select id="findById" parameterType="Integer" resultType="user">
            select * from user where id = #{id}
        </select>
    
        <!--更新用户信息-->
        <select id="updateUser"  resultType="user">
            update user set username=#{username},address=#{address} where id=#{id}
        </select>
    
    </mapper>
    

    测试缓存的同步

    UserTest:

    package com.keafmd.test;
    
    import com.keafmd.dao.IUserDao;
    import com.keafmd.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.List;
    
    /**
     * Keafmd
     *
     * @ClassName: MybatisTest
     * @Description: 测试类
     * @author: 牛哄哄的柯南
     * @date: 2021-02-08 15:24
     */
    public class UserTest {
    
        private InputStream in;
        private SqlSessionFactory factory;
        private SqlSession sqlSession;
        private IUserDao userDao;
    
        @Before // 用于在测试方法执行前执行
        public void init()throws Exception{
            //1.读取配置文件,生成字节输入流
            in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.创建SqlSessionFactory工厂
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            factory = builder.build(in);
            //3.使用工厂生产SqlSession对象
            sqlSession = factory.openSession(true); //里面写个true,下面每次就不用了写 sqlsession.commit(); 了
            //4.使用SqlSession创建Dao接口的代理对象
            userDao = sqlSession.getMapper(IUserDao.class);
        }
    
        @After // 用于在测试方法执行后执行
        public void destory() throws Exception{
            //提交事务
            //sqlSession.commit();
            //6.释放资源
            sqlSession.close();
            in.close();
        }
    
    
        /**
         * 测试一级缓存
         */
        @Test
        public void testFirstLevelCache(){
            User user1 = userDao.findById(41);
            System.out.println(user1);
    
            /*sqlSession.close();
    
            //再次获取sqlSession对象
            sqlSession = factory.openSession();*/
    
            sqlSession.clearCache();//此方法也可以清空缓存
    
            userDao = sqlSession.getMapper(IUserDao.class);
    
            User user2 = userDao.findById(41);
            System.out.println(user2);
    
            System.out.println(user1==user2);
        }
    
        /**
         * 测试缓存的同步
         */
        @Test
        public void testClearCache(){
            //1.根据id查询用户
            User user1 = userDao.findById(41);
            System.out.println(user1);
    
            //2.更新用户信息
            user1.setUsername("update user clear cache");
            user1.setAddress("上海");
            userDao.updateUser(user1);
    
            //手动提交
            sqlSession.commit();
    
            //3.再次查询id为41的用户
            User user2 = userDao.findById(41);
            System.out.println(user2);
    
            System.out.println(user1==user2);
        }
    
    
    }
    

    运行testClearCache():

    2021-02-16 16:13:04,277 209    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
    2021-02-16 16:13:04,560 492    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 93314457.
    2021-02-16 16:13:04,565 497    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==>  Preparing: select * from user where id = ?
    2021-02-16 16:13:04,618 550    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==> Parameters: 41(Integer)
    2021-02-16 16:13:04,645 577    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - <==      Total: 1
    com.keafmd.domain.User@57175e74
    2021-02-16 16:13:04,646 578    [           main] DEBUG keafmd.dao.IUserDao.updateUser  - ==>  Preparing: update user set username=?,address=? where id=?
    2021-02-16 16:13:04,646 578    [           main] DEBUG keafmd.dao.IUserDao.updateUser  - ==> Parameters: update user clear cache(String), 上海(String), 41(Integer)
    2021-02-16 16:13:04,647 579    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==>  Preparing: select * from user where id = ?
    2021-02-16 16:13:04,648 580    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==> Parameters: 41(Integer)
    2021-02-16 16:13:04,649 581    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - <==      Total: 1
    com.keafmd.domain.User@c540f5a
    false
    2021-02-16 16:13:04,650 582    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@58fdd99]
    2021-02-16 16:13:04,650 582    [           main] DEBUG source.pooled.PooledDataSource  - Returned connection 93314457 to pool.
    
    Process finished with exit code 0
    

    我们在第一次查询后进行的更新操作,所以会清空一级缓存,然后第二次会在进行查询。

    Mybatis二级缓存

    二级缓存:
    它指的是Mybatis中SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。
    二级缓存的使用步骤:
    第一步:让Mybatis框架支持二级缓存(在SqlMapConfig.xml中配置)
    第二步:让当前的映射文件支持二级缓存(在IUserDao.xml中配置)
    第三步:让当前的操作支持二级缓存(在select标签中配置)
    二级缓存是 mapper 映射级别的缓存,多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句,多个SqlSession 可以共用二级缓存,二级缓存是跨 SqlSession 的。

    二级缓存结构图

    在这里插入图片描述
    首先开启 mybatis 的二级缓存。
    sqlSession1 去查询用户信息,查询到用户信息会将查询数据存储到二级缓存中。
    如果 SqlSession3 去执行相同 mapper 映射下 sql,执行 commit 提交,将会清空该 mapper 映射下的二级缓存区域的数据。
    sqlSession2 去查询与 sqlSession1 相同的用户信息,首先会去缓存中找是否存在数据,如果存在直接从缓存中取出数据。

    二级缓存的开启与关闭

    第一步:在 SqlMapConfig.xml 文件开启二级缓存

    <settings>
        <!--开启二级缓存的支持-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
    

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

    第二步:配置相关的 Mapper 映射文件

    IUserDao.xml:

    <?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.keafmd.dao.IUserDao">
    
    
        <!--开启user支持二级缓存-->
        <cache/>
    
        <!--配置查询所有-->
        <select id="findAll" resultType="user">
            select * from user
    
        </select>
    
        <!--根据id查询用户-->
        <select id="findById" parameterType="Integer" resultType="user" useCache="true">
            select * from user where id = #{id}
        </select>
    
        <!--更新用户信息-->
        <select id="updateUser"  resultType="user">
            update user set username=#{username},address=#{address} where id=#{id}
        </select>
    
    
    </mapper>
    

    第三步:配置 statement 上面的 useCache 属性

    <!--根据id查询用户-->
    <select id="findById" parameterType="Integer" resultType="user" useCache="true">
        select * from user where id = #{id}
    </select>
    

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

    二级缓存测试

    SecondLevelCacheTest:

    package com.keafmd.test;
    
    import com.keafmd.dao.IUserDao;
    import com.keafmd.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;
    
    /**
     * Keafmd
     *
     * @ClassName: MybatisTest
     * @Description: 测试类,测试crud操作
     * @author: 牛哄哄的柯南
     * @date: 2021-02-08 15:24
     */
    public class SecondLevelCacheTest {
    
        private InputStream in;
        private SqlSessionFactory factory;
    
    
        @Before // 用于在测试方法执行前执行
        public void init()throws Exception{
            //1.读取配置文件,生成字节输入流
            in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.创建SqlSessionFactory工厂
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            factory = builder.build(in);
    
        }
    
        @After // 用于在测试方法执行后执行
        public void destory() throws Exception{
    
            in.close();
        }
    
    
        /**
         * 测试二级缓存
         */
        @Test
        public void testSecondLevelCache(){
            SqlSession sqlSession1 = factory.openSession();
            IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);
            User user1 = dao1.findById(41);
            System.out.println(user1);
            sqlSession1.close(); //一级缓存消失
    
            SqlSession sqlSession2 = factory.openSession();
            IUserDao dao2 = sqlSession2.getMapper(IUserDao.class);
            User user2 = dao2.findById(41);
            System.out.println(user2);
            sqlSession2.close();
    
            System.out.println(user1==user2);
        }
    
    }
    

    运行结果:

    2021-02-16 17:07:05,474 179    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
    2021-02-16 17:07:05,723 428    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 905735620.
    2021-02-16 17:07:05,723 428    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@35fc6dc4]
    2021-02-16 17:07:05,726 431    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==>  Preparing: select * from user where id = ?
    2021-02-16 17:07:05,752 457    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==> Parameters: 41(Integer)
    2021-02-16 17:07:05,770 475    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - <==      Total: 1
    com.keafmd.domain.User@400cff1a
    2021-02-16 17:07:05,777 482    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@35fc6dc4]
    2021-02-16 17:07:05,778 483    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@35fc6dc4]
    2021-02-16 17:07:05,778 483    [           main] DEBUG source.pooled.PooledDataSource  - Returned connection 905735620 to pool.
    2021-02-16 17:07:05,782 487    [           main] DEBUG        com.keafmd.dao.IUserDao  - Cache Hit Ratio [com.keafmd.dao.IUserDao]: 0.5
    com.keafmd.domain.User@75c072cb
    false
    
    Process finished with exit code 0
    

    经过上面的测试,我们发现执行了两次查询,并且在执行第一次查询后,我们关闭了一级缓存,再去执行第二次查询时,我们发现并没有对数据库发出 sql 语句,所以此时的数据就只能是来自于我们所说的二级缓存。
    注意:二级缓存中存放的内容是数据,而不是对象,内容虽然是同样的,但是存放的是数据,第二次虽然没有发起查询,但从二级缓存中获取时,会把内容封装到新的对象返回,所以是false。

    二级缓存注意事项

    当我们在使用二级缓存时,所缓存的类一定要实现 java.io.Serializable 接口,这种就可以使用序列化方式来保存对象。

    User:

    package com.keafmd.domain;
    
    import java.io.Serializable;
    import java.util.Date;
    import java.util.List;
    
    /**
     * Keafmd
     *
     * @ClassName: User
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-02-08 15:16
     */
    
    public class User implements Serializable {
        private Integer id;
        private String username;
        private String sex;
        private String address;
        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 getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public Date getBirthday() {
            return birthday;
        }
    
        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }
    
    }
    

    以上就是Mybatis缓存的全部内容。

    看完如果对你有帮助,感谢点赞支持!
    如果你是电脑端的话,看到右下角的 “一键三连” 了吗,没错点它[哈哈]

    在这里插入图片描述

    加油!

    共同努力!

    Keafmd

    展开全文
  • mybatis缓存

    2019-09-18 05:20:01
    mybatis缓存接口定义 mybatis缓存是啥? 说白了就是个键值对容器,可以保存数据、查询数据、删除数据、清空缓存、获取缓存数据数量等。 【注】 mybatis中缓存的key对象值是:org.apache.ibatis.cache.CacheKey. ...

    mybatis缓存接口定义

    mybatis缓存是啥?
    说白了就是个键值对容器,可以保存数据、查询数据、删除数据、清空缓存、获取缓存数据数量等。

    mybatis缓存
    【注】

    • mybatis中缓存的key对象值是:org.apache.ibatis.cache.CacheKey.
    • mybatis缓存接口实现类必须有这样一个构造函数:XXX(String id) id代表缓存的唯一标识符
    • mybatis将命名空间作为缓存的唯一标识符

      mybatis提供的缓存

      mybatis缓存

      mybatis提供的11种缓存,应用了典型的"装饰器模式".

    展开全文
  • Mybatis缓存配置

    千次阅读 2017-04-27 16:36:05
    Mybatis缓存配置 Mybatis缓存配置 Mybatis缓存配置 Mybatis缓存配置 Mybatis缓存配置 Mybatis缓存配置

    pom文件配置:

    <dependency>
    	<groupId>org.mybatis</groupId>
    	<artifactId>mybatis</artifactId>
    	<version>3.4.1</version>
    </dependency>
    <dependency>
    	<groupId>org.mybatis</groupId>
    	<artifactId>mybatis-spring</artifactId>
    	<version>1.3.0</version>
    </dependency>
    <dependency>
    	<groupId>org.mybatis.caches</groupId>
    	<artifactId>mybatis-ehcache</artifactId>
    	<version>1.1.0</version>
    </dependency>
    <dependency>
    	<groupId>net.sf.ehcache</groupId>
    	<artifactId>ehcache-core</artifactId>
    	<version>2.5.3</version>
    </dependency>


    展开全文
  • MyBatis缓存

    千次阅读 2019-09-25 10:57:35
    MyBatis提供查询缓存,用于减轻数据库压力,提高性能。MyBatis提供了一级缓存和二级缓存。 一级缓存是SqlSession级别的缓存,每个SqlSession对象都有一个哈希表用于缓存数据,不同SqlSession对象之间缓存不共享。同...
  • 像大多数的持久化框架一样,Mybatis 也提供了缓存策略,通过缓存策略来减少数据库的查询次数,从而提高性能 Mybatis缓存分为一级缓存,二级缓存 Mybatis 一级缓存 Mybatis 二级缓存 ...
  • Mybatis 缓存

    2020-05-09 13:06:09
    像大多数的持久化框架一样, Mybatis 也提供了缓存策略,通过缓存策略来减少数据库的查询次数, 从而提高性能。 Mybatis缓存分为一级缓存,二级缓存。 文章目录一、Mybatis 一级缓存二、Mybatis 二级缓存 一、...
  • mybatis缓存配置

    千次阅读 2018-05-25 18:10:45
    mybatis缓存使示意图:一、一级缓存说明:其中一级缓存是mybatis默认使用的缓存,无需手动配置,二级缓存需要手动配置;一级缓存失效条件1)sqlSession不同,由于一级缓存是基于sqlSession级别的,所以当使用不同sq.....
  • MyBatis 缓存

    2016-04-04 18:53:02
    Mybatis一级、二级缓存 使用详解http://www.mamicode.com/info-detail-890951.html为何禁用MyBatis缓存http://www.codeweblog.com/%E4%B8%BA%E4%BD%95%E7%A6%81%E7%94%A8mybatis%E7%BC%93%E5%AD%98/
  • 文章目录MyBatis缓存机制Spring+MyBatis开启二级缓存1. 创建MyBatis核心配置文件,在settings中开启二级缓存2. 在spring的核心配置文件中,sqlSessionFactory的bean中,将mybatis的配置粘入3. 在mapper.xml映射文件...
  • MyBatis缓存分为一级缓存和二级缓存一级缓存,本文给大家介绍mybatis缓存知识,非常不错具有参考借鉴价值,感兴趣的朋友一起学习吧
  • mybatis 缓存

    2017-06-28 09:20:21
    再使用mybatis开发的时候,有时候需要手动清楚mybatis 缓存,调用clearCache()即可,以整合了Spring mybatis 为例: SqlSessionUtils.getSqlSession(...
  • MyBatis缓存机制原理

    千次阅读 2017-11-14 10:45:09
    mybatis 缓存原理,mybatis缓存机制,mybatis 一级缓存 二级缓存。mybatis理解
  • MyBatis 缓存机制

    万次阅读 多人点赞 2017-04-28 15:52:12
    MyBatis 提供了查询缓存缓存数据,以提高查询的性能。MyBatis缓存分为一级缓存和二级缓存。 一级缓存是 SqlSession 级别的缓存 二级缓存是 mapper 级别的缓存,多个 SqlSession 共享
  • MyBatis缓存配置

    千次阅读 2016-06-29 17:47:31
    1. Mybatis缓存简介Mybatis提供功能强大的缓存机制。缓存共可以分为两类:一级缓存和二级缓存。一级缓存是SqlSession级别的,二级缓存为整个应用级别,即一个数据源级别。缓存的具体实现可以有以下几种方式: [x] ...
  • 5. MyBatis 缓存

    2021-09-03 22:36:29
    1. 什么是MyBatis缓存 上文介绍的 MyBatis 延迟加载,解决的是多表关联查询情况下的效率问题,但是对于单表查询,延迟加载没有作用,MyBatis 提供了缓存机制来解决单表查询情况下的效率问题。 使用缓存也是通过减少 ...
  • MyBatis缓存(一级缓存、二级缓存)
  • Mybatis缓存机制

    2016-11-09 21:20:55
    Mybatis缓存机制 一.什么是Mybatis的缓存机制 缓存的概念简而言之就是临时存放在本机的数据。为什么需要缓存机制呢,因为链接数据库的资源很珍贵,而且如果每次查询数据都需要访问数据库的话会很费时,且效率不高...
  • mybatis缓存机制.pdf

    2021-08-10 13:32:07
    mybatis缓存机制.pdf

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 103,323
精华内容 41,329
关键字:

mybatis缓存是什么