springboot整合redis分别实现手动缓存和注解缓存

最新推荐文章于 2024-08-23 09:36:37 发布
最新推荐文章于 2024-08-23 09:36:37 发布
阅读量807 收藏 1
点赞数 2
分类专栏： # redis 文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26356861/article/details/105864740
版权

一、前期准备

  1. 一个构建好的springboot系统
  2. 下载redis安装包，去redis官网下载
  3. 启动redis服务，windows下双击bin目录下的redis-service.exe

二、环境构建

  1. 在项目的pom.xml中引入redis依赖
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
  1. 在项目配置文件application.yml中添加redis配置
spring:
  #redis缓存
  redis:
    open: true  # 是否开启redis缓存  true开启   false关闭
    database: 0
    host: 127.0.0.1
    port: 6379
    password:    # 密码（默认为空）
    timeout: 60000ms  # 连接超时时长（毫秒）
    jedis:
      pool:
        max-active: 1000  # 连接池最大连接数（使用负值表示没有限制）
        max-wait: -1ms      # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 10      # 连接池中的最大空闲连接
        min-idle: 5       # 连接池中的最小空闲连接

三、redis手动缓存

1、缓存配置


import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
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.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.time.Duration;

/**
 * 缓存配置类
 * @author 谢小鱼
 * @Date 2019-11-20 11:00
 **/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    @Bean
    public ValueOperations<String, String> valueOperations(RedisTemplate<String, String> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}

四、redis注解缓存

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
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.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.time.Duration;

/**
 * 缓存配置类
 * @author 谢小鱼
 * @Date 2019-11-20 11:00
 **/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    private static final Logger logger = LoggerFactory.getLogger(RedisConfig.class);
    @Autowired
    private RedisConnectionFactory factory;
    /**
     * 默认两小时
     */
    private static final long DURATION_SECOND_7200 = 7200L;
    private static final long DURATION_SECOND_300 = 300L;
    
    @Override
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @SuppressWarnings("rawtypes")
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder(RedisAutoCacheValue.AUTO_KEY_PREFIX);
                if(target instanceof Proxy) {
                	//如果是代理类
                	Class[] i = target.getClass().getInterfaces();
                	if(i != null  && i.length > 0) {
                		//取第一个即可
                		sb.append(i[0].getName());
                	}else {
                		sb.append(target.getClass().getName());
                	}
                } else if(target instanceof org.springframework.cglib.proxy.Factory){
                    //如果是cglib代理，需要手动去除 $$ 后面的
                    String className = target.getClass().getName();
                    sb.append(className, 0, className.indexOf("$$"));
                } else {
                	sb.append(target.getClass().getName());
                }
                sb.append(".");
                sb.append(method.getName());
                sb.append("_");
                for (Object obj : params) {
                    if (obj != null) {
                        Class cls = obj.getClass();
                        if (cls.isArray()) {
                            //对于基础数据处理
                            logger.info("keyGenerator : {}", cls.getComponentType());
                            if (cls.isAssignableFrom(long.class)) {
                                long[] ay = (long[]) obj;
                                for (long o : ay) {
                                    sb.append(o).append("");
                                }
                            } else if (cls.isAssignableFrom(int.class)) {
                                int[] ay = (int[]) obj;
                                for (int o : ay) {
                                    sb.append(o).append("");
                                }
                            } else if (cls.isAssignableFrom(float.class)) {
                                float[] ay = (float[]) obj;
                                for (float o : ay) {
                                    sb.append(o).append("");
                                }
                            } else if (cls.isAssignableFrom(double.class)) {
                                double[] ay = (double[]) obj;
                                for (double o : ay) {
                                    sb.append(o).append("");
                                }
                            } else if (cls.isAssignableFrom(String.class)) {
                                String[] ay = (String[]) obj;
                                for (String o : ay) {
                                    sb.append(o).append("");
                                }
                            } else {
                                sb.append(obj.toString());
                            }
                            //TODO 对其他类型数组处理
                        } else {
                            sb.append(obj.toString());
                        }
                    } else {
                        sb.append("null");
                    }
                    sb.append("_");
                    //sb.append(obj == null ? "null" : obj.toString());
                }
                sb.delete(sb.length()-1, sb.length());
                return sb.toString();
            }

        };

    }

    /**
     * 默认的缓存管理，存放时效较长的缓存
     * @param redisTemplate
     * @return
     */
    @SuppressWarnings({"rawtypes", "Duplicates"})
    @Primary
    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheConfiguration config = RedisCacheConfiguration
                .defaultCacheConfig()
                //过期时间
                .entryTtl(Duration.ofSeconds(DURATION_SECOND_7200))
                //不缓存null值
                //.disableCachingNullValues()
                //明确manager中的序列化与template一样，防止莫名其妙的问题
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(this.keySerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(this.valueSerializer()));

        RedisCacheManager rcm = RedisCacheManager.builder(redisTemplate.getConnectionFactory()).cacheDefaults(config).transactionAware().build();
        return rcm;
    }

    /**
     * 存放时效较短的缓存（5分钟）
     * @param redisTemplate
     * @return
     */
    @SuppressWarnings({"rawtypes", "Duplicates"})
    @Bean
    public CacheManager cacheManagerIn5Minutes(RedisTemplate redisTemplate) {
        RedisCacheConfiguration config = RedisCacheConfiguration
                .defaultCacheConfig()
                //过期时间
                .entryTtl(Duration.ofSeconds(DURATION_SECOND_300))
                //不缓存null值
                //.disableCachingNullValues()
                //明确manager中的序列化与template一样，防止莫名其妙的问题
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(this.keySerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(this.valueSerializer()));

        RedisCacheManager rcm = RedisCacheManager.builder(redisTemplate.getConnectionFactory()).cacheDefaults(config).transactionAware().build();
        return rcm;
    }
    
    private RedisSerializer<String> keySerializer() {
        return new StringRedisSerializer();
    }
    private RedisSerializer<Object> valueSerializer() {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        //略过不匹配的属性
        om.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        jackson2JsonRedisSerializer.setObjectMapper(om);
        return jackson2JsonRedisSerializer;
    }
}

