SpringBoot-Redis联合Mybatis实现分布式缓存

最新推荐文章于 2023-12-10 18:52:19 发布
最新推荐文章于 2023-12-10 18:52:19 发布
阅读量157 收藏
点赞数
分类专栏： redis 文章标签： spring boot redis mybatis mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39309802/article/details/113575738
版权
配置文件
spring.datasource.druid.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.druid.username=root
spring.datasource.druid.password=sunyue
spring.datasource.druid.initial-size=1
spring.datasource.druid.min-idle=1
spring.datasource.druid.max-active=20
spring.datasource.druid.test-on-borrow=true
spring.datasource.druid.driver-class-name=com.mysql.jdbc.Driver
mybatis.type-aliases-package=com.sunyue.test.entity
mybatis.mapper-locations=classpath:mapper/*.xml
#打印数据库的操作
logging.level.com.sunyue.test.dao=debug
#redis缓存
### 配置Redis
mybatis.configuration.cache-enabled=true
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=152.136.30.116
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=sunyue
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-idle=200
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=1000
缓存实体类

这是我们要向Redis中缓存的对象

package com.sunyue.test.entity;

import lombok.Data;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.util.Date;

@Data
@Accessors(chain = true)
public class TestUser implements Serializable {
    private String id;
    private String name;
    private Integer age;
    private Date bir;
}
Mybatis Dao & Mapper
package com.sunyue.test.dao;

import com.sunyue.test.entity.TestUser;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface TestUserMapper {
    List<TestUser> findAll();

    TestUser selectOne(String id);

    void insert(TestUser testUser);

    void update(TestUser testUser);

    void delete(String id);
}

Mapper:
直接启用Mybatis的<-cache>标签，缓存是本机缓存，所以我们需要实现自定义Redis缓存

<?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.sunyue.test.dao.TestUserMapper">
    <!--  开启二级缓存 需要entity开启序列化 type指定自定义缓存策略 -->
    <cache type="com.sunyue.test.redis.RedisCache"/>
    <!-- 关联查询时，需要保证各方缓存的数据都是最新的，采用共享缓存方案 -->
    <!--  <cache-ref namespace="com.junsir.dao.PersonDao"/>-->
    <select id="findAll"  resultType="TestUser">
       select * from test_user
    </select>
    <select id="selectOne" resultType="TestUser">
       select * from test_user where id=#{id}
    </select>

    <insert id="insert">
        insert into test_user (id,name,age,bir) value (#{id},#{name},#{age},#{bir})
    </insert>
    <update id="update" parameterType="com.sunyue.test.entity.TestUser">
		update test_user set name = #{name},age=#{age},bir=#{bir} where id = #{id}
	</update>
    <delete id="delete">
		delete from test_user where id = #{id}
	</delete>
</mapper>
RedisCache.java：

此类需要实现org.apache.ibatis.cache.Cache接口，才可以在Mapper中进行指定

package com.sunyue.test.redis;

import com.sunyue.test.utils.ApplicationContextUtils;
import org.apache.ibatis.cache.Cache;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.util.DigestUtils;

import java.util.concurrent.locks.ReadWriteLock;

/**
 * 本类由mybatis初始化 启动时并无法由spring容器管理（盲猜参数无法传递id），故无法注入拿到RedisTemplate
 * 要拿到RedisTemplate 需要动下工厂 在工厂启动时拿到RedisTemplate
 *
 * 实现细节:
 * 多表关联查询下的内容保持最新 - 由于DB增删改只会使Redis清空对应key的缓存 所以目的就是让有关联的缓存数据同时进同时出
 *
 * 实现完毕之后的优化问题:
 * 1.key过长会影响redis性能，采用MD5算法对key进行处理，这里利用的是MD5加密算法的唯一性
 * */
public class RedisCache implements Cache {

    //自定义Cache必要条件
    private final String id;

    //根据断点 : id:mapper的namespace
    public RedisCache(String id) {
        this.id = id;
    }

    //返回cache的唯一标识
    @Override
    public String getId() {
        return this.id;
    }

