【Redis】SSM整合Redis注解式缓存的使用

news2024/11/24 10:02:44

🎉🎉欢迎来到我的CSDN主页！🎉🎉

🏅我是Java方文山，一个在CSDN分享笔记的博主。📚📚

🌟推荐给大家我的专栏《Redis》。🎯🎯

👉点击这里，就可以查看我的主页啦！👇👇

Java方文山的个人主页

🎁如果感觉还不错的话请给我点赞吧！🎁🎁

💖期待你的加入，一起学习，一起进步！💖💖

请添加图片描述

目录

一、SSM整合Redis

1.1.pom配置

1.2.配置文件spring-redis.xml

1.3.修改applicationContext.xml

1.4.配置redis的key生成策略

二、Redis的注解式开发及应用场景        

2.1.什么是Redis注解式

2.2.为什么使用Redis注解式

2.3.Redis注解式的应用

①Cacheable

②CachePut

③CacheEvict

2.4.CachePut和Cacheable的区别

三、Redis中的击穿、穿透、雪崩的三种场景

3.1.缓存穿透

1.什么是缓存穿透？

2.如何解决缓存穿透问题？

3.2.缓存击穿

1.什么是缓存击穿？

2.如何解决缓存击穿问题？

3.3.缓存雪崩

1.什么是缓存雪崩？

2.如何解决缓存雪崩问题？

一、SSM整合Redis

1.1.pom配置

在Maven或Gradle的构建文件中添加Redis相关的依赖。

注意：resources的配置必须涵盖读取.properties结尾的文件

