redis分布式缓存

image.png

一、mybatis自身缓存

引入mybatis相关依赖

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>

        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.19</version>
        </dependency>

application.properties:

#mybatis
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/nono?characterEncoding=UTF-8&useSSL=false

spring.datasource.username=root
spring.datasource.password=123456

mybatis.mapper-locations=classpath:com/nono/mapper/*.xml
mybatis.type-aliases-package=com.nono.entity


logging.level.com.nono.dao=debug

application


package com.nono;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.nono.dao")
public class RedisApplication {

    public static void main(String[] args) {
        SpringApplication.run(RedisApplication.class, args);
    }

}

User实体类，记住要implements Serializable

package com.nono.entity;

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

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

@Data
@Accessors(chain = true)
public class User implements Serializable {
    private    String id;
    private String name;
    private Integer age;
    private Date bir;

}

UserDao:

package com.nono.dao;

import com.nono.entity.User;

import java.util.List;

public interface UserDao {

    List<User> findAll();
}

resources-com/nono/mapper/-UserDaoMapper.xml
开启二级缓存：

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nono.dao.UserDao">



    <!--开启mybatis二级缓存-->
    <cache/>

    <!--findAll-->
    <select id="findAll" resultType="User">
        select id,name,age,bir from t_user
    </select>



</mapper>

UserServiceImpl:


package com.nono.service;

import com.nono.dao.UserDao;
import com.nono.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
@Service
@Transactional
public class UserServiceImpl implements UserService{

    @Autowired
    private UserDao userDao;


    @Override
    public List<User> findAll() {
        return  userDao.findAll();
    }
}

test-java-TestUserService:

package com.nono;

import com.nono.service.UserService;
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;


@SpringBootTest(classes = RedisApplication.class)
@RunWith(SpringRunner.class)
public class TestUserService {

    @Autowired
    private UserService userService;

    @Test
    public void testFindAll(){
        userService.findAll().forEach(user -> System.out.println(user));

        System.out.println("=============");

        userService.findAll().forEach(user -> System.out.println(user));

    }

}

image.png

二、redis缓存

1、由上面mybatis二级缓存可以看出来，mybatis的缓存主要是实现Cache接口，所以我们可以自定义Cache类，public class RedisCache implements Cache。
putObject和getObject是用来实现我们往redis中存取数据的。这里需要用到RedisTemplate，但是我们自定义的RedisCache是mybatis实例化的，并不是springboot工厂实例化，所以这里不能直接注入RedisTemplate。

所以我们需要一个工具类来将RedisTemplate从spring的工厂中注入RedisCache。

package com.nono.util;

//用来获取springboot创建工厂

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class ApplicationContextUtils implements ApplicationContextAware {

    //保留下来工厂
    private static ApplicationContext applicationContext;


    //将创建好的工厂以参数形式传递给这个类
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext=applicationContext;
    }


    //提供在工厂中获取对象的方法 RedisTemplate redisTemplate
    public static Object getBean(String beanName){
        return applicationContext.getBean(beanName);
    }
}

package com.nono.cache;

import com.nono.util.ApplicationContextUtils;
import org.apache.ibatis.cache.Cache;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

//自定义Redis缓存实现
public class RedisCache implements Cache {

    //当前放入缓存的mapper的namespace
    private final String id;

    //必须存在构造方法
    public RedisCache(String id){
        System.out.println(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.toString());
        System.out.println("value:"+value);
        //通过application工具类获取redisTemplate
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        //使用redishash类型作为缓存存储模型 key hashkey value
        redisTemplate.opsForHash().put(id.toString(),key.toString(),value);

    }

    //缓存中获取数据
    @Override
    public Object getObject(Object key) {
        System.out.println("key:"+key.toString());
        //通过application工具类获取redisTemplate
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        //根据key 从redis的hash类型中获取数据
        return redisTemplate.opsForHash().get(id.toString(),key.toString());
    }

    @Override
    public Object removeObject(Object o) {
        return null;
    }

    @Override
    public void clear() {

    }

    @Override
    public int getSize() {
        return 0;
    }
}

UserDaoMapper.xml

  <!--开启mybatis二级缓存-->
    <cache type="com.nono.cache.RedisCache"/>

UserServiceImpl

package com.nono.service;

import com.nono.dao.UserDao;
import com.nono.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
@Service
@Transactional
public class UserServiceImpl implements UserService{

    @Autowired
    private UserDao userDao;


    @Override
    @Transactional(propagation = Propagation.SUPPORTS)
    public List<User> findAll() {
        return  userDao.findAll();
    }

    @Override
    @Transactional(propagation = Propagation.SUPPORTS)
    public User findById(String id) {
        return userDao.findById(id);
    }
}

TestUserService

package com.nono;

import com.nono.entity.User;
import com.nono.service.UserService;
import org.apache.ibatis.cache.Cache;
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.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;


@SpringBootTest(classes = RedisApplication.class)
@RunWith(SpringRunner.class)
public class TestUserService {

    @Autowired
    private UserService userService;


    @Test
    public void testFindAll(){


        userService.findAll().forEach(user -> System.out.println(user));

        System.out.println("=============");

        userService.findAll().forEach(user -> System.out.println(user));

    }

    @Test
    public void testFindOne(){

        User byId = userService.findById("1");
        System.out.println(byId);
        System.out.println("==================");
        User byId1 = userService.findById("1");
        System.out.println(byId1);

    }

}

image.png

2、增删改走的都是clear

package com.nono.cache;

import com.nono.util.ApplicationContextUtils;
import org.apache.ibatis.cache.Cache;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

//自定义Redis缓存实现
public class RedisCache implements Cache {

    //当前放入缓存的mapper的namespace
    private final String id;

    //必须存在构造方法
    public RedisCache(String id){
        System.out.println(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.toString());
        System.out.println("value:"+value);
        //通过application工具类获取redisTemplate
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        //使用redishash类型作为缓存存储模型 key hashkey value
        redisTemplate.opsForHash().put(id.toString(),key.toString(),value);

    }

    //缓存中获取数据
    @Override
    public Object getObject(Object key) {
        System.out.println("key:"+key.toString());
        //通过application工具类获取redisTemplate
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        //根据key 从redis的hash类型中获取数据
        return redisTemplate.opsForHash().get(id.toString(),key.toString());
    }

    //注意：这个方法为mybatis保留方法 默认没有实现 后续改版可能实现
    @Override
    public Object removeObject(Object key) {
        System.out.println("根据指定key删除缓存");
        return null;
    }

    @Override
    public void clear() {
        System.out.println("清空缓存");
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        //清空namespace
        redisTemplate.delete(id.toString());//清空缓存

    }

    @Override
    public int getSize() {
        return 0;
    }
}

执行一下TestUserService的delete方法：

package com.nono;

import com.nono.entity.User;
import com.nono.service.UserService;
import org.apache.ibatis.cache.Cache;
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.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;


@SpringBootTest(classes = RedisApplication.class)
@RunWith(SpringRunner.class)
public class TestUserService {

    @Autowired
    private UserService userService;


    @Test
    public void testFindAll(){


        userService.findAll().forEach(user -> System.out.println(user));

        System.out.println("=============");

        userService.findAll().forEach(user -> System.out.println(user));

    }

    @Test
    public void testFindOne(){

        User byId = userService.findById("1");
        System.out.println(byId);
        System.out.println("==================");
        User byId1 = userService.findById("1");
        System.out.println(byId1);

    }

    @Test
    public void testDelete(){
        userService.delete("1");
    }

}

com.nono.userDao这个key在redis中就没有了

3、计数和缓存量封装redisTemplate给自己用的类用

package com.nono.cache;

import com.nono.util.ApplicationContextUtils;
import org.apache.ibatis.cache.Cache;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

//自定义Redis缓存实现
public class RedisCache implements Cache {

    //当前放入缓存的mapper的namespace
    private final String id;

    //必须存在构造方法
    public RedisCache(String id){
        System.out.println(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.toString());
        System.out.println("value:"+value);
        //通过application工具类获取redisTemplate
//        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        //使用redishash类型作为缓存存储模型 key hashkey value
        getRedisTemplate().opsForHash().put(id.toString(),key.toString(),value);

    }

    //缓存中获取数据
    @Override
    public Object getObject(Object key) {
        System.out.println("key:"+key.toString());
        //通过application工具类获取redisTemplate
//        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        //根据key 从redis的hash类型中获取数据
        return getRedisTemplate().opsForHash().get(id.toString(),key.toString());
    }

    //注意：这个方法为mybatis保留方法 默认没有实现 后续改版可能实现
    @Override
    public Object removeObject(Object key) {
        System.out.println("根据指定key删除缓存");
        return null;
    }

    @Override
    public void clear() {
        System.out.println("清空缓存");
//        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        //清空namespace
        getRedisTemplate().delete(id.toString());//清空缓存

    }

    //用来计算缓存数量
    @Override
    public int getSize() {
        //通过application工具类获取redisTemplate
//        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        //获取hash中key value数量
        return getRedisTemplate().opsForHash().size(id.toString()).intValue();
    }


    //封装redisTemplate
    private RedisTemplate getRedisTemplate(){
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

5.redis分布式缓存(二).png

现在在写一个关于emp的redis缓存：

EmpDaoMapper.xml：

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nono.dao.EmpDao">



    <!--开启mybatis二级缓存-->
    <cache type="com.nono.cache.RedisCache"/>

    <!--findAll-->
    <select id="findAll" resultType="Emp">
        select id,name from t_emp
    </select>




</mapper>

service：

package com.nono.service;

import com.nono.dao.EmpDao;
import com.nono.entity.Emp;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class EmpServiceImpl implements EmpService{

    @Autowired
    private EmpDao empDao;


    @Override
    public List<Emp> findAll() {
        return empDao.findAll();
    }
}

dao：

package com.nono.dao;

import com.nono.entity.Emp;

import java.util.List;

public interface EmpDao {
    List<Emp> findAll();
}

如果emp和user表没关联，可以直接用过上面的方式。
但是一旦两个表有关联，就会出问题，比如我们更新了emp的信息，redis里user包含的emp不会跟着跟新，是旧的。

在mybatis的缓存中如何解决关联关系更新缓存信息的问题：<cache-ref />用来将多个具体关联关系查询缓存放在一起处理。

EmpDaoMapper.xml:

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nono.dao.EmpDao">



    <!--开启mybatis二级缓存
    <cache type="com.nono.cache.RedisCache"/>-->
    
    <cache-ref namespace="com.nono.dao.UserDao"/>

    <!--findAll-->
    <select id="findAll" resultType="Emp">
        select id,name from t_emp
    </select>




</mapper>

6.redis分布式缓存(三).png

1、缓存优化策略

key要设计简洁一点：
算法：MD5 处理加密

在putObject和getObject中调用此方法：

 //封装一个对key进行md5处理方法
    private String getKeyToMD5(String key){
        return DigestUtils.md5DigestAsHex(key.getBytes());
    }

package com.nono.cache;

import com.nono.util.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;

//自定义Redis缓存实现
public class RedisCache implements Cache {

    //当前放入缓存的mapper的namespace
    private final String id;

    //必须存在构造方法
    public RedisCache(String id){
        System.out.println(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.toString());
        System.out.println("value:"+value);
        //通过application工具类获取redisTemplate
//        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        //使用redishash类型作为缓存存储模型 key hashkey value
        getRedisTemplate().opsForHash().put(id.toString(),getKeyToMD5(key.toString()),value);

    }

    //缓存中获取数据
    @Override
    public Object getObject(Object key) {
        System.out.println("key:"+key.toString());
        //通过application工具类获取redisTemplate
//        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        //根据key 从redis的hash类型中获取数据
        return getRedisTemplate().opsForHash().get(id.toString(),getKeyToMD5(key.toString()));
    }

    //注意：这个方法为mybatis保留方法 默认没有实现 后续改版可能实现
    @Override
    public Object removeObject(Object key) {
        System.out.println("根据指定key删除缓存");
        return null;
    }

    @Override
    public void clear() {
        System.out.println("清空缓存");
//        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        //清空namespace
        getRedisTemplate().delete(id.toString());//清空缓存

    }

    //用来计算缓存数量
    @Override
    public int getSize() {
        //通过application工具类获取redisTemplate
//        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        //获取hash中key value数量
        return getRedisTemplate().opsForHash().size(id.toString()).intValue();
    }


    //封装redisTemplate
    private RedisTemplate getRedisTemplate(){
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }


    //封装一个对key进行md5处理方法
    private String getKeyToMD5(String key){
        return DigestUtils.md5DigestAsHex(key.getBytes());
    }
}

key:

image.png

2、防止缓存穿透、击穿

mybatis中cache解决了缓存击穿：将数据库中没有查询到结果也进行缓存存为null。

3、防止缓存雪崩

1、永久存储【不推荐】
2、针对于不同业务数据一定要设置不同超时时间。

  if(id.equals("com.nono.dao.UserDAO")){
            //缓存超时  client  用户   client  员工
            getRedisTemplate().expire(id.toString(),1, TimeUnit.HOURS);
        }


        if(id.equals("com.nono.dao.CityDAO")){
            //缓存超时  client  用户   client  员工
            getRedisTemplate().expire(id.toString(),30, TimeUnit.MINUTES);
        }

        //.....指定不同业务模块设置不同缓存超时时间

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 202,100评论 5赞 474
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 84,862评论 2赞 378
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 148,993评论 0赞 335
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,309评论 1赞 272
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,303评论 5赞 363
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,421评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,830评论 3赞 393
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,501评论 0赞 256
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,689评论 1赞 295
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,506评论 2赞 318
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,564评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,286评论 4赞 318
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,826评论 3赞 305
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,875评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,114评论 1赞 259
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,705评论 2赞 348
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,269评论 2赞 341

redis分布式缓存

一、mybatis自身缓存

二、redis缓存

在mybatis的缓存中如何解决关联关系更新缓存信息的问题：<cache-ref />用来将多个具体关联关系查询缓存放在一起处理。

1、缓存优化策略

2、防止缓存穿透、击穿

3、防止缓存雪崩

推荐阅读更多精彩内容