SSM之Spring注解式缓存Redis


<redis.version>2.9.0redis.version>
<redis.spring.version>1.7.1.RELEASEredis.spring.version>
 
<dependency>
    <groupId>redis.clientsgroupId>
    <artifactId>jedisartifactId>
    <version>${redis.version}version>
dependency>
<dependency>
    <groupId>org.springframework.datagroupId>
    <artifactId>spring-data-redisartifactId>
    <version>${redis.spring.version}version>
dependency>

②添加对应的配置文件

redis.properties


redis.hostName=192.168.141.128
redis.port=6379
redis.password=123456
redis.timeout=10000
redis.maxIdle=300
redis.maxTotal=1000
redis.maxWaitMillis=1000
redis.minEvictableIdleTimeMillis=300000
redis.numTestsPerEvictionRun=1024
redis.timeBetweenEvictionRunsMillis=30000
redis.testOnBorrow=true
redis.testWhileIdle=true
redis.expiration=3600


"1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
               xmlns:aop="http://www.springframework.org/schema/aop"
               xmlns:cache="http://www.springframework.org/schema/cache"
               xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans.xsd
               http://www.springframework.org/schema/context
               http://www.springframework.org/schema/context/spring-context.xsd
               http://www.springframework.org/schema/tx
               http://www.springframework.org/schema/tx/spring-tx.xsd
               http://www.springframework.org/schema/aop
               http://www.springframework.org/schema/aop/spring-aop.xsd
               http://www.springframework.org/schema/cache
               http://www.springframework.org/schema/cache/spring-cache.xsd">
 
    
    <context:property-placeholder location="classpath:redis.properties" />
 
    
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        
        <property name="maxIdle" value="${redis.maxIdle}"/>
        
        <property name="maxTotal" value="${redis.maxTotal}"/>
        
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}"/>
        
        <property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}"/>
        
        <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}"/>
        
        <property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}"/>
        
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
        
        <property name="testWhileIdle" value="${redis.testWhileIdle}"/>
    bean>
 
    
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          destroy-method="destroy">
        <property name="poolConfig" ref="poolConfig"/>
        
        <property name="hostName" value="${redis.hostName}"/>
        
        <property name="port" value="${redis.port}"/>
        
        <property name="password" value="${redis.password}"/>
        
        <property name="timeout" value="${redis.timeout}"/>
    bean>
 
    
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="connectionFactory"/>
        
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
        property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
        property>
        
        <property name="enableTransactionSupport" value="true"/>
    bean>
 
    
    <bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
        <constructor-arg name="redisOperations" ref="redisTemplate"/>
        
        <property name="defaultExpiration" value="${redis.expiration}"/>
        
        <property name="usePrefix" value="true"/>
        
        <property name="cachePrefix">
            <bean class="org.springframework.data.redis.cache.DefaultRedisCachePrefix">
                <constructor-arg index="0" value="-cache-"/>
            bean>
        property>
    bean>
 
    
    <bean id="cacheKeyGenerator" class="com.xiaokun.ssm.redis.CacheKeyGenerator">bean>
 
    
    <cache:annotation-driven cache-manager="redisCacheManager" key-generator="cacheKeyGenerator"/>
beans>

③Spring-redis的整合配置文件

注意1：jdbc.properties与redis.properties文件在整合的时候会有冲突现象，解决方式，用引入外部多文件方式进行处理

注意2：pom中可以编译的文件以及目录

记得下载插件lombox


package com.zking.ssm.redis;
 
import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.util.ClassUtils;
 
import java.lang.reflect.Array;
import java.lang.reflect.Method;
 
/**
 * 指定redis中的key value存储中的key字符串的生成规则
 * uname:zs 以前这个uname是手动赋予的
 * 这个uname不想手写了，就通过它来写
 *
 * @enableCache 这个key就通过它来做的
 */
 
@Slf4j
public class CacheKeyGenerator implements KeyGenerator {
    // custom cache key
    public static final int NO_PARAM_KEY = 0;
    public static final int NULL_PARAM_KEY = 53;
 