<?xml version="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.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>ssm2</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>ssm2 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.plugin.version>3.7.0</maven.compiler.plugin.version>

    <!--添加jar包依赖-->
    <!--1.spring 5.0.2.RELEASE相关-->
    <spring.version>5.0.2.RELEASE</spring.version>
    <!--2.mybatis相关-->
    <mybatis.version>3.4.5</mybatis.version>
    <!--mysql-->
    <mysql.version>5.1.44</mysql.version>
    <!--pagehelper分页jar依赖-->
    <pagehelper.version>5.1.2</pagehelper.version>
    <!--mybatis与spring集成jar依赖-->
    <mybatis.spring.version>1.3.1</mybatis.spring.version>
    <!--3.dbcp2连接池相关 druid-->
    <commons.dbcp2.version>2.1.1</commons.dbcp2.version>
    <commons.pool2.version>2.4.3</commons.pool2.version>
    <!--4.log日志相关-->
    <log4j2.version>2.9.1</log4j2.version>
    <!--5.其他-->
    <junit.version>4.12</junit.version>
    <servlet.version>4.0.0</servlet.version>
    <lombok.version>1.18.2</lombok.version>

    <ehcache.version>2.10.0</ehcache.version>
    <slf4j-api.version>1.7.7</slf4j-api.version>

    <redis.version>2.9.0</redis.version>
    <redis.spring.version>1.7.1.RELEASE</redis.spring.version>
  </properties>

  <dependencies>
    <!--1.spring相关-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!--2.mybatis相关-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <!--mysql-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>
    <!--pagehelper分页插件jar包依赖-->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>${pagehelper.version}</version>
    </dependency>
    <!--mybatis与spring集成jar包依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>${mybatis.spring.version}</version>
    </dependency>

    <!--3.dbcp2连接池相关-->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-dbcp2</artifactId>
      <version>${commons.dbcp2.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-pool2</artifactId>
      <version>${commons.pool2.version}</version>
    </dependency>

    <!--4.log日志相关依赖-->
    <!--核心log4j2jar包-->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <version>${log4j2.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-api</artifactId>
      <version>${log4j2.version}</version>
    </dependency>
    <!--web工程需要包含log4j-web，非web工程不需要-->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-web</artifactId>
      <version>${log4j2.version}</version>
    </dependency>

    <!--5.其他-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>${lombok.version}</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- jsp依赖-->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.3.3</version>
    </dependency>
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>taglibs</groupId>
      <artifactId>standard</artifactId>
      <version>1.1.2</version>
    </dependency>

    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.3</version>
    </dependency>

<!--    做服务端参数校验 JSR303 的jar包依赖 -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>6.0.7.Final</version>
    </dependency>

<!--    用来SpringMVC支持json数据转换-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.3</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.3</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.9.3</version>
    </dependency>

<!--    shiro相关依赖 -->
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-core</artifactId>
      <version>1.3.2</version>
    </dependency>

    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-web</artifactId>
      <version>1.3.2</version>
    </dependency>

    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-spring</artifactId>
      <version>1.3.2</version>
    </dependency>

    <dependency>
      <groupId>net.sf.ehcache</groupId>
      <artifactId>ehcache</artifactId>
      <version>${ehcache.version}</version>
    </dependency>

    <!-- slf4j核心包 -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j-api.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>jcl-over-slf4j</artifactId>
      <version>${slf4j-api.version}</version>
      <scope>runtime</scope>
    </dependency>

    <!--用于与slf4j保持桥接 -->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-slf4j-impl</artifactId>
      <version>${log4j2.version}</version>
    </dependency>

    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>${redis.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-redis</artifactId>
      <version>${redis.spring.version}</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>ssm2</finalName>
    <resources>
      <!--解决mybatis-generator-maven-plugin运行时没有将XxxMapper.xml文件放入target文件夹的问题-->
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.xml</include>
        </includes>
      </resource>
      <!--解决mybatis-generator-maven-plugin运行时没有将jdbc.properites文件放入target文件夹的问题-->
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>*.properties</include>
          <include>*.xml</include>
        </includes>
      </resource>
    </resources>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <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.generator</groupId>
          <artifactId>mybatis-generator-maven-plugin</artifactId>
          <version>1.3.2</version>
          <dependencies>
            <!--使用Mybatis-generator插件不能使用太高版本的mysql驱动 -->
            <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>${mysql.version}</version>
            </dependency>
          </dependencies>
          <configuration>
            <overwrite>true</overwrite>
          </configuration>
        </plugin>

        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

1.2.配置文件spring-redis.xml

这个配置文件的作用主要用于配置数据源和连接工厂还有配置序列化的用途

redis.properties

redis.hostName=localhost
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

spring-redis.xml

<?xml version="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: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/cache
       http://www.springframework.org/schema/cache/spring-cache.xsd">

    <!-- 1. 引入properties配置文件 -->
    <!--<context:property-placeholder location="classpath:redis.properties" />-->

    <!-- 2. redis连接池配置-->
    <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}"/>
        <!--逐出连接的最小空闲时间 默认1800000毫秒(30分钟)-->
        <property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}"/>
        <!--每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3-->
        <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}"/>
        <!--逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1-->
        <property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}"/>
        <!--是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个-->
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
        <!--在空闲时检查有效性, 默认false  -->
        <property name="testWhileIdle" value="${redis.testWhileIdle}"/>
    </bean>

    <!-- 3. redis连接工厂 -->
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          destroy-method="destroy">
        <property name="poolConfig" ref="poolConfig"/>
        <!--IP地址 -->
        <property name="hostName" value="${redis.hostName}"/>
        <!--端口号  -->
        <property name="port" value="${redis.port}"/>
        <!--如果Redis设置有密码  -->
        <property name="password" value="${redis.password}"/>
        <!--客户端超时时间单位是毫秒  -->
        <property name="timeout" value="${redis.timeout}"/>
    </bean>

    <!-- 4. redis操作模板,使用该对象可以操作redis
        hibernate课程中hibernatetemplete，相当于session，专门操作数据库。
    -->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="connectionFactory"/>
        <!--如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！！  -->
        <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>

    <!--  5.配置缓存管理器  -->
    <bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
        <constructor-arg name="redisOperations" ref="redisTemplate"/>
        <!--redis缓存数据过期时间单位秒-->
        <property name="defaultExpiration" value="${redis.expiration}"/>
        <!--是否使用缓存前缀，与cachePrefix相关-->
        <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>

    <!--6.配置缓存生成键名的生成规则-->
    <bean id="cacheKeyGenerator" class="com.zking.ssm.redis.CacheKeyGenerator"></bean>

    <!--7.启用缓存注解功能-->
    <cache:annotation-driven cache-manager="redisCacheManager" key-generator="cacheKeyGenerator"/>
</beans>

 

1.3.修改applicationContext.xml

如果spring配置文件中需要配置两个及以上的properties文件则需要在applicationContext.xml中进行配置处理，否则会出现覆盖的情况。