    //重点实现 加入缓存
    @Override
    public void putObject(Object key, Object value) {
        System.out.println("加入缓存：key================》" + key + "值:value ===================》" + value);
        RedisTemplate redisTemplate = getRedisTemplate();
        redisTemplate.opsForHash().put(id.toString(),keyToMd5(key.toString()),value);
    }

    //重点实现 查询缓存
    @Override
    public Object getObject(Object key) {
        System.out.println("查询缓存：key================》" + key );
        RedisTemplate redisTemplate = getRedisTemplate();
        return redisTemplate.opsForHash().get(id.toString(),keyToMd5(key.toString()));
    }

    //根据指定的key删除缓存 目前没有实现
    @Override
    public Object removeObject(Object o) {
        return null;
    }

    //清空缓存 执行增删改的时候都会进行clear
    @Override
    public void clear() {
        System.out.println("清空缓存");
        RedisTemplate redisTemplate = getRedisTemplate();
        //清空缓存
        redisTemplate.delete(id.toString());
    }

    //计算缓存数量
    @Override
    public int getSize() {

        RedisTemplate redisTemplate = getRedisTemplate();
        //获取哈希中的键值对数量
        return redisTemplate.opsForHash().size(id.toString()).intValue();
    }

    @Override
    public ReadWriteLock getReadWriteLock() {
        return null;
    }

    //统一加工redisTemplate 并返回
    private RedisTemplate getRedisTemplate(){
        //获取redisTemplate
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        //设置序列化策略,因为设置了RedisConfig实例
/*        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());*/
        return redisTemplate;
    }


    //优化: 对key做MD5处理
    private String keyToMd5(String key){
        return  DigestUtils.md5DigestAsHex(key.getBytes());
    }

}
redis序列化
package com.sunyue.test.redis;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {
    /**
     * 由于原生的redis自动装配，在存储key和value时，没有设置序列化方式，故自己创建redisTemplate实例
     * redis的默认方式是JdkSerializationRedisSerializer，key和value都是JdkSerializationRedisSerializer方式的序列化，好处是可以直接支持Object
     * 但是如果需要取值则需要序列化  1) "\xac\xed\x00\x05t\x00\"com.sunyue.test.dao.TestUserMapper"（没有序列化时）
     *                               2) "com.sunyue.test.dao.TestUserMapper"（序列化好的）
     *  RedisTemplate<Object, Object> ==> RedisTemplate<String, Object(通常需要key为String，则key设置为stringRedisSerializer这样，值不需要)
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 使用StringRedisSerializer来序列化/反序列化redis的key值
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}
业务层server实现
package com.sunyue.test.server.serverImpl;

import com.sunyue.test.dao.TestUserMapper;
import com.sunyue.test.entity.TestUser;
import com.sunyue.test.server.TestUserServer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service

public class TestUserServerImpl implements TestUserServer {
    @Autowired
    private TestUserMapper testUserMapper;

    @Override
    @Transactional
    public List<TestUser> selectAll() {
        return testUserMapper.findAll();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public TestUser selectByOne(String id){
        return testUserMapper.selectOne(id);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void insert(TestUser testUser) {
        testUserMapper.insert(testUser);
        //推荐：在业务层将异常抛出
/*        throw new RuntimeException("添加发生异常了..");*/
    }

    @Override
    public void delete(String id) {
        testUserMapper.delete(id);
    }

    @Override
    public void update(TestUser testUser) {
        testUserMapper.update(testUser);
    }
}
测试类
import com.sunyue.test.TestApplication;
import com.sunyue.test.entity.TestUser;
import com.sunyue.test.server.TestUserServer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Date;
import java.util.List;
import java.util.UUID;

@SpringBootTest(classes = TestApplication.class)
@RunWith(SpringRunner.class)
public class RedisTest {
    @Autowired
    private TestUserServer testUserServer;