自动缓存key：

/**
 * 自动缓存value集中在此
 * @author Leon
 * @Date 2019-11-19 12:38
 **/
public class RedisAutoCacheValue {

    /**
     * 自动生成key前缀
     */
    public static final String AUTO_KEY_PREFIX = "AUTO:";
}

推荐使用注解的方式操作redis，便于维护

谢小鱼
关注
专栏目录
Springboot redis缓存
weixin_68193389的博客
10-25 267
在支持Spring Cache的环境下，对于使用@Cacheable标注的方法，Spring在每次执行前都会检查Cache中是否存在相同key的缓存元素，如果存在就不再执行该方法，而是直接从缓存中获取结果进行返回，否则才会执行并将返回结果存入指定的缓存中。在存储快照后，还可以让redis来进行数据校验，如果数据已经损坏就不需要再进行持久化的操作，这样做会增加大约10%的性能消耗，如果希望获取到最大的性能提升，可以关闭此功能,推荐yes.使用新的AOF文件覆盖旧的AOF文件，完成AOF重写。
springboot集成redis，实现手动缓存（AOP+注解）
aimeng555的博客
04-04 1746
redis简介 REmote DIctionary Server(Redis) 是一个由 Salvatore Sanfilippo 写的 key-value 存储系统，是跨平台的非关系型数据库。 Redis 是一个开源的使用 ANSI C 语言编写、遵守 BSD 协议、支持网络、可基于内存、分布式、可选持久性的键值对(Key-Value)存储数据库，并提供多种语言的 API。 Redis 通常被称为数据结构服务器，因为值（value）可以是字符串(String)、哈希(Hash)、列表(list)、集合(s
springboot集成redis(缓存篇)
知识追寻者(Inheriting the spirit of open source, Spreading technology knowledge;)
05-13 594
一 前言 公众号：知识追寻者 知识追寻者(Inheriting the spirit of open source, Spreading technology knowledge;) pring为我们提供的缓存注解Spring Cache。Spring支持多种缓存技术：RedisCacheManager，EhCacheCacheManager、GuavaCacheManager等，今天的内容是集成RedisCacheManager实现缓存技术； 二 Spring Cache spring cache 常
Spring Boot集成Redis缓存的最佳实践
最新发布
微赚淘客开发者博客
08-23 437
在现代的软件开发中，缓存技术是提升应用性能的关键手段之一。Spring Boot作为一个流行的Java框架，提供了与Redis缓存的集成，使得开发者可以轻松地在应用中实现缓存功能。同时，也要注意缓存策略的选择和缓存数据的管理，以避免潜在的问题。Spring Data Redis默认使用Java的序列化机制，但我们可以自定义序列化器来提高性能。可以在方法执行前检查缓存，如果缓存中有数据则直接返回，否则执行方法并将结果存入缓存。大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！
SpringBoot中使用Redis实现缓存
热门推荐
u011851478的博客
04-19 1万+
摘要: 原创出处 http://peijie2016.oschina.io 欢迎转载，保留摘要，谢谢！ Spring Data Redis为我们封装了Redis客户端的各种操作，简化使用。 - 当Redis当做数据库或者消息队列来操作时，我们一般使用RedisTemplate来操作 - 当Redis作为缓存使用时，我们可以将它作为Spring Cache的实现，直接通过注解使用关于RedisTe
通过注解实现Redis缓存功能
chaojiyingxiong的博客
01-22 1709
redis、@Cacheable、@CachePut、@CacheEvict
SpringBoot Redis 缓存
小虎哥的技术博客
05-15 210
一、前言 Redis是内存数据库，什么是内存数据库，内存数据库是相对于硬盘数据库的。您的电脑配置是内存16G,硬盘500G，Redis的数据就是放在16G内存中，Mysql数据就放在500G硬盘中。 内存读写速度快，所以Redis数据库快，那它可以做缓存和一些访问率高的数据存储。 因为是内存数据库，所以Redis存储容量小，而且断电了数据会丢失。 所以Redis不要存储数据量大的数据，对于断电数据丢失，redis有两种持久化策略(记录命令和定时刷盘)，这些后续再说。 废话不多话，SpringBoot集成Re
8分钟带你学会SpringBoot整合Redis来实现缓存技术
好程序员IT教育
11-15 580
随着互联网技术的发展，对技术要求也越来越高，所以在当期情况下项目的开发中对数据访问的效率也有了很高的要求，所以在项目开发中缓存技术使用的也越来越多，因为它可以极大的提高系统的访问速度，关于缓存的框架也种类繁多，比如 Redis、Ehchahe、JBoss Cache、Voldemort、Cacheonix 等等，今天主要介绍的是使用现在非常流行的 NoSQL 数据库（Redis）来实现我们的缓存需求。
Springboot 整合 redis实现缓存
我的第一个博客
08-02 348
基于注解的接口、方法等缓存的实现 1. pom文件引入依赖 <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 --> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> </dependency>
SpringBoot 整合 Redis、mybatis 完整项目源码下载
05-26
4. **Redis缓存配置**: 可以使用`@Cacheable`、`@CacheEvict`、`@CachePut`等注解实现方法级缓存，提升应用性能。 5. **RedisUtil工具类**: 封装通用的Redis操作，如设置、获取、删除键值对等，便于代码复用和管理...
Spring Boot的Redis缓存
Trapped_beast的博客
07-23 314
1. 什么是Redis缓存，为什么要用Redis缓存 Redis 是一种内存高速cache，如果使用redis缓存，那经常被访问的内容会被缓存在内存中，需要使用的时候直接从内存调取，不知道比硬盘调取快了多少倍，并且支持复杂的数据结构，应用于许多高并发的场景中。 Redis 是一个高性能的 key-value 数据库。 2. Redis使用之前先安装 先从官网下载，然后解压，找一个目录放好 官网：https://github.com/tporadowski/redis/releases 管理员身份运行命
springboot2.0整合redis缓存注解
itboy
05-21 740
一、JSR107缓存规范 CachingProvider 【缓存提供者】 定义了创建、配置、获取、管理和控制多个CacheManager。一个应用可以在运行期访问多个CachingProvider CacheManager 【缓存管理】 定义了创建、配置、获取、管理和控制多个唯一命名的Cache，这些Cache存在于CacheManager的上下文中。一个CacheManager仅被一个CachingProvider所拥有 Cache 【缓存】 是一个类似Map的数据结构并临时存储以Key为
Springboot 中的 redis 缓存
tianjiliuhen的博客
06-28 393
Springboot 中缓存的使用一。说明二。springboot中使用缓存(redis)1.引入依赖2.在 application.yml 中指定 缓存方式3.在 application.yml 中指定 redis 连接信息4.在启动类上开启缓存5.注解的使用说明1.读取缓存2.更新缓存3.删除缓存三。缓存不生效问题的解决 一。说明 1.springboot 中的缓存遵循 JSR107 规范。 2.spring 中 从 3.1 版本开始，实现了 JSR107规范，进行了缓存的抽象。 3.springboo
springboot整合redis 使用缓存注解
lin1214000999的博客
02-08 1750
1.启动类标明@EnableCaching @SpringBootApplication @MapperScan("com.jx.luckyDraw.mapper") @EnableCaching public class LuckyDrawApplication { public static void main(String[] args) { SpringApplication.run(LuckyDrawApplication.class, args); } }
SpringBoot中使用Redis作为缓存
编程学习者的博客
08-13 2824
环境：JDK1.8、MAVEN 3.6.1 、eclipse 1.添加redis依赖 当前的pom文件内容： <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <parent> ...
在SpringBoot中使用Redis缓存
qq_37771475的博客
01-21 425
前言 本项目主要采用H2作为数据库，Durid作为连接池，JPA作为持久层框架，Redis作为缓存。 注：本章与之前的使用H2Database+Druid连接池+Spring Data JPA+Ehcache实现CRUD操作，大同小异，所不同的是这里使用的是Redis缓存。如果相关概念不清楚，请查看上篇。  一、导入依赖包 &lt;?xml version="1.0" encodin...
Spring Boot整合Redis实现缓存操作(注解实现).md
凌晨四点的洛杉矶
09-27 326
在一些要求高一致性（任何数据变化都能及时的被查询到）的系统和应用中，就不能再使用EhCache来解决了，这个时候使用集中式缓存是个不错的选择，因此本文将介绍如何在Spring Boot的缓存支持中使用Redis进行数据缓存。 在pom.xml文件中添加redis依赖： &lt;dependency&gt; &lt;groupId&gt;org.springframework.b...
redis作为spring boot项目的缓存
qq_41539807的博客
05-26 205
一、背景 在日常开发中，有很多情况下需要使用缓存来提高系统的访问速度，本文章将使用redis和jetcache来介绍一种缓存在spring boot项目中的使用 二、使用 2.1引入相关依赖 <dependency> <groupId>com.alicp.jetcache</groupId> <artifactId>jetcache-starter-redis</artifactId>
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值