<?xml version="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">
    <!--1. 引入外部多文件方式 -->
    <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.properties</value>
                <value>classpath:redis.properties</value>
            </list>
        </property>
    </bean>

<!--  随着后续学习，框架会越学越多，不能将所有的框架配置，放到同一个配制间，否者不便于管理  -->
    <import resource="applicationContext-mybatis.xml"></import>
    <import resource="spring-redis.xml"></import>
    <import resource="applicationContext-shiro.xml"></import>
</beans>

1.4.配置redis的key生成策略

CacheKeyGenerator.java

package com.zking.ssm.redis;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.util.ClassUtils;

import java.lang.reflect.Array;
import java.lang.reflect.Method;

@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;

    @Override
    public Object generate(Object target, Method method, Object... params) {
        StringBuilder key = new StringBuilder();
        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;
    }
}

 

具体生成缓存键的逻辑如下：

  1. 首先，将目标对象的简单类名和方法名添加到缓存键中，以方便区分不同的方法。
  2. 接下来，根据方法的参数个数进行判断：
    • 如果参数个数为0，则将NO_PARAM_KEY添加到缓存键中，表示没有参数。
    • 如果参数个数大于0，则遍历参数数组，根据参数的类型和取值来生成缓存键的一部分。
  3. 在遍历参数数组时，判断参数的类型：
    • 如果参数为null，则将NULL_PARAM_KEY添加到缓存键中，表示参数为null。
    • 如果参数为基本类型数组，则遍历数组中的元素，并将每个元素及其索引添加到缓存键中。
    • 如果参数为基本类型或包装类类型，或者是字符串类型，则直接将参数添加到缓存键中。
    • 如果参数为其他类型，则使用参数对象的哈希码作为缓存键的一部分。
  4. 最后，将生成的缓存键转换成字符串，并返回。

在代码中，通过log.debug()语句输出了生成的缓存键，方便调试和查看。

注意事项：

  • 为了保证缓存键的唯一性，需要确保目标对象、方法以及参数的哈希码等逻辑正确。可以通过重写对象的hashCode()和equals()方法来确保哈希码的正确性。
  • 在使用自定义的缓存键生成器时，需要将其配置为Spring缓存注解的keyGenerator属性的值，以替代默认的缓存键生成器。

二、Redis的注解式开发及应用场景        

2.1.什么是Redis注解式

Redis的注解式是指通过使用Spring框架提供的缓存注解，在业务代码中对Redis进行读写操作的方式。这种方式可以大大简化开发人员对缓存的操作，避免了手动编写Redis API代码的繁琐操作。

Spring框架提供了一系列缓存注解，其中常用的有：

  1. @Cacheable: 表示方法的返回值可以被缓存，如果缓存中已经存在相同Key的值，则直接返回缓存中的值，否则会执行方法体中的代码，并将返回值存储到缓存中。

  2. @CachePut: 表示将方法的返回值存储到缓存中，常用于更新缓存中的值。

  3. @CacheEvict: 表示从缓存中删除指定的Key，常用于删除缓存中的某个值。

  4. @Caching: 表示对多个缓存注解进行组合，常用于同时使用多个注解的场景。

  5. @CacheConfig: 可以在类级别上设置缓存相关的配置，避免在每个方法上重复设置。

通过使用这些缓存注解，开发人员可以快速方便地实现对Redis的读写操作，同时也能够灵活地控制缓存的过期时间、缓存Key的生成规则等。

2.2.为什么使用Redis注解式

使用缓存注解的主要目的是为了提高应用程序的性能和响应速度。当应用程序从数据库或其他资源中获取数据时，如果这些数据在未来的请求中可能会被多次读取，那么使用缓存可以显著减少每个请求的响应时间。缓存将数据存储在内存中，因此可以快速读取，而不需要每次都访问数据库或其他资源。

使用缓存注解还可以减少对数据库或其他资源的负载，从而减少应用程序的资源消耗。当数据被缓存时，应用程序不需要每次都访问数据库或其他资源，从而减轻了这些资源的负载。

在使用缓存注解时，需要注意该注解的生命周期和缓存策略。缓存的生命周期指定了数据在缓存中存储的时间，而缓存策略则指定了何时应将数据从缓存中删除。通过选择适当的生命周期和缓存策略，可以优化缓存的性能和效率。