    @Cacheable
    @Override
    public Object generate(Object target, Method method, Object... params) {
        StringBuilder key = new StringBuilder();
//        com.zking.service.ClzServie.get:1
        key.append(target.getClass().getSimpleName()).append(".").append(method.getName()).append(":");
        if (params.length == 0) {
            key.append(NO_PARAM_KEY);
        } else {
            int count = 0;
            for (Object param : params) {
                if (0 != count) {//参数之间用,进行分隔
                    key.append(',');
                }
                if (param == null) {
                    key.append(NULL_PARAM_KEY);
                } else if (ClassUtils.isPrimitiveArray(param.getClass())) {
                    int length = Array.getLength(param);
                    for (int i = 0; i < length; i++) {
                        key.append(Array.get(param, i));
                        key.append(',');
                    }
                } else if (ClassUtils.isPrimitiveOrWrapper(param.getClass()) || param instanceof String) {
                    key.append(param);
                } else {//Java一定要重写hashCode和eqauls
                    key.append(param.hashCode());
                }
                count++;
            }
        }
 
        String finalKey = key.toString();
//        IEDA要安装lombok插件
        log.debug("using cache key={}", finalKey);
        return finalKey;
    }
}

这个时候运行会出错，因为redis.properties与jdbc.properties在与Spring做整合时发生冲突；所以引入配置文件的地方要放到中applicationContext.xml

将以下的配置内容加入即可


"1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
               xmlns:aop="http://www.springframework.org/schema/aop"
               xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
 
    
    <bean id="propertyConfigurer"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
        <property name="ignoreResourceNotFound" value="true" />
        <property name="locations">
            <list>
                <value>classpath:jdbc.propertiesvalue>
                <value>classpath:redis.propertiesvalue>
            list>
        property>
    bean>
 
    
    
    <import resource="applicationContext-mybatis.xml">import>
    
    <import resource="applicationContext-redis.xml">import>
    <import resource="applicationContext-shiro.xml"/>
beans>

④测试

完整版pom依赖