    @Test
    public void redisTest() {
        TestUser testUser = new TestUser();
        testUser.setId(UUID.randomUUID().toString());
        testUser.setName("孙跃");
        testUser.setBir(new Date());
        testUser.setAge(24);
        testUserServer.insert(testUser);
        TestUser testUser1 = new TestUser();
        testUser1.setId(UUID.randomUUID().toString());
        testUser1.setName("孙越");
        testUser1.setBir(new Date());
        testUser1.setAge(22);
        testUserServer.insert(testUser1);
    }
    @Test
    public void delete(){
        testUserServer.delete("93bc9818-a1fd-4012-9f75-f15d6653f912");
    }
    @Test
    public void update(){
        TestUser testUser = new TestUser();
        testUser.setId("1a88f8dc-b9aa-45cf-af53-38e5a6d52b38");
        testUser.setName("孙跃1w");
        testUser.setBir(new Date());
        testUser.setAge(18);
        testUserServer.update(testUser);
    }
    @Test
    public void select() {
        List<TestUser> testUsers = testUserServer.selectAll();
        testUsers.forEach(System.out::println);
        System.out.println(testUserServer.selectByOne("1a88f8dc-b9aa-45cf-af53-38e5a6d52b38"));
    }
}
log查看

insert方法：

2020-12-01 21:44:25.300  INFO 3424 --- [           main] RedisTest                                : Started RedisTest in 3.349 seconds (JVM running for 3.94)
2020-12-01 21:44:25.416 DEBUG 3424 --- [           main] c.sunyue.test.dao.TestUserMapper.insert  : ==>  Preparing: insert into test_user (id,name,age,bir) value (?,?,?,?) 
2020-12-01 21:44:25.439 DEBUG 3424 --- [           main] c.sunyue.test.dao.TestUserMapper.insert  : ==> Parameters: 5d7af197-a25e-418a-a087-7717bd5d4483(String), 孙跃(String), 24(Integer), 2020-12-01 21:44:25.379(Timestamp)
2020-12-01 21:44:25.446 DEBUG 3424 --- [           main] c.sunyue.test.dao.TestUserMapper.insert  : <==    Updates: 1
清空缓存
2020-12-01 21:44:25.510  INFO 3424 --- [           main] io.lettuce.core.EpollProvider            : Starting without optional epoll library
2020-12-01 21:44:25.510  INFO 3424 --- [           main] io.lettuce.core.KqueueProvider           : Starting without optional kqueue library
2020-12-01 21:44:25.794 DEBUG 3424 --- [           main] c.sunyue.test.dao.TestUserMapper.insert  : ==>  Preparing: insert into test_user (id,name,age,bir) value (?,?,?,?) 
2020-12-01 21:44:25.794 DEBUG 3424 --- [           main] c.sunyue.test.dao.TestUserMapper.insert  : ==> Parameters: 07222415-adc0-4117-8f85-4a19ea0633d2(String), 孙越(String), 22(Integer), 2020-12-01 21:44:25.792(Timestamp)
2020-12-01 21:44:25.794 DEBUG 3424 --- [           main] c.sunyue.test.dao.TestUserMapper.insert  : <==    Updates: 1
清空缓存
2020-12-01 21:44:25.843  INFO 3424 --- [       Thread-5] o.s.w.c.s.GenericWebApplicationContext   : Closing org.springframework.web.context.support.GenericWebApplicationContext@1f760b47: startup date [Tue Dec 01 21:44:22 CST 2020]; root of context hierarchy
2020-12-01 21:44:26.976  INFO 3424 --- [       Thread-5] com.alibaba.druid.pool.DruidDataSource   : {dataSource-1} closed

update方法：

2020-12-01 21:45:38.336  INFO 10076 --- [           main] RedisTest                                : Started RedisTest in 3.47 seconds (JVM running for 4.07)
2020-12-01 21:45:38.457 DEBUG 10076 --- [           main] c.sunyue.test.dao.TestUserMapper.update  : ==>  Preparing: update test_user set name = ?,age=?,bir=? where id = ? 
2020-12-01 21:45:38.487 DEBUG 10076 --- [           main] c.sunyue.test.dao.TestUserMapper.update  : ==> Parameters: 孙跃1w(String), 18(Integer), 2020-12-01 21:45:38.427(Timestamp), 1a88f8dc-b9aa-45cf-af53-38e5a6d52b38(String)
2020-12-01 21:45:38.497 DEBUG 10076 --- [           main] c.sunyue.test.dao.TestUserMapper.update  : <==    Updates: 1
清空缓存
2020-12-01 21:45:38.568  INFO 10076 --- [           main] io.lettuce.core.EpollProvider            : Starting without optional epoll library
2020-12-01 21:45:38.568  INFO 10076 --- [           main] io.lettuce.core.KqueueProvider           : Starting without optional kqueue library
2020-12-01 21:45:38.852  INFO 10076 --- [       Thread-5] o.s.w.c.s.GenericWebApplicationContext   : Closing org.springframework.web.context.support.GenericWebApplicationContext@1f760b47: startup date [Tue Dec 01 21:45:35 CST 2020]; root of context hierarchy
2020-12-01 21:45:39.986  INFO 10076 --- [       Thread-5] com.alibaba.druid.pool.DruidDataSource   : {dataSource-1} closed