总之，使用缓存注解可以显著提高应用程序的性能和响应速度，减少对数据库或其他资源的负载，并优化缓存的性能和效率。

2.3.Redis注解式的应用

首先搞一个test类来进行讲解

package com.zking.ssm.biz;

import com.zking.ssm.model.Clazz;
import com.zking.ssm.util.PageBean;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;

import java.util.List;
import java.util.Map;

public interface ClazzBiz {
    @CacheEvict(value = "xx",key = "'cid:'+#cid",allEntries = true)
    int deleteByPrimaryKey(Integer cid);

    int insert(Clazz record);

    int insertSelective(Clazz record);

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

    int updateByPrimaryKeySelective(Clazz record);

    int updateByPrimaryKey(Clazz record);

    List<Clazz> listPager(Clazz clazz, PageBean pageBean);
    List<Map> listMapPager(Clazz clazz, PageBean pageBean);
}

①Cacheable

使用该注解会将查询结果放入Redis中下一次同样的查询就不会走数据库，而是走Redis.

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

value：缓存位置的一段名称，不能为空
key：缓存的key，默认为空，表示使用方法的参数类型及参数值作为key，支持SpEL
condition：触发条件，满足条件就加入缓存，默认为空，表示全部都加入缓存，支持SpEL 

②CachePut

该注解会将查询结果放入Redis中，类似于更新操作，即每次不管缓存中有没有结果，都从数据库查找结果，并将结果更新到缓存，并返回结果

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

value：缓存的名称，在 spring 配置文件中定义，必须指定至少一个
key：缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，如果不指定，则缺省按照方法的所有参数进行组合
condition：缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才进行缓存

③CacheEvict

用来清除用在本方法或者类上的缓存数据

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

value：缓存位置的一段名称，不能为空
key：缓存的key，默认为空，表示使用方法的参数类型及参数值作为key，支持SpEL
condition：触发条件，满足条件就加入缓存，默认为空，表示全部都加入缓存，支持SpEL
allEntries：true表示清除value中的全部缓存，默认为false

2.4.CachePut和Cacheable的区别

Cacheable和CachePut都是Spring框架中用于缓存的注解，它们的主要区别是：

  1. Cacheable用于获取缓存中的数据，如果缓存不存在，就会执行方法并将返回值放入缓存中；而CachePut用于更新缓存中的数据，它每次都会执行方法，并将返回值放入缓存中。

  2. Cacheable和CachePut的key生成方式不同，Cacheable默认使用方法的参数作为key，可以通过key属性指定key的生成方式或使用SpEL表达式自定义key的生成方式；而CachePut默认使用Cacheable的默认key生成方式，也可以通过key属性指定key的生成方式。

  3. Cacheable和CachePut的Sync属性也不同，Cacheable默认为false，即异步处理；而CachePut默认为true，即同步处理。

因此，Cacheable适用于需要从缓存中获取数据的场景，比如读取数据库中的数据；而CachePut适用于需要更新缓存中的数据的场景，比如写入数据库或者删除数据。

在具体应用场景中，可以根据实际需求选择合适的注解。例如，当我们需要查询用户信息时，可以使用Cacheable注解将查询结果缓存起来，下一次查询同样的信息时，直接从缓存中读取，避免了频繁访问数据库，提高了响应速度；当我们需要修改用户信息时，可以使用CachePut注解将修改后的信息更新缓存，保证缓存与数据库的一致性。

三、Redis中的击穿、穿透、雪崩的三种场景

3.1.缓存穿透

首先，我们来说说缓存穿透。什么是缓存穿透呢？缓存穿透问题在一定程度上与缓存命中率有关。如果我们的缓存设计的不合理，缓存的命中率非常低，那么，数据访问的绝大部分压力都会集中在后端数据库层面。

1.什么是缓存穿透？

如果在请求数据时，在缓存层和数据库层都没有找到符合条件的数据，也就是说，在缓存层和数据库层都没有命中数据，那么，这种情况就叫作缓存穿透。

我们可以使用下图来表示缓存穿透的现象。

造成缓存穿透的主要原因就是：查询某个Key对应的数据，Redis缓存中没有相应的数据，则直接到数据库中查询。数据库中也不存在要查询的数据，则数据库会返回空，而Redis也不会缓存这个空结果。这就造成每次通过这样的Key去查询数据都会直接到数据库中查询，Redis不会缓存空结果。这就造成了缓存穿透的问题。

