这个名字先用着

Spring Boot整合Redis实现缓存(实战详细)

目录

- 第一步：创建springboot项目
- 第二步：引入依赖：spring-boot-starter-data-redis
- 第三步：修改启动类：
- 第四步：准备数据表和实体类：
- 第五步：配置文件
- 常用redis缓存：相关注解介绍
- - 1 @Cacheable
  - 2 @CachePut
  - 3 @CacheEvict
- 第六步：接口文件：缓存注解使用的地方

第一步：创建springboot项目

第二步：引入依赖：spring-boot-starter-data-redis


        
        
            mysql
            mysql-connector-java
            8.0.22
        
        
        
            com.baomidou
            mybatis-plus-boot-starter
            3.4.2
        
        
        
            org.springframework.boot
            spring-boot-starter-data-redis
            2.6.6
        
        
        
            org.projectlombok
            lombok
            1.18.22
        

        
            org.springframework.boot
            spring-boot-starter
        
        
        
            io.springfox
            springfox-swagger2
            2.9.2
        
        
        
            io.springfox
            springfox-swagger-ui
            2.9.2
        

        
        
            org.springframework.boot
            spring-boot-starter-web
            2.6.9
        

        
            org.springframework.boot
            spring-boot-starter-test
            test

第三步：修改启动类：

package com.fan.rediscach;

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

@SpringBootApplication
@MapperScan("com.fan.rediscach.mapper") //mapper扫描
public class RediscachApplication {

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

}

第四步：准备数据表和实体类：

准备数据库和对用的实体类：

实体类com.fan.rediscach.entity.User：

@TableName和@TableField属于mybatis-plus的注解，很好用

package com.fan.rediscach.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "user")
public class User implements Serializable {

    private Long id;//一定使用包装类，实体类
    @TableField(value = "user_name")
    private String name;

    private String sex;
    private int age;

}

第五步：配置文件



# mysql数据库连接
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/mybatis_plus?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=***

spring.mvc.pathmatch.matching-strategy=ant_path_matcher

#redis配置
spring.cache.type=redis
pring.redis.database=0
pring.redis.port=6379
spring.redis.host=192.168.211.210 //自己redis地址
spring.redis.password=
spring.redis.timeout=1800000

配置类config包下：

Swagger2Config配置类：Swagger2测试接口比较方便

package com.fan.rediscach.config;

import com.google.common.base.Predicates;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 * Swagger2配置信息
 */
@Configuration
@EnableSwagger2
public class Swagger2Config {

    @Bean
    public Docket webApiConfig(){

        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("webApi")
                .apiInfo(webApiInfo())
                .select()
                //只显示api路径下的页面
                .paths(Predicates.and(PathSelectors.regex("/api/.*")))
                .build();

    }

    @Bean
    public Docket adminApiConfig(){

        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("adminApi")
                .apiInfo(adminApiInfo())
                .select()
                //这里要修改成自己的controller类上的requestmapping路径
                .paths(Predicates.and(PathSelectors.regex("/.*")))
                .build();

    }

    private ApiInfo webApiInfo(){

        return new ApiInfoBuilder()
                .title("网站-API文档")
                .description("本文档描述了网站微服务接口定义")
                .version("1.1")
                .contact(new Contact("fan", "http://atguigu.com", "[email protected]"))
                .build();
    }

    private ApiInfo adminApiInfo(){

        return new ApiInfoBuilder()
                .title("后台管理系统-API文档")
                .description("本文档描述了后台管理系统微服务接口定义")
                .version("1.1")
                .contact(new Contact("fan", "http://atguigu.com", "[email protected]"))
                .build();
    }


}

RedisConfig配置类：

package com.fan.rediscach.config;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.*;
import java.time.Duration;

/**
 * Redis 配置类
 */
@Configuration
@EnableCaching //开启缓存配置
public class RedisConfig {

    /**
     * 配置缓存管理器
     * @param factory Redis 线程安全连接工厂
     * @return 缓存管理器
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        // 生成两套默认配置，通过 Config 对象即可对缓存进行自定义配置
        RedisCacheConfiguration cacheConfig1 = RedisCacheConfiguration.defaultCacheConfig()
                // 设置过期时间 10 分钟
                .entryTtl(Duration.ofMinutes(10))
                // 设置缓存前缀
                .prefixKeysWith("cache:user:")
                // 禁止缓存 null 值
                .disableCachingNullValues()
                // 设置 key 序列化
                .serializeKeysWith(keyPair())
                // 设置 value 序列化
                .serializeValuesWith(valuePair());

        RedisCacheConfiguration cacheConfig2 = RedisCacheConfiguration.defaultCacheConfig()
                // 设置过期时间 30 秒
                .entryTtl(Duration.ofSeconds(30))
                .prefixKeysWith("cache:admin:")
                .disableCachingNullValues()
                .serializeKeysWith(keyPair())
                .serializeValuesWith(valuePair());

        // 返回 Redis 缓存管理器
        return RedisCacheManager.builder(factory)
                .withCacheConfiguration("user", cacheConfig1)
                .withCacheConfiguration("admin", cacheConfig2)
                .build();
    }

    /**
     * 配置键序列化
     * @return StringRedisSerializer
     */
    private RedisSerializationContext.SerializationPair keyPair() {
        return RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer());
    }

    /**
     * 配置值序列化，使用 GenericJackson2JsonRedisSerializer 替换默认序列化
     * @return GenericJackson2JsonRedisSerializer
     */
    private RedisSerializationContext.SerializationPair