delete方法：

2020-12-01 21:46:29.897  INFO 6072 --- [           main] RedisTest                                : Started RedisTest in 3.391 seconds (JVM running for 3.992)
2020-12-01 21:46:30.009 DEBUG 6072 --- [           main] c.sunyue.test.dao.TestUserMapper.delete  : ==>  Preparing: delete from test_user where id = ? 
2020-12-01 21:46:30.029 DEBUG 6072 --- [           main] c.sunyue.test.dao.TestUserMapper.delete  : ==> Parameters: 1a88f8dc-b9aa-45cf-af53-38e5a6d52b38(String)
2020-12-01 21:46:30.036 DEBUG 6072 --- [           main] c.sunyue.test.dao.TestUserMapper.delete  : <==    Updates: 1
清空缓存
2020-12-01 21:46:30.098  INFO 6072 --- [           main] io.lettuce.core.EpollProvider            : Starting without optional epoll library
2020-12-01 21:46:30.098  INFO 6072 --- [           main] io.lettuce.core.KqueueProvider           : Starting without optional kqueue library
2020-12-01 21:46:30.389  INFO 6072 --- [       Thread-5] o.s.w.c.s.GenericWebApplicationContext   : Closing org.springframework.web.context.support.GenericWebApplicationContext@1f760b47: startup date [Tue Dec 01 21:46:26 CST 2020]; root of context hierarchy
2020-12-01 21:46:31.522  INFO 6072 --- [       Thread-5] com.alibaba.druid.pool.DruidDataSource   : {dataSource-1} closed

select方法：