2.如何解决缓存穿透问题？

既然我们知道了造成缓存穿透的主要原因就是缓存中不存在相应的数据，直接到数据库查询，数据库返回空结果，缓存中不存储空结果。

那我们就自然而然的想到了第一种解决方案：就是把空对象缓存起来。当第一次从数据库中查询出来的结果为空时，我们就将这个空对象加载到缓存，并设置合理的过期时间，这样，就能够在一定程度上保障后端数据库的安全。

第二种解决缓存穿透问题的解决方案：就是使用布隆过滤器，布隆过滤器可以针对大数据量的、有规律的键值进行处理。一条记录是不是存在，本质上是一个Bool值，只需要使用 1bit 就可以存储。我们可以使用布隆过滤器将这种表示是、否等操作，压缩到一个数据结构中。比如，我们最熟悉的用户性别这种数据，就非常适合使用布隆过滤器来处理。

3.2.缓存击穿

如果我们为缓存中的大部分数据设置了相同的过期时间，则到了某一时刻，缓存中的数据就会批量过期。

1.什么是缓存击穿？

如果缓存中的数据在某个时刻批量过期，导致大部分用户的请求都会直接落在数据库上，这种现象就叫作缓存击穿。

我么可以使用下图来表示缓存击穿的线程。

造成缓存击穿的主要原因就是：我们为缓存中的数据设置了过期时间。如果在某个时刻从数据库获取了大量的数据，并设置了相同的过期时间，这些缓存的数据就会在同一时刻失效，造成缓存击穿问题。

2.如何解决缓存击穿问题？

对于比较热点的数据，我们可以在缓存中设置这些数据永不过期；也可以在访问数据的时候，在缓存中更新这些数据的过期时间；如果是批量入库的缓存项，我们可以为这些缓存项分配比较合理的过期时间，避免同一时刻失效。

还有一种解决方案就是：使用分布式锁，保证对于每个Key同时只有一个线程去查询后端的服务，某个线程在查询后端服务的同时，其他线程没有获得分布式锁的权限，需要进行等待。不过在高并发场景下，这种解决方案对于分布式锁的访问压力比较大。

3.3.缓存雪崩

如果缓存系统出现故障，所有的并发流量就会直接到达数据库。

1.什么是缓存雪崩？

如果在某一时刻缓存集中失效，或者缓存系统出现故障，所有的并发流量就会直接到达数据库。数据存储层的调用量就会暴增，用不了多长时间，数据库就会被大流量压垮，这种级联式的服务故障，就叫作缓存雪崩。

我们可以用下图来表示缓存雪崩的现象。

造成缓存雪崩的主要原因就是缓存集中失效，或者缓存服务发生故障，瞬间的大并发流量压垮了数据库。

2.如何解决缓存雪崩问题？

解决缓存雪崩问题最常用的一种方案就是保证Redis的高可用，将Redis缓存部署成高可用集群（必要时候做成异地多活），可以有效的防止缓存雪崩问题的发生。

为了缓解大并发流量，我们也可以使用限流降级的方式防止缓存雪崩。例如，在缓存失效后，通过加锁或者使用队列来控制读数据库写缓存的线程数量。具体点就是设置某些Key只允许一个线程查询数据和写缓存，其他线程等待。则能够有效的缓解大并发流量对数据库打来的巨大冲击。

另外，我们也可以通过数据预热的方式将可能大量访问的数据加载到缓存，在即将发生大并发访问的时候，提前手动触发加载不同的数据到缓存中，并为数据设置不同的过期时间，让缓存失效的时间点尽量均匀，不至于在同一时刻全部失效。

 

请添加图片描述​

到这里我的分享就结束了，欢迎到评论区探讨交流！！

💖如果觉得有用的话还请点个赞吧 💖

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1178470.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

2000-2022年上市公司供应链数字化示范名单匹配数据

2000-2022年上市公司供应链数字化示范名单匹配数据

2000-2022年上市公司供应链数字化示范名单匹配数据 1、时间&#xff1a;2000-2022年 2、来源&#xff1a;商务部 3、指标&#xff1a; 上市公司供应链数字化&#xff08;根据城市名单匹配&#xff09;&#xff1a;股票代码、年份、股票简称、中文全称、省份、城市、区县、上…
阅读更多...
接口请求断言