"1.0" encoding="UTF-8"?>
 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0modelVersion>
 
  <groupId>org.examplegroupId>
  <artifactId>ssm2artifactId>
  <version>1.0-SNAPSHOTversion>
  <packaging>warpackaging>
 
  <name>ssm2 Maven Webappname>
  
  <url>http://www.example.comurl>
 
  <properties>
    <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    <maven.compiler.source>1.8maven.compiler.source>
    <maven.compiler.target>1.8maven.compiler.target>
    <maven.compiler.plugin.version>3.7.0maven.compiler.plugin.version>
 
    
    
    <spring.version>5.0.2.RELEASEspring.version>
    
    <mybatis.version>3.4.5mybatis.version>
    
    <mysql.version>5.1.44mysql.version>
    
    <pagehelper.version>5.1.2pagehelper.version>
    
    <mybatis.spring.version>1.3.1mybatis.spring.version>
    
    <commons.dbcp2.version>2.1.1commons.dbcp2.version>
    <commons.pool2.version>2.4.3commons.pool2.version>
    
    <log4j2.version>2.9.1log4j2.version>
    
    <junit.version>4.12junit.version>
    <servlet.version>4.0.0servlet.version>
    <lombok.version>1.18.2lombok.version>
 
    <redis.version>2.9.0redis.version>
    <redis.spring.version>1.7.1.RELEASEredis.spring.version>
  properties>
 
  <dependencies>
    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>${spring.version}version>
    dependency>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-ormartifactId>
      <version>${spring.version}version>
    dependency>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-txartifactId>
      <version>${spring.version}version>
    dependency>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-aspectsartifactId>
      <version>${spring.version}version>
    dependency>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webartifactId>
      <version>${spring.version}version>
    dependency>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-testartifactId>
      <version>${spring.version}version>
    dependency>
 
    
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatisartifactId>
      <version>${mybatis.version}version>
    dependency>
    
    <dependency>
      <groupId>mysqlgroupId>
      <artifactId>mysql-connector-javaartifactId>
      <version>${mysql.version}version>
    dependency>
    
    <dependency>
      <groupId>com.github.pagehelpergroupId>
      <artifactId>pagehelperartifactId>
      <version>${pagehelper.version}version>
    dependency>
    
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatis-springartifactId>
      <version>${mybatis.spring.version}version>
    dependency>
 
    
    <dependency>
      <groupId>org.apache.commonsgroupId>
      <artifactId>commons-dbcp2artifactId>
      <version>${commons.dbcp2.version}version>
    dependency>
    <dependency>
      <groupId>org.apache.commonsgroupId>
      <artifactId>commons-pool2artifactId>
      <version>${commons.pool2.version}version>
    dependency>
 
    
    
    <dependency>
      <groupId>org.apache.logging.log4jgroupId>
      <artifactId>log4j-coreartifactId>
      <version>${log4j2.version}version>
    dependency>
    <dependency>
      <groupId>org.apache.logging.log4jgroupId>
      <artifactId>log4j-apiartifactId>
      <version>${log4j2.version}version>
    dependency>
    
    <dependency>
      <groupId>org.apache.logging.log4jgroupId>
      <artifactId>log4j-webartifactId>
      <version>${log4j2.version}version>
    dependency>
 
    
    <dependency>
      <groupId>junitgroupId>
      <artifactId>junitartifactId>
      <version>${junit.version}version>
      <scope>testscope>
    dependency>
    <dependency>
      <groupId>javax.servletgroupId>
      <artifactId>javax.servlet-apiartifactId>
      <version>${servlet.version}version>
      <scope>providedscope>
    dependency>
    <dependency>
      <groupId>org.projectlombokgroupId>
      <artifactId>lombokartifactId>
      <version>${lombok.version}version>
      <scope>providedscope>
    dependency>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webmvcartifactId>
      <version>${spring.version}version>
    dependency>
    
    <dependency>
      <groupId>javax.servlet.jspgroupId>
      <artifactId>javax.servlet.jsp-apiartifactId>
      <version>2.3.3version>
    dependency>
    <dependency>
      <groupId>jstlgroupId>
      <artifactId>jstlartifactId>
      <version>1.2version>
    dependency>
    <dependency>
      <groupId>taglibsgroupId>
      <artifactId>standardartifactId>
      <version>1.1.2version>
    dependency>
 
    <dependency>
      <groupId>commons-fileuploadgroupId>
      <artifactId>commons-fileuploadartifactId>
      <version>1.3.3version>
    dependency>
 
    
    <dependency>
      <groupId>org.hibernategroupId>
      <artifactId>hibernate-validatorartifactId>
      <version>6.0.7.Finalversion>
    dependency>
 
    <dependency>
      <groupId>com.fasterxml.jackson.coregroupId>
      <artifactId>jackson-databindartifactId>
      <version>2.9.3version>
    dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.coregroupId>
      <artifactId>jackson-coreartifactId>
      <version>2.9.3version>
    dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.coregroupId>
      <artifactId>jackson-annotationsartifactId>
      <version>2.9.3version>
    dependency>
 
 
    <dependency>
      <groupId>redis.clientsgroupId>
      <artifactId>jedisartifactId>
      <version>${redis.version}version>
    dependency>
    <dependency>
      <groupId>org.springframework.datagroupId>
      <artifactId>spring-data-redisartifactId>
      <version>${redis.spring.version}version>
    dependency>
  dependencies>
 
  <build>
    <finalName>ssm2finalName>
    <resources>
      
      <resource>
        <directory>src/main/javadirectory>
        <includes>
          <include>**/*.xmlinclude>
        includes>
      resource>
      
      <resource>
        <directory>src/main/resourcesdirectory>
        <includes>
          <include>*.propertiesinclude>
          <include>*.xmlinclude>
        includes>
      resource>
    resources>
    <pluginManagement>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.pluginsgroupId>
          <artifactId>maven-compiler-pluginartifactId>
          <version>${maven.compiler.plugin.version}version>
          <configuration>
            <source>${maven.compiler.source}source>
            <target>${maven.compiler.target}target>
            <encoding>${project.build.sourceEncoding}encoding>
          configuration>
        plugin>
        <plugin>
          <groupId>org.mybatis.generatorgroupId>
          <artifactId>mybatis-generator-maven-pluginartifactId>
          <version>1.3.2version>
          <dependencies>
            
            <dependency>
              <groupId>mysqlgroupId>
              <artifactId>mysql-connector-javaartifactId>
              <version>${mysql.version}version>
            dependency>
          dependencies>
          <configuration>
            <overwrite>trueoverwrite>
          configuration>
        plugin>
        <plugin>
          <artifactId>maven-clean-pluginartifactId>
          <version>3.1.0version>
        plugin>
        
        <plugin>
          <artifactId>maven-resources-pluginartifactId>
          <version>3.0.2version>
        plugin>
        <plugin>
          <artifactId>maven-compiler-pluginartifactId>
          <version>3.8.0version>
        plugin>
        <plugin>
          <artifactId>maven-surefire-pluginartifactId>
          <version>2.22.1version>
        plugin>
        <plugin>
          <artifactId>maven-war-pluginartifactId>
          <version>3.2.2version>
        plugin>
        <plugin>
          <artifactId>maven-install-pluginartifactId>
          <version>2.5.2version>
        plugin>
        <plugin>
          <artifactId>maven-deploy-pluginartifactId>
          <version>2.8.2version>
        plugin>
      plugins>
    pluginManagement>
  build>
project>

二、reids的注解式开发

启动虚拟机VMware，启动虚拟机连接工具

连接redis服务6379

① @Cacheable

配置在方法或类上

作用：本方法执行后，先去缓存看有没有数据，如果没有，从数据库中查找出来，给缓存中存一份，返回结果，下次本方法执行，在缓存未过期情况下，先在缓存中查找，有的话直接返回，没有的话从数据库查找

ClazzBiz


package com.zking.ssm.biz;
 
import com.zking.ssm.model.Clazz;
import com.zking.ssm.util.PageBean;
import org.springframework.cache.annotation.Cacheable;
 
import java.util.List;
import java.util.Map;
 
public interface ClazzBiz {
    int deleteByPrimaryKey(Integer cid);
 
    int insert(Clazz record);
 
    int insertSelective(Clazz record);
 
    Clazz selectByPrimaryKey(Integer cid);
 
    int updateByPrimaryKeySelective(Clazz record);
 
    int updateByPrimaryKey(Clazz record);
 
    List listPager(Clazz clazz, PageBean pageBean);
 
    List listMapPager(Clazz clazz, PageBean pageBean);
}

读Spring上下文

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})

ClazzBizTest


package com.zking.ssm.redis;
 
import com.zking.ssm.biz.ClazzBiz;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
/**
 * @author 小坤
 * @create  2022-10-28 17:00
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class ClazzBizTest {
    @Autowired
    private ClazzBiz clazzBiz;
 
    @Test
    public void test1(){
        System.out.println(clazzBiz.selectByPrimaryKey(1));
        System.out.println(clazzBiz.selectByPrimaryKey(1));
    }
}

运行图

修改ClazzBiz里的注释


    @Cacheable(value = "xx")
    Clazz selectByPrimaryKey(Integer cid);

现在我们看看redis的桌面管理器中显示

再次修改注释中的属性 key改变原有的key生成规则


//    xx=cache-cid:1
//    key的作用是改变原有的key生成规则
    @Cacheable(value = "xx",key = "'cid:'+#cid")
    Clazz selectByPrimaryKey(Integer cid);


 @Test
    public void test1(){
        System.out.println(clazzBiz.selectByPrimaryKey(2));
        System.out.println(clazzBiz.selectByPrimaryKey(2));
    }

redis最终存储的对象是JSON

修改注释里的属性 condition判断什么时候修改key属性将库清空


//    xx=cache-cid:1
//    key的作用是改变原有的key生成规则
//    改变它的生成规则，只有key大于6的时候生成缓存，key小于6不生成缓存
    @Cacheable(value = "xx",key = "'cid:'+#cid",condition = "#cid > 6")
    Clazz selectByPrimaryKey(Integer cid);


  @Test
    public void test1(){
        System.out.println(clazzBiz.selectByPrimaryKey(3));
        System.out.println(clazzBiz.selectByPrimaryKey(3));
    }

运行图

查询了两次数据库

修改ClazzBizTest


 @Test
    public void test1(){
        System.out.println(clazzBiz.selectByPrimaryKey(8));
        System.out.println(clazzBiz.selectByPrimaryKey(8));
    }

运行结果肯定查询了一次数据库，还生成了缓存👀👀

② @CachePut

类似于更新操作，即每次不管缓存中有没有结果，都从数据库查找结果，并将结果更新到缓存，并返回结果。

ClazzBiz


    @CachePut(value = "xx",key = "'cid:'+#cid",condition = "#cid > 6")
    Clazz selectByPrimaryKey(Integer cid);

ClazzBizTest


@Test
    public void test1(){
        System.out.println(clazzBiz.selectByPrimaryKey(9));
        System.out.println(clazzBiz.selectByPrimaryKey(9));
    }

运行图

③ @CacheEvict

用来清除用在本方法或者类上的缓存数据（把指定的数据清空的同时，清除掉redis桌面管理器这里面的缓存清空某一条数据，你传的id是什么，就把id对应的缓存给清掉）

ClazzBiz


    @CacheEvict(value = "xx",key = "'cid:'+#cid")
    int deleteByPrimaryKey(Integer cid);

ClazzBizTest


@Test
    public void test2(){
        clazzBiz.deleteByPrimaryKey(9);
    }

ClazzBizImpl


 @Override
    public int deleteByPrimaryKey(Integer cid) {
 
//        return clazzMapper.deleteByPrimaryKey(cid);
        System.out.println("不做任何操作,因为我们只清除缓存，不清除数据库");
        return 0;
    }

ClazzBizTest


@Test
    public void test2(){
        clazzBiz.deleteByPrimaryKey(10);
    }

小结：

① @Cacheable 使用注解，缓存并使用

② @CaChePut 只放缓存，不查缓存

③ @CacheEvict 清除缓存，可以去设置权限，清除指定缓存、清除所有缓存

三、redis的击穿、穿透、雪崩现象及解决方案 👀👀

击穿：高并发量的同时key失效，导致请求直接到达数据库

设置锁
1.获取 Redis 锁，如果没有获取到，则回到任务队列继续排队
2.获取到锁，从数据库拉取数据并放入缓存中
3.释放锁，其他请求从缓存中拿到数据

限流：请求redis之前做流量削峰

穿透：很多请求都在访问数据库一定不存在的数据，造成请求将缓存和数据库都穿透的情况

规则排除
可以增加一些参数检验。例如数据库数据 id 一般都是递增的，如果请求 id = -10 这种参数，势必绕过Redis。避免这种情况，可以对用户真实性检验等操作。

null值填充
当缓存穿透时，redis存入一个类似null的值，下次访问则直接缓存返回空，当数据库中存在该数据的值则需要把redis存在的null值清除并载入新值，此方案不能解决频繁随机不规则的key请求。

雪崩：雪崩和击穿类似，不同的是击穿是一个热点 Key 某时刻失效，而雪崩是大量的热点 Key 在一瞬间失效

给不同的热点key设置不同的缓存策略

简略图解

击穿、穿透、雪崩它们都有共同点会有大量请求：通用的解决方案限流，限流用到的技术RabbitMQ，流量雪崩
击穿的解决方案：给redis上锁，第一个请求拿到锁，从数据库拿数据，缓存到redis中，

然后在把锁释放，后面的请求就可以访问了

穿透：因为它的现象是反而不存在的数据，redis跟MySQL都没有这条数据但此时我们可以在

redis设置一条压根就不存在的数据，那下次在访问的话，

那么redis就有数据请求就不会到达MySQL，这是关于穿透

雪崩：是因为大量的key同一时间发生变化，那我们可以采用disregard的方式，
给不同的key设置不同的缓存策略，设置不同的存活时间

小结：

reids的击穿穿透雪崩
击穿：一瞬间大量请求访问某一个key的数据，而这个key正好失效；那么此时大量请求会到数据库

方案：限流，设置redis锁

穿透：访问一个redis以及数据库压根不存在的数据，每一次请求都会到达数据库

方案：设置“null”值

雪崩：一瞬间大量请求访问多个key的数据，而多个key同时失效

方案：通过定时任务，设置不同的缓存机制

相关阅读:
android 固定进度环形刷新效果
 【记录】GLICB2.25 升级时报错
 春秋云境CVE-2018-20604
ElasticSearch映射与模板介绍
 Word插入希腊字母及特殊符号分类整
 idea常用快捷键持续更新
 C++精简实现2048游戏逻辑
 微服务架构陷阱与挑战
 安装cuda和cudnn之后torch.cuda_is_available()为False
Makefile与CMakeLists.txt
原文地址：https://blog.csdn.net/weixin_67450855/article/details/127577380

SSM之Spring注解式缓存Redis

一、Spring整合Redis

①导入相关的pom依赖

②添加对应的配置文件

③Spring-redis的整合配置文件

④测试

完整版pom依赖

二、reids的注解式开发

① @Cacheable

② @CachePut

③ @CacheEvict

小结：

三、redis的击穿、穿透、雪崩现象及解决方案 👀👀

击穿：高并发量的同时key失效，导致请求直接到达数据库

穿透： 很多请求都在访问数据库一定不存在的数据，造成请求将缓存和数据库都穿透的情况

雪崩： 雪崩和击穿类似，不同的是击穿是一个热点 Key 某时刻失效，而雪崩是大量的热点 Key 在一瞬间失效

简略图解

小结：

穿透：很多请求都在访问数据库一定不存在的数据，造成请求将缓存和数据库都穿透的情况

雪崩：雪崩和击穿类似，不同的是击穿是一个热点 Key 某时刻失效，而雪崩是大量的热点 Key 在一瞬间失效