redis07

redis的整合

 

引入依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

 

redis的工具类，将redis的池初始化到spring容器中

public class RedisUtil {

    private JedisPool jedisPool;

    public void initPool(String host,int port ,int database){
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(200);
        poolConfig.setMaxIdle(30);
        poolConfig.setBlockWhenExhausted(true);
        poolConfig.setMaxWaitMillis(10*1000);
        poolConfig.setTestOnBorrow(true);
        jedisPool=new JedisPool(poolConfig,host,port,20*1000);
    }

    public Jedis getJedis(){
        Jedis jedis = jedisPool.getResource();
        return jedis;
    }

}

 

spring整合redis的配置类

@Configuration
public class RedisConfig {
    //读取配置文件中的redis的ip地址
    @Value("${spring.redis.host:disabled}")
    private String host;
    @Value("${spring.redis.port:0}")
    private int port ;
    @Value("${spring.redis.database:0}")
    private int database;
    @Bean
    public RedisUtil getRedisUtil(){
        if(host.equals("disabled")){
            return null;
        }
        RedisUtil redisUtil=new RedisUtil();
        redisUtil.initPool(host,port,database);
        return redisUtil;
    }
}

 

application.properties

spring.redis.host=192.168.239.139

spring.redis.port=6379

spring.redis.database=0

 

 

缓存击穿

是某一个热点key在高并发访问的情况下，突然失效，导致大量的并发,引起mysql数据库压力瞬间增大，造成过大压力

 

击穿：在正常的访问情况下，如果缓存失效，如果保护mysql，重启缓存的过程，使用redis数据库的分布式锁，解决mysql的访问压力问题。

 

第一种分布式锁：redis自带一个分布式锁,set px nx

set sku:108:lock 1 px 600000 nx 

px 600000   过期时间

nx    分布式锁参数，只有不存在才能返回成功

 

第二种分布式锁：redisson框架，一个redis的带有juc的lock功能的客户端的实现(既有jedis的功能，又有juc的锁功能)

 

例：通过skuId查询skuInfo

 @Override
    public PmsSkuInfo getSkuById(String skuId) {

        PmsSkuInfo pmsSkuInfo = new PmsSkuInfo();


        //连接缓存，查询缓存
        Jedis jedis = redisUtil.getJedis();


        //没有缓存，查询mysql
        String skuKey = "sku:"+skuId+":info";
        String skuJson = jedis.get(skuKey);

        if (StringUtils.isNotBlank(skuJson)){
            pmsSkuInfo = JSON.parseObject(skuJson, PmsSkuInfo.class);
        }else {

            //设置分布式锁
            String token = UUID.randomUUID().toString();
            String OK = jedis.set("sku:" + skuId + ":lock", token, "nx", "px", 10*1000);
            if (StringUtils.isNotBlank(OK)&&OK.equals("OK")){
                //设置成功，有权在10s内访问数据库
                pmsSkuInfo = getSkuByIdFromDb(skuId);

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if (pmsSkuInfo != null){
                    //mysql存入redis
                    jedis.set("sku:"+skuId+":info",JSON.toJSONString(pmsSkuInfo));
                }else {
　　　　　　　　　　　　　　//数据库不存在该sku
                    //防止缓存穿透,值设为空字符串或null
                    jedis.setex("sku:"+skuId+":info",60*3,JSON.toJSONString(""));
                }

                String lockToken = jedis.get("sku:" + skuId + ":lock");
                if(StringUtils.isNotBlank(lockToken)&&lockToken.equals(token)){  //用token确认删除的是自己的锁

                    //在访问mysql后，将mysql的分布式锁删除
                    jedis.del("sku:" + skuId + ":lock");

                }

            }else {
                //设置失败，自旋（该线程在睡眠几秒后，重新尝试本方法）
                return  getSkuById(skuId);
            }

        }
        jedis.close();

        return pmsSkuInfo;

    }

49行中，如改为，则是错误的自旋

                //设置失败，自旋（该线程在睡眠几秒后，重新尝试本方法）
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
                getSkuById(skuId);

getSkuId(skuId) 表示又开新辟的线程重新进行访问，与原线程形成父子线程，

加入 return 后 ，return getSkuById(skuId) 表原线程重新进行访问