2020-12-01 21:48:13.949  INFO 2924 --- [           main] RedisTest                                : Started RedisTest in 3.355 seconds (JVM running for 3.974)
查询缓存：key================》448135888:3833733049:com.sunyue.test.dao.TestUserMapper.findAll:0:2147483647:select * from test_user:SqlSessionFactoryBean
2020-12-01 21:48:14.130  INFO 2924 --- [           main] io.lettuce.core.EpollProvider            : Starting without optional epoll library
2020-12-01 21:48:14.132  INFO 2924 --- [           main] io.lettuce.core.KqueueProvider           : Starting without optional kqueue library
2020-12-01 21:48:14.426 DEBUG 2924 --- [           main] com.sunyue.test.dao.TestUserMapper       : Cache Hit Ratio [com.sunyue.test.dao.TestUserMapper]: 0.0
2020-12-01 21:48:14.434 DEBUG 2924 --- [           main] c.s.test.dao.TestUserMapper.findAll      : ==>  Preparing: select * from test_user 
2020-12-01 21:48:14.452 DEBUG 2924 --- [           main] c.s.test.dao.TestUserMapper.findAll      : ==> Parameters: 
2020-12-01 21:48:14.466 DEBUG 2924 --- [           main] c.s.test.dao.TestUserMapper.findAll      : <==      Total: 5
加入缓存：key================》448135888:3833733049:com.sunyue.test.dao.TestUserMapper.findAll:0:2147483647:select * from test_user:SqlSessionFactoryBean值:value ===================》[TestUser(id=07222415-adc0-4117-8f85-4a19ea0633d2, name=孙越, age=22, bir=Tue Dec 01 00:00:00 CST 2020), TestUser(id=5d7af197-a25e-418a-a087-7717bd5d4483, name=孙跃, age=24, bir=Tue Dec 01 00:00:00 CST 2020), TestUser(id=695601aa-4ad4-449f-92a3-bbae5cc432b0, name=孙越, age=22, bir=Mon Nov 30 00:00:00 CST 2020), TestUser(id=8c2e2f28-d6f1-48e6-930b-0cf431667089, name=孙跃, age=24, bir=Mon Nov 30 00:00:00 CST 2020), TestUser(id=a2bf3c23-2024-43f1-a328-b09331606c56, name=孙跃, age=24, bir=Mon Nov 30 00:00:00 CST 2020)]
TestUser(id=07222415-adc0-4117-8f85-4a19ea0633d2, name=孙越, age=22, bir=Tue Dec 01 00:00:00 CST 2020)
TestUser(id=5d7af197-a25e-418a-a087-7717bd5d4483, name=孙跃, age=24, bir=Tue Dec 01 00:00:00 CST 2020)
TestUser(id=695601aa-4ad4-449f-92a3-bbae5cc432b0, name=孙越, age=22, bir=Mon Nov 30 00:00:00 CST 2020)
TestUser(id=8c2e2f28-d6f1-48e6-930b-0cf431667089, name=孙跃, age=24, bir=Mon Nov 30 00:00:00 CST 2020)
TestUser(id=a2bf3c23-2024-43f1-a328-b09331606c56, name=孙跃, age=24, bir=Mon Nov 30 00:00:00 CST 2020)
查询缓存：
key================》-1510582337:937263828:com.sunyue.test.dao.TestUserMapper.selectOne:0:2147483647:select * from test_user where id=?:1a88f8dc-b9aa-45cf-af53-38e5a6d52b38:SqlSessionFactoryBean
2020-12-01 21:48:14.596 DEBUG 2924 --- [           main] com.sunyue.test.dao.TestUserMapper       : Cache Hit Ratio [com.sunyue.test.dao.TestUserMapper]: 0.0
2020-12-01 21:48:14.596 DEBUG 2924 --- [           main] c.s.test.dao.TestUserMapper.selectOne    : ==>  Preparing: select * from test_user where id=? 
2020-12-01 21:48:14.596 DEBUG 2924 --- [           main] c.s.test.dao.TestUserMapper.selectOne    : ==> Parameters: 1a88f8dc-b9aa-45cf-af53-38e5a6d52b38(String)
2020-12-01 21:48:14.596 DEBUG 2924 --- [           main] c.s.test.dao.TestUserMapper.selectOne    : <==      Total: 0
加入缓存：key================》-1510582337:937263828:com.sunyue.test.dao.TestUserMapper.selectOne:0:2147483647:select * from test_user where id=?:1a88f8dc-b9aa-45cf-af53-38e5a6d52b38:SqlSessionFactoryBean值:value ===================》[]
null
2020-12-01 21:48:14.645  INFO 2924 --- [       Thread-5] o.s.w.c.s.GenericWebApplicationContext   : Closing org.springframework.web.context.support.GenericWebApplicationContext@1f760b47: startup date [Tue Dec 01 21:48:10 CST 2020]; root of context hierarchy
2020-12-01 21:48:15.766  INFO 2924 --- [       Thread-5] com.alibaba.druid.pool.DruidDataSource   : {dataSource-1} closed

再次select方法：