接口请求断言

接口请求断言是指在发起请求之后&#xff0c;对返回的响应内容去做判断&#xff0c;用来查看是否响应内容是否与规定的返回值相符。 在发起请求后&#xff0c;我们使用一个变量 r 存储响应的内容&#xff0c;也就是 Response 对象。 Response 对象有很多功能强大的方法可以调…
阅读更多...
[动态规划] (九) 路径问题：LeetCode 64.最小路径和

[动态规划] (九) 路径问题：LeetCode 64.最小路径和

[动态规划] (九) 路径问题&#xff1a;LeetCode 64.最小路径和 文章目录 [动态规划] (九) 路径问题&#xff1a;LeetCode 64.最小路径和题目解析解题思路状态表示状态转移方程初始化和填表顺序返回值 代码实现总结 64. 最小路径和 题目解析 (1) 从左上角到右下角 (2) 只能向右…
阅读更多...
Poetry：Python开发者的依赖管理新时代

Poetry：Python开发者的依赖管理新时代

更多资料获取 &#x1f4da; 个人网站&#xff1a;涛哥聊Python 在Python开发中&#xff0c;管理项目的依赖关系是一个至关重要的任务。传统上&#xff0c;开发者使用requirements.txt文件和pip工具来管理依赖&#xff0c;但这种方式在复杂项目中存在一些问题。Poetry是一个现…
阅读更多...
Docker 学习路线 5：在 Docker 中实现数据持久化

Docker 学习路线 5：在 Docker 中实现数据持久化

Docker 可以运行隔离的容器&#xff0c;包括应用程序和其依赖项&#xff0c;与主机操作系统分离。默认情况下&#xff0c;容器是临时的&#xff0c;这意味着容器中存储的任何数据在终止后都将丢失。为了解决这个问题并在容器生命周期内保留数据&#xff0c;Docker 提供了各种数…
阅读更多...
kafka问题汇总

kafka问题汇总

报错1&#xff1a; 解决方式 1、停止docker服务   输入如下命令停止docker服务 systemctl stop docker 或者service docker stop1   停止成功的话&#xff0c;再输入docker ps 就会提示出下边的话&#xff1a; Cannot connect to the Docker daemon. Is the docker daem…
阅读更多...
通过全流量查看部门或客户端网络使用情况

通过全流量查看部门或客户端网络使用情况

近年来&#xff0c;随着数字化转型和云计算服务的广泛应用&#xff0c;组织和企业对于网络带宽和性能的需求也在不断增长。 网络的稳定性、性能和安全性对于业务流程的顺畅运行至关重要。因此&#xff0c;了解部门或客户端网络的使用情况是网络管理和优化的关键。本文将通过Ne…
阅读更多...
【C++】STL容器适配器——stack类的使用指南（含代码使用）（17）

【C++】STL容器适配器——stack类的使用指南（含代码使用）（17）

前言 大家好吖&#xff0c;欢迎来到 YY 滴C系列 &#xff0c;热烈欢迎&#xff01; 本章主要内容面向接触过C的老铁 主要内容含&#xff1a; 欢迎订阅 YY滴C专栏&#xff01;更多干货持续更新&#xff01;以下是传送门&#xff01; 目录 一、stack 类——基本介绍二、stack 类…
阅读更多...
if语句中的按位取反问题

if语句中的按位取反问题

&#x1f380; 文章作者&#xff1a;二土电子 &#x1f338; 关注公众号获取更多资源&#xff01; &#x1f438; 期待大家一起学习交流&#xff01; 文章目录 一、现象描述1.1 在C语言中&#xff08;非STM32&#xff09;1.2 STM32中运行 二、基础知识复习2.1 原码、反码和补…
阅读更多...
dell r720部署chatglm3，使用nvidia tesla P40+M40

dell r720部署chatglm3，使用nvidia tesla P40+M40

dell r720的idrac的地址默认是192.168.1.110&#xff0c;root 默认密码calvin fatal Error! All channnels have been disabled due to all DIMMs failed the Memoey 是什么意思 Dell PowerEdge T320服务器 开机显示 Fatal Errort!all channells have been disabled due to …
阅读更多...
NSSCTF第11页（1）

NSSCTF第11页（1）

[HUBUCTF 2022 新生赛]Calculate 进到主页 翻译 回答以下数学问题20次&#xff1b;你有3秒钟的时间来解决每个问题&#xff1b; 为了保护服务器&#xff0c;你不能在1秒内回答一个问题 您已回答0个问题&#xff1b; 让我们3秒速算&#xff0c;没那个实力&#xff0c;提示说是写…
阅读更多...
Kotlin基础数据类型和运算符

Kotlin基础数据类型和运算符

原文链接 Kotlin Types and Operators Kotlin是新一代的基于JVM的静态多范式编程语言&#xff0c;功能强大&#xff0c;语法简洁&#xff0c;前面已经做过Kotlin的基本的介绍&#xff0c;今天就来深入的学习一下它的数据类型和运算操作符。 数据类型 与大部分语言不同的是&am…
阅读更多...
Vue多级路由的实现

Vue多级路由的实现

对Vue路由的配置不了解的看这篇文章&#xff1a;Vue-router 路由的基本使用-CSDN博客 一、配置children属性 注意&#xff1a;子路径不能带 / { path : "/父路径", component : 父组件, children : [{ path : "子路径", component : 子组件 }] } 二、配…
阅读更多...
读源码的七大步骤

读源码的七大步骤

前序 在如今信息这么发达的时代&#xff0c;如何让自己成长得最快&#xff0c;莫过于直接去“学习”别人已经写好的产品。但一提到读源码&#xff0c;很多人都会比较畏惧&#xff0c;认为读源码是高手才会做的事情。毕竟动不动几十万行代码的源码&#xff0c;谁看了不害怕呢&a…
阅读更多...
软件开发必备神器！一文读懂10款热门看板工具推荐！

软件开发必备神器！一文读懂10款热门看板工具推荐！

看板&#xff08;Kanban&#xff09;是一种流行的框架&#xff0c;用于实施敏捷和DevOps软件开发。它要求实时沟通每个人的能力&#xff0c;并全面透明地展示正在进行的工作。工作项目在看板上以可视化方式表示&#xff0c;使项目经理和所有团队成员可以随时查看每个工作的状态…
阅读更多...
云尘靶场 --铁三域控

云尘靶场 --铁三域控

签到1-eval ls System Assert 铁三域控 域就像是我们一个机房&#xff0c;老师的电脑控制很多很多电脑&#xff0c;这个机房就像一个域&#xff0c;老师是管理员身份&#xff0c;可以控制所有学生的电脑 下文的141就像老师&#xff0c;192.168.60.100就像学生的电脑 123 用…
阅读更多...
Linux学习笔记之四（文件IO、目录IO）

Linux学习笔记之四（文件IO、目录IO）

Linux 1、文件IO1.1、open and close1.2、read and write1.3、lseek1.4、综合练习 2、目录IO2.1、mkdir2.2、opendir, closedir, readdir2.3、综合练习 1、文件IO 1.1、open and close 使用以下代码查看以下open函数原型&#xff1a; man 2 open如图&#xff0c;open函数有两…
阅读更多...
测试开发角色定位

测试开发角色定位

&#x1f4e2;专注于分享软件测试干货内容&#xff0c;欢迎点赞 &#x1f44d; 收藏 ⭐留言 &#x1f4dd; 如有错误敬请指正&#xff01;&#x1f4e2;交流讨论&#xff1a;欢迎加入我们一起学习&#xff01;&#x1f4e2;资源分享&#xff1a;耗时200小时精选的「软件测试」资…
阅读更多...
python opencv 实现对二值化后的某一像素值做修改和mask叠加

python opencv 实现对二值化后的某一像素值做修改和mask叠加

实现对二值化后的某一像素值做修改 使用OpenCV的findNonZero函数找到所有非零&#xff08;也就是像素值为255&#xff09;的像素&#xff0c;然后遍历这些像素并修改他们的值。示例代码&#xff1a; import cv2 import numpy as np # 加载并二值化图像 img cv2.imread(…
阅读更多...
实验七 组合器模式的应用

实验七 组合器模式的应用

实验目的 1)掌握组合器模式&#xff08;composite&#xff09;的特点 2 分析具体问题&#xff0c;使用组合器模式进行设计。 实验内容和要求 在例3.3的设计中&#xff0c;添加一个空军大队( Wing)类&#xff0c;该类与Squadron、Group类是平行的&#xff0c;因此应该继承了AirU…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023