2020-12-01 21:49:28.358  INFO 9744 --- [           main] RedisTest                                : Started RedisTest in 3.46 seconds (JVM running for 4.048)
查询缓存：key================》448135888:3833733049:com.sunyue.test.dao.TestUserMapper.findAll:0:2147483647:select * from test_user:SqlSessionFactoryBean
2020-12-01 21:49:28.548  INFO 9744 --- [           main] io.lettuce.core.EpollProvider            : Starting without optional epoll library
2020-12-01 21:49:28.550  INFO 9744 --- [           main] io.lettuce.core.KqueueProvider           : Starting without optional kqueue library
2020-12-01 21:49:28.887 DEBUG 9744 --- [           main] com.sunyue.test.dao.TestUserMapper       : Cache Hit Ratio [com.sunyue.test.dao.TestUserMapper]: 1.0
TestUser(id=07222415-adc0-4117-8f85-4a19ea0633d2, name=孙越, age=22, bir=Tue Dec 01 00:00:00 CST 2020)
TestUser(id=5d7af197-a25e-418a-a087-7717bd5d4483, name=孙跃, age=24, bir=Tue Dec 01 00:00:00 CST 2020)
TestUser(id=695601aa-4ad4-449f-92a3-bbae5cc432b0, name=孙越, age=22, bir=Mon Nov 30 00:00:00 CST 2020)
TestUser(id=8c2e2f28-d6f1-48e6-930b-0cf431667089, name=孙跃, age=24, bir=Mon Nov 30 00:00:00 CST 2020)
TestUser(id=a2bf3c23-2024-43f1-a328-b09331606c56, name=孙跃, age=24, bir=Mon Nov 30 00:00:00 CST 2020)
查询缓存：key================》-1510582337:937263828:com.sunyue.test.dao.TestUserMapper.selectOne:0:2147483647:select * from test_user where id=?:1a88f8dc-b9aa-45cf-af53-38e5a6d52b38:SqlSessionFactoryBean
2020-12-01 21:49:28.933 DEBUG 9744 --- [           main] com.sunyue.test.dao.TestUserMapper       : Cache Hit Ratio [com.sunyue.test.dao.TestUserMapper]: 1.0
null
2020-12-01 21:49:28.936  INFO 9744 --- [       Thread-5] o.s.w.c.s.GenericWebApplicationContext   : Closing org.springframework.web.context.support.GenericWebApplicationContext@1f760b47: startup date [Tue Dec 01 21:49:25 CST 2020]; root of context hierarchy
2020-12-01 21:49:30.072  INFO 9744 --- [       Thread-5] com.alibaba.druid.pool.DruidDataSource   : {dataSource-1} closed
总结一下

mybatis实现分布式缓存中增删改会直接清空缓存，查询会去查redis数据库，如果没有再去查数据库获取，如果redis缓存中存在则不需要查询数据库直接可以在缓存中获取值

一曲肝肠断——
关注
专栏目录
springboot整合redis、mybatis以及redis和mybatis的联合使用
09-17
springboot集成redis、mybatis...5、springboot实现初始化加载配置（实现缓存预热）的两种方式 6、二级缓存联合使用 方式一：redis原生方法工具类（RedisService）+redis+mybatis 方式二：CacheManager+redis+mybatis
扩展spring boot cache实现redis一二级分布式缓存
05-01
NULL 博文链接：https://sundoctor.iteye.com/blog/2409237
springboot+mybatis+redis实现分布式缓存
dichengyan0013的博客
01-07 387
大家都知道springboot项目都是微服务部署，A服务和B服务分开部署，那么它们如何更新或者获取共有模块的缓存数据，或者给A服务做分布式集群负载，如何确保A服务的所有集群都能同步公共模块的缓存数据，这些都涉及到分布式系统缓存的实现。 前面其实我已经介绍了springboot+mybatis+ehcache实现缓存数据，但是ehcache的设计并不适合做分布式缓存，所...
SpringBoot和redis 实现(mybatis的)分布式缓存
坤的博客
07-23 146
redis分布式缓存（搭建环境） 搭建mybatis和springboot的环境 server.port=8888 spring.redis.host=127.0.0.1 spring.redis.port=6379 spring.datasource.type=com.alibaba.druid.pool.DruidDataSource spring.datasource.username=root spring.datasource.password=123456 spring.datasource.
Springboot2.0下通过redis实现支持分布式的mybatis二级缓存
dixi7582的博客
09-03 199
最近领导要求在项目中加下mybatis二级缓存，由于当前项目是分布式微服务，且是多节点部署的，而司内缓存中间件使用的redis，那很自然的要用redis做分布式缓存支持，避免出现直接使用原生mybatis二级缓存造成缓存数据不一致等问题。下面会对基于redis的mybatis二级缓存实现做下简单介绍，涉及一些概念，同时一些坑点做下整理。 1. 一级缓存 一级缓存是在SqlSessio...
springboot-shiros-mybatis-redis+mysql(前后分离)
09-16
【标题】"springboot-shiros-mybatis-redis+mysql(前后分离)"是一个基于Java的Web开发框架示例，它整合了Spring Boot、Shiro、MyBatis以及Redis和MySQL数据库，实现了前后端分离的设计模式。 【Spring Boot】是...
springboot-mybatis-redis
05-01
【标题】"springboot-mybatis-redis"是一个项目名称，暗示了这个项目是关于整合Spring Boot、MyBatis和Redis的。Spring Boot是Spring框架的一个轻量级版本，旨在简化新Spring应用的初始搭建以及开发过程。MyBatis是...
即开即用的基于SpringBoot的后台管理系统脚手架SpringBoot+Redis+Mybatis.zip
最新发布
03-09
- Redis是一个高性能的键值存储系统，常用于实现分布式缓存，提高数据读取速度。 - 在项目中，Redis可以用来存放频繁访问的数据，减少数据库压力，提高响应速度。 - SpringBoot提供了对Redis的集成支持，方便地...
shiro-freemarker-springBoot- redis-mysql
07-07
此外，Redis还可以用于实现分布式锁，提高多线程环境下的并发处理能力。 **MySQL** MySQL是一个广泛使用的开源关系型数据库管理系统。在本项目中，MySQL主要负责持久化存储数据，如用户账户信息、权限角色等。...
spring redis 分布式缓存整合详细的注释说明
07-29
spring redis 分布式缓存整合详细的注释说明，各个工具类的的整合。非常简单
SpringBoot +Mybatis + Redis实现缓存（案例解析）
知识记录
07-31 3905
都知道Redis可以用来做缓存，那么该如何实现呢？
为什么没用Redis做缓存
稚彦的博客
10-02 545
都知道用Redis作缓存非常的快，但事实上有些时候我们并没有使用Redis来做缓存，而是采用本地缓存的方式。就比如我所接触的一个项目，就没有采用Redis作缓存，而是使用谷歌工具包中的Table来作的缓存。 这个Table其实就是一个数据结构，你可以把它当做Map来看待。现在我们来画两幅图，分别是使用Table做缓存和使用Redid做缓存的两种情况 使用Table作本地缓存 使用Redis作缓存 1、访问本地缓存快还是Redis快 2、Reids事务 3、Redis多一次IO ...
系列九、SpringBoot + MyBatis + Redis实现分布式缓存
仰望星空，脚踏实地！安全感是自己给的，努力才是一辈子的安全感。
12-10 1266
缓存是计算机内存中的一段数据（PS：内存中的数据具有读写快、断电立即消失的特点），合理地使用缓存能够提高网站的吞吐量和运行效率，减轻数据库的访问压力。那么哪些数据适合缓存呢？使用缓存时，一定是数据库中的数据极少发生改变，更多用于查询的情况，例如：省、市、区、县、村等数据。
SpringBoot+MyBatis+Redis实现SSO单点登录系统(一)
zhangbijun1230的专栏
10-31 3628
SpringBoot+MyBatis+Redis实现SSO单点登录系统(一)   一、SSO系统概述        SSO英文全称Single Sign On，单点登录。SSO是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。它包括可以将这次主要的登录映射到其他应用中用于同一个用户的登录的机制。它是目前比较流行的企业业务整合的解决方案之一。 二、环境搭建 1、Spr...
SpringBoot+Mybatis+Redis 实现缓存
古柏树下的博客
04-27 5900
搭建环境：IDEA，jdk1.8，springboot1.5.3新建springboot项目  依赖选择如下springboot的推荐项目结构如下其中root package结构：com.example.myproject应用主类Application.java置于root package下，通常我们会在应用主类中做一些框架配置扫描等配置， 我们放在root package下可以帮助程序减少手工配...
Redis分布式缓存 Springboot/Mybatis/高可用/高并发/互联网架构
02-25
<p><img src="https://img-bss.csdnimg.cn/202102040935553530.png" alt="" /></p> <p><img src="https://img-bss.csdnimg.cn/202102040936047411.png" alt="" /></p> <p><img src="https://img-bss.csdnimg.cn/202102040936106871.jpg" alt="" /></p> <p><img src="https://img-bss.csdnimg.cn/202102040936168151.jpg" alt="" /></p>
Property ‘sqlSessionFactory‘ or ‘sqlSessionTemplate‘ are required 问题解决
热门推荐
igray_xl的博客
08-03 5万+
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值