redis系列三-springboot如何使用redis做缓存及缓存注解的用法总结

合集下载

spring+redis实现数据的缓存

314<property name="locations">5<list>67<value>classpath*:/META-INF/config/redis.properties</value>8</list>9</property>10</bean>1112<import resource="spring-redis.xml"/>4)、web.xml设置spring的总配置⽂件在项⽬启动时加载1<context-param>2<param-name>contextConfigLocation</param-name>3<param-value>classpath*:/META-INF/applicationContext.xml</param-value> 4</context-param>5)、redis缓存⼯具类ValueOperations ——基本数据类型和实体类的缓存ListOperations ——list的缓存SetOperations ——set的缓存HashOperations Map的缓存1import java.io.Serializable;2import java.util.ArrayList;3import java.util.HashMap;4import java.util.HashSet;5import java.util.Iterator;6import java.util.List;7import java.util.Map;8import java.util.Set;910import org.springframework.beans.factory.annotation.Autowired;11import org.springframework.beans.factory.annotation.Qualifier;12import org.springframework.context.support.ClassPathXmlApplicationContext;13import org.springframework.data.redis.core.BoundSetOperations;14import org.springframework.data.redis.core.HashOperations;15import org.springframework.data.redis.core.ListOperations;16import org.springframework.data.redis.core.RedisTemplate;17import org.springframework.data.redis.core.SetOperations;18import org.springframework.data.redis.core.ValueOperations;19import org.springframework.stereotype.Service;2021@Service22public class RedisCacheUtil<T>23{2425 @Autowired @Qualifier("jedisTemplate")26public RedisTemplate redisTemplate;2728/**29 * 缓存基本的对象，Integer、String、实体类等30 * @param key 缓存的键值31 * @param value 缓存的值32 * @return缓存的对象33*/34public <T> ValueOperations<String,T> setCacheObject(String key,T value)35 {3637 ValueOperations<String,T> operation = redisTemplate.opsForValue();38 operation.set(key,value);39return operation;40 }4142/**43 * 获得缓存的基本对象。

redis系列三-springboot如何使用redis做缓存及缓存注解的用法总结

redis系列三-springboot如何使用redis做缓存及缓存注解的用法总结1. 概述本文介绍spring boot 如何使用Redis做缓存，如何对redis 缓存进行定制化配置(如key的有效期)以及spring boot 如何初始化redis做缓存。

使用具体的代码介绍了@Cacheable，@CacheEvict，@CachePut，@CacheConfig等注解及其属性的用法。

2. spring boot集成redis2.1. application.properties配置application.properties，包含如下信息：指定缓存的类型配置redis的服务器信息请不要配置spring.cache.cache-names值，原因后面再说## 缓存# spring.cache.cache-names=book1,book2spring.cache.type=REDIS# REDIS (RedisProperties)spring.redis.database=0spring.redis.host=192.168.188.7spring.redis.password=spring.redis.port=6379spring.redis.pool.max-idle=8spring.redis.pool.min-idle=0spring.redis.pool.max-active=100spring.redis.pool.max-wait=-1123456789101112131234567891 01112132.2. 配置启动类@EnableCaching: 启动缓存重新配置RedisCacheManager，使用新的配置的值@SpringBootApplication@EnableCaching // 启动缓存public class CacheApplication {private static final Logger log =LoggerFactory.getLogger(CacheApplication.class);public static void main(String[] args) {("Start CacheApplication.. ");SpringApplication.run(CacheApplication.class, args);}/*** 重新配置RedisCacheManager* @param rd*/@Autowiredpublic void configRedisCacheManger(RedisCacheManager rd){rd.setDefaultExpiration(100L);}}123456789101112131415161718192012345678910111213141 51617181920经过以上配置后，redis缓存管理对象已经生成。

程序员看了不后悔一步一步轻松实现SpringBoot整合Redis缓存

程序员看了不后悔一步一步轻松实现SpringBoot整合Redis缓存前言随着技术的发展，程序框架也越来越多，非常考验程序的学习能力，但是框架的产生在程序员开发过程中也提供很多便利，框架可以为程序员减少许多工作量，比如spring boot 、mybatis等都可以提高开发人员的工作效率，今天就来聊聊spring boot与redis 的整合。

一、基本概况为什么使用缓存缓存是在内存中存储的数据备份，当数据没有发生本质变化时就可以直接从内存中查询数据，而不用去数据库查询(在磁盘中)CPU读取内存的速度要比读取磁盘快，可以提高效率Redis缓存Remote Dictionnary Server(远程数据服务)，是一款内存高速缓存数据库。

五种常用数据类型： String（字符串）、List(列表)、Set(集合)、Hash(散列)、ZSet(有序集合)可持久化：一边运行，一边向硬盘备份一份，防止断电等偶然情况，导致内存中数据丢失二、搭建Redis环境1.下载Redis平台限制不能贴链接，自行去官网下载哈！2.设置Redis开机自启在解压好的文件夹下输入cmd命令window下安装Redis服务redis-server --service-install redis.windows.conf检查安装是否成功搜索服务点击设置为开机自启三、新建SpringBoot项目新建好项目的童鞋可以自动跳过添加web依赖选择数据库依赖选择项目位置，点击finish四、使用StringRedisTemplate操作Redis1.pom.xml文件引入坐标 <dependency><groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>2.在appliaction.properties配置redis数据库连接信息#redis配置#Redis服务器地址spring.redis.host=127.0.0.1#Redis服务器连接端口spring.redis.port=6379#Redis数据库索引（默认为0）spring.redis.database=03.在SpringbootdemoApplicationTests中测试操作Redis@SpringBootTestclass SpringbootdemoApplicationTests {@Autowired StringRedisTemplate stringRedisTemplate; //操作key-value都是字符串，最常用@Test public void test01(){ //字符串操作stringRedisTemplate.opsForValue().append("msg","coder"); //列表操作stringRedisTemplate.opsForList().leftPush("mylist","1"); stringRedisTemplate.opsForList().leftPush("mylist","2"); }}对于Redis的五大常用数据类型都提供了方法String（字符串）、List(列表)、Set(集合)、Hash(散列)、ZSet(有序集合)stringRedisTemplate.opsForValue();[String(字符串)]stringRedisTemplate.opsForList();[List(列表)]stringRedisTemplate.opsForSet();[Set(集合)]stringRedisTemplate.opsForHash();[Hash(散列)]stringRedisTemplate.opsForZSet();[ZSet(有序集合)]使用RedisDesktopManager可视化工具查看结果StringTemplate类中方法存取的key-value值是String类型，RedisTemplate中key-value值是Object类型，RedisTemplate是StringTemplate父类下面就用RedisTemplate实现从MySQL数据库取出数据放到Redis缓存五、使用RedisTemplate操作Redis1.项目目录结构2.建立与数据库相关的类建表的sql脚本application.properties配置文件MySQL及Redis连接的相关配置User类采用ORM思想，属性和数据库字段对应package com.thinkcoder.bean;import java.io.Serializable;importjava.util.Date;/*** @ClassName User * @Author Think-Coder * @Data 2020/5/27 10:35* @Version 1.0 */public class User implements Serializable { private Integer id; private String username; private Date birthday; private String sex;private String address; //getter和setter方法 public Integer getId() {returnid;} public void setId(Integer id) {this.id = id;} public StringgetUsername() {return username;} public void setUsername(String username){ername = username;} public Date getBirthday() {return birthday;}public void setBirthday(Date birthday) {this.birthday = birthday;} publicString getSex() {return sex;} public void setSex(String sex) {this.sex = sex;}public String getAddress() {return address;} public void setAddress(Stringaddress) {this.address = address;} //重写toString方法 @Override publicString toString() { return "User{" + "id=" + id +", username='" + username + '\'' + ", birthday=" + birthday + ", sex='" + sex + '\'' + ", address='" + address + '\'' + '}'; }}UserMapper类使用注解方法操作数据库@Mapperpublic interface UserMapper {@Select("SELECT * FROM user WHERE id =#{id}") User findById(int id);}3.MyRedisConfig自定义序列化类，将存储在Redis的对象序列化为json格式，不会产生乱码@Configuration@EnableAutoConfigurationpublic class MyRedisConfig {@Beanpublic RedisTemplate<Object, User> redisTemplate(RedisConnectionFactory redisConnectionFactory){ RedisTemplate<Object, User> template = newRedisTemplate<>(); template.setConnectionFactory(redisConnectionFactory);Jackson2JsonRedisSerializer<User> ser = newJackson2JsonRedisSerializer<>(User.class);template.setDefaultSerializer(ser); return template; }}4.工具类RedisUtil类//工具类中使用Autowired注解需要加上Compoent@Componentpublic class RedisUtil{@Autowired RedisTemplate redisTemplate; //key-value是对象的 //判断是否存在key public boolean hasKey(String key){ returnredisTemplate.hasKey(key); } //从redis中获取值 public Object get(String key){ return redisTemplate.opsForValue().get(key); } //向redis插入值 public boolean set(final String key,Object value){ boolean result = false; try{ redisTemplate.opsForValue().set(key,value); result = true; }catch (Exceptione){ e.printStackTrace(); } return result; }}5.sevice包代码IUserService@Servicepublic interface IUserService {//根据id查用户信息 UserfindById(int id);}UserService实现类@Servicepublic class UserServiceImpl implements IUserService {User user;@Autowired UserMapper userMapper; @Autowired private RedisUtil redisUtil; @Override public User findById(int id) { String key = "user"+id;if(redisUtil.hasKey(key)) { user = (User)redisUtil.get(key); System.out.println("查询的是缓存"); }else{ user =userMapper.findById(id); System.out.println("查询的是数据库"); System.out.println(redisUtil.set(key,user) ? "插入成功" : "插入失败"); } return user; }}erController类@RestControllerpublic class UserController {@Autowired IUserService userService; @GetMapping("/user/{id}") public UserfindById(@PathVariable("id") Integer id){ User user =userService.findById(id); return user; }}7.测试打开浏览器输入下方url查看控制台输出Redis Desktop Manager显示结果六、总结整体来说，操作Redis是两个类，RedisTemplate类和StringTemplate类，为父子关系，提供的方法正好对应操作Redis数据类型的指令，所以要把数据类型及常用的指令练熟。

SpringBoot（三）：SpringBoot中Redis的使用

}; } } 注意我们使用了注解：@EnableCaching来开启缓存。
@Bean public KeyGenerator keyGenerator() {
return new KeyGenerator() { @Override public Object generate(Object target, Method method, Object... params) { StringBuilder sb = new StringBuilder(); sb.append(target.getClass().getName()); sb.append(method.getName()); for (Object obj : params) { sb.append(obj.toString()); } return sb.toString(); }
1、引入依赖包 <dependency>
<groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>mons</groupId> <artifactId>commons-pool2</artifactId> </dependency> Spring Boot 提供了对 Redis 集成的组件包：spring-boot-starter-data-redis，spring-boot-starter-data-redis依赖于spring-data-redis 和 lettuce 。Spring Boot 1.0 默认使用的是 Jedis 客户端，2.0 替换成 Lettuce，但如果你从 Spring Boot 1.5.X 切换过来，几乎感受不大差异，这是因为 spring-boot-starter-data-redis 为我们隔离了其中的差异性。 Lettuce 是一个可伸缩线程安全的 Redis 客户端，多个线程可以共享同一个 RedisConnection，它利用优秀 netty NIO 框架来高效地管理多个连接。

SpringBoot整合使用Redis缓存详解、注解@Cacheable、@CacheEv。。。

SpringBoot整合使⽤Redis缓存详解、注解@Cacheable、@CacheEv。

Redis简介： REmote DIctionary Server(Redis) 是⼀个由Salvatore Sanfilippo写的key-value存储系统。

Redis是⼀个开源的使⽤ANSI C语⾔编写、遵守BSD协议、⽀持⽹络、可基于内存亦可持久化的⽇志型、Key-Value数据库，并提供多种语⾔的API。

它通常被称为数据结构服务器，因为值（value）可以是字符串(String), 哈希(Map), 列表(list), 集合(sets) 和有序集合(sorted sets)等类型。

Reids的优点：异常快：Redis⾮常快，每秒可执⾏⼤约110000次的设置(SET)操作，每秒⼤约可执⾏81000次的读取/获取(GET)操作。

⽀持丰富的数据类型：Redis⽀持开发⼈员常⽤的⼤多数数据类型，例如列表，集合，排序集和散列等等。

这使得Redis很容易被⽤来解决各种问题，因为我们知道哪些问题可以更好使⽤地哪些数据类型来处理解决。

操作具有原⼦性：所有Redis操作都是原⼦操作，这确保如果两个客户端并发访问，Redis服务器能接收更新的值。

多实⽤⼯具：Redis是⼀个多实⽤⼯具，可⽤于多种⽤例，如：缓存，消息队列(Redis本地⽀持发布/订阅)，应⽤程序中的任何短期数据，例如，web应⽤程序中的会话，⽹页命中计数等。

Redis 与其他 key - value 缓存产品有以下三个特点： Redis⽀持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进⾏使⽤。

Redis不仅仅⽀持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。

Redis⽀持数据的备份，即master-slave模式的数据备份。

1. Redis安装、RedisDesktopManager的使⽤ Redis安装和RedisDesktopManager的使⽤在前⾯已经介绍过了：2. Spring Boot中整合使⽤Redis 2.1 添加Redis依赖包<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><dependency><groupId>mons</groupId><artifactId>commons-pool2</artifactId></dependency> 2.2 Redis数据库连接信息配置spring:#Redis配置redis:host: 192.168.135.40#Redis服务器连接密码（默认为空）password:#Redis数据库索引（默认为0）database: 5port: 6379#连接超时时间（毫秒）timeout: 300#这⾥使⽤的是lettuce，如果使⽤Jedis，把下⾯的lettuce改成Jedis即可lettuce:pool:#连接池中的最⼤空闲连接max-idle: 8#连接池中的最⼩空闲连接min-idle: 0#连接池最⼤连接数（使⽤负值表⽰没有限制）max-active: 8#连接池最⼤阻塞等待时间（使⽤负值表⽰没有限制）max-wait: -1 2.3 新建RedisConfig类配置Redis @Configuration：⽤于定义配置类，可替换xml配置⽂件，被注解的类内部包含有⼀个或多个被@Bean注解的⽅法，这些⽅法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进⾏扫描，并⽤于构建bean定义，初始化Spring容器。

springboot使用shiro-整合redis作为缓存的操作

springboot使⽤shiro-整合redis作为缓存的操作说在前⾯本来的整合过程是顺着博客的顺序来的，越往下，集成的越多，由于之前是使⽤ehcache缓存，现在改为redis，限制登录⼈数以及限制登录次数等都需要改动，本篇为了简单，⽬前先将这两个功能下线，配置暂时是注销的，原类保存，在下篇博客中改。

还有之前是使⽤SessionListener监听session创建来统计在线⼈数，在本篇中也将改为统计redis中的key数⽬。

如果是单机，使⽤ehcache是最快的，项⽬⼀般都不是单节点，为了⽅便之后使⽤sso单点登录，以及多节点部署，所以使⽤shiro整合redis。

整合过程shiro⽤redis实现缓存需要重写cache、cacheManager、SessionDAO和初始化redis配置。

pom添加依赖<dependency><groupId>org.apache.shiro</groupId><artifactId>shiro-spring</artifactId><version>1.4.0</version></dependency><dependency><groupId>com.github.theborakompanioni</groupId><artifactId>thymeleaf-extras-shiro</artifactId><version>1.2.1</version></dependency><dependency><groupId>org.crazycake</groupId><artifactId>shiro-redis</artifactId><version>3.1.0</version></dependency>ShiroConfig.javapackage com.springboot.test.shiro.config;import at.pollux.thymeleaf.shiro.dialect.ShiroDialect;import com.springboot.test.shiro.config.shiro.*;import org.apache.shiro.codec.Base64;import org.apache.shiro.session.SessionListener;import org.apache.shiro.session.mgt.SessionManager;import org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator;import org.apache.shiro.session.mgt.eis.SessionDAO;import org.apache.shiro.session.mgt.eis.SessionIdGenerator;import org.apache.shiro.spring.LifecycleBeanPostProcessor;import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;import org.apache.shiro.spring.web.ShiroFilterFactoryBean;import org.apache.shiro.mgt.SecurityManager;import org.apache.shiro.web.filter.authc.FormAuthenticationFilter;import org.apache.shiro.web.mgt.CookieRememberMeManager;import org.apache.shiro.web.mgt.DefaultWebSecurityManager;import org.apache.shiro.web.servlet.SimpleCookie;import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;import org.crazycake.shiro.RedisCacheManager;import org.crazycake.shiro.RedisManager;import org.crazycake.shiro.RedisSessionDAO;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.beans.factory.config.MethodInvokingFactoryBean;import org.springframework.boot.context.embedded.ConfigurableEmbeddedServletContainer;import org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizer;import org.springframework.boot.web.servlet.ErrorPage;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.http.HttpStatus;import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;import javax.servlet.Filter;import java.util.ArrayList;import java.util.Collection;import java.util.LinkedHashMap;import java.util.Properties;/*** @author: wangsaichao* @date: 2018/5/10* @description: Shiro配置*/@Configurationpublic class ShiroConfig {/*** ShiroFilterFactoryBean 处理拦截资源⽂件问题。

springboot用redis缓存整合springcache注解，使用Json序列化和反序列化。

springboot⽤redis缓存整合springcache注解，使⽤Json序列化和反序列化。

springboot下⽤cache注解整合redis并使⽤json序列化反序列化。

cache注解整合redis最近发现spring的注解⽤起来真的是很⽅便。

随即产⽣了能不能吧spring注解使⽤redis实现的⽅式。

只需要在配置⽂件中（application.propertoes）添加如下⼀个配置spring.cache.type=redis并配置好redis的相关信息spring.redis.database=0spring.redis.host=spring.redis.port=spring.redis.password=spring.redis.timeout=5000msspring.redis.lettuce.pool.max-active=8spring.redis.lettuce.pool.max-wait=-1msspring.redis.lettuce.pool.max-idle=8spring.redis.lettuce.pool.min-idle=0springcache注解整合redis⾮常容易就整合完成了。

redis缓存序列化与反序列化由于缓存数据使⽤的是jdk⾃带的序列化需要序列化的实体类继承Serializable接⼝。

⽽且序列化后的内容在redis中看起来也不是很⽅便。

于是萌⽣了需要将数据序列化成json的想法。

经过⼀番研究后决定写⼀个redis 配置⽂件。

RedisConfig具体内容如下@Configurationpublic class RedisConfig extends CachingConfigurerSupport {@Beanpublic RedisCacheConfiguration redisCacheConfiguration(){Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig();configuration = configuration.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer)).entryTtl(Duration.ofDays(30));return configuration;}@Beanpublic CacheManager cacheManager(RedisConnectionFactory connectionFactory) {//初始化⼀个RedisCacheWriterRedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory);//设置CacheManager的值序列化⽅式为 fastJsonRedisSerializer,但其实RedisCacheConfiguration默认使⽤StringRedisSerializer序列化key，Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);RedisSerializationContext.SerializationPair<Object> pair = RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer);RedisCacheConfiguration defaultCacheConfig=RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);return new RedisCacheManager(redisCacheWriter, defaultCacheConfig);}}配置完成后，数据访问序列化都⾮常正常，redis中也可以看到有序的json数据。

spring配置redis注解缓存

spring配置redis注解缓存前⼏天在spring整合Redis的时候使⽤了⼿动的⽅式，也就是可以⼿动的向redis添加缓存与清除缓存，参考: 今天想的将spring注解整合Redis缓存弄明⽩，于是通过查阅资料，先做记录如下:⼤致步骤如下: 0.spring的主配置中声明注解缓存:<cache:annotation-driven cache-manager="redisCacheManager"/> 1.maven的pom.xml⽂件导⼊架包 2.配置⽂件添加配置 3.spring管理bean的⽣成,xml⽂件配置 4. RedisCacheConfig redis⾃定义的⼯具类，⾃定义redis的key⽣成规则 5.在你想要做缓存的地⽅，使⽤注解进⾏缓存0.spring的主配置中声明注解缓存:<cache:annotation-driven cache-manager="redisCacheManager"/> 注意:此步骤必须做，必须声明采⽤的缓存管理器是⾃⼰配置的redisCacheManager，否则会报错。

<cache:annotation-driven cache-manager="redisCacheManager"/>1.maven的pom.xml⽂件导⼊架包注意: 引⼊jackson是为了⼿动添加缓存<dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>2.9.0</version></dependency><dependency><groupId>org.springframework.data</groupId><artifactId>spring-data-redis</artifactId><version>1.8.4.RELEASE</version></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-core</artifactId><version>2.1.0</version></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.1.0</version></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-annotations</artifactId><version>2.1.0</version></dependency>2.配置⽂件添加配置redis.properties#访问地址redis.host=127.0.0.1#访问端⼝redis.port=6379#注意，如果没有password，此处不设置值，但这⼀项要保留redis.password=#最⼤空闲数，数据库连接的最⼤空闲时间。

springboot整合redis缓存

springboot整合redis缓存1.【准备】pom.xml⽂件加⼊redis依赖<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency>2.【载⼊】⾃动装配redis类模板@Autowiredprivate RedisTemplate redisTemplate;注：使⽤该模板直接在redis客户端查看内容key编码需转换，需要另外配置⼀般使⽤：StringRedisTemplate 模板，已经是使⽤String类型模板不需要额外配置3.【使⽤】设置key-value进缓存@Testvoid set(){ValueOperations ops = redisTemplate.opsForValue();ops.set("name","zhangsan",5,TimeUnit.SECONDS);}4.【使⽤】查看缓存内容@Testvoid get(){ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();System.out.println(ops.get("name"));}5.【补充】存⼊和查看Hash值进缓存// 存⼊hash值内容@Testvoid hset(){HashOperations ops = redisTemplate.opsForHash();ops.put("info","name","张三");}// 查看hash内容@Testvoid hget(){HashOperations ops = redisTemplate.opsForHash();System.out.println(ops.get("info","name"));}。

SpringBoot实现redis缓存菜单列表

SpringBoot实现redis缓存菜单列表因为系统的菜单列表是不轻易改变的，所以不需要在每次请求的时候都去查询数据库，所以，在第⼀次根据⽤户id请求到菜单列表的时候，可以把菜单列表的数据缓存在redis⾥，在第⼆次请求菜单列表的时候，可以直接在redis缓存⾥⾯获取数据，从⽽减少对数据库的操作，提升性能！⾸先，我们要下载redis到本地，然后在cmd终端打开redis的src⽬录，然后运⾏redis-server即可开启redis本地服务（mac）,开启了redis服务后，就要在项⽬中配置相关的redis的代码了，⾸先在pom.xml中导⼊我们需要的包：<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId><version>2.5.1</version></dependency><dependency><groupId>mons</groupId><artifactId>commons-pool2</artifactId><version>2.9.0</version></dependency>然后在config⽂件下创建ReidsConfig配置类⽂件：/*** redis配置类*/@Configurationpublic class RedisConfig {@Beanpublic RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){RedisTemplate<String,Object> redisTemplate=new RedisTemplate<>();//String类型key序列器redisTemplate.setKeySerializer(new StringRedisSerializer());//String类型value序列器redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());//Hash类型key序列器redisTemplate.setHashKeySerializer(new StringRedisSerializer());//Hash类型value序列器redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());redisTemplate.setConnectionFactory(redisConnectionFactory);return redisTemplate;}}这个配置⽂件主要是对String类型和hash类型的key和value做序列化操作；接下来就是使⽤redis了，在我们需要引⼊redis的根据⽤户id获取菜单列表接⼝的实现类中,判断下，如果菜单已经缓存在了redis中，则从redis中获取数据返回，否则去查询数据库获取数据：/*** <p>* 菜单表服务实现类* </p>** @author hhk* @since 2022-01-04*/@Servicepublic class MenuServiceImpl extends ServiceImpl<MenuMapper, Menu> implements IMenuService {@Autowiredprivate MenuMapper menuMapper;@Autowiredprivate RedisTemplate<String,Object> redisTemplate;/*** 根据⽤户id查询菜单列表* @return*/@Overridepublic List<Menu> getMenuByAdminId() {//getMenuByAdminId需要传⽤户id，这时候，要从security全局上下⽂中获取⽤户id,SecurityContextHolder.getContext().getAuthentication().getPrincipal()获取当前⽤户对象 Admin principal = (Admin) SecurityContextHolder.getContext().getAuthentication().getPrincipal();//获取到⽤户idInteger id = principal.getId();ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();List<Menu> menus=((List<Menu>) valueOperations.get("menu_" + id));//获取redis缓存中的菜单列表if(CollectionUtils.isEmpty(menus)){//如果是空，则从数据库中获取menus= menuMapper.getMenuByAdminId(id);//将数据设置到redis中valueOperations.set("menu_"+id,menus);}return menus;}}到这⾥，重启项⽬即可测试接⼊缓存是否成功了到此这篇关于SpringBoot实现redis缓存菜单列表的⽂章就介绍到这了,更多相关SpringBoot redis缓存菜单列表内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

springboot缓存的使用实践

springboot缓存的使⽤实践spring针对各种缓存实现，抽象出了CacheManager接⼝，⽤户使⽤该接⼝处理缓存，⽽⽆需关⼼底层实现。

并且也可以⽅便的更改缓存的具体实现，⽽不⽤修改业务代码。

下⾯对于在springboot中使⽤缓存做⼀简单介绍：1、添加依赖<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId></dependency>2、在配置类⾥开启缓存,如下图所⽰:3、在需要使⽤缓存的⽅法上加上注解，如下：@Override//@CachePut 该注解会将⽅法的返回值缓存起来,其中缓存名字是 people,数据的key是person的id@CachePut(value = "people", key = "#person.id")public Person save(Person person) {Person p = personRepository.save(person);System.out.println("为id、key为:"+p.getId()+"数据做了缓存");return p;}@Override//@CacheEvict 该注解会删除people缓存中key为id 的数据@CacheEvict(value = "people", key = "#id")public void remove(Long id) {System.out.println("删除了id、key为"+id+"的数据缓存");//这⾥不做实际删除操作}@Override//@Cacheable 该注解会在⽅法执⾏时，判断缓存people中key为#person.id的缓存是否存在,如果存在，则直接返回缓存中的数据。

SpringBoot整合Redis案例缓存首页数据、缓解数据库压力

SpringBoot整合Redis案例缓存⾸页数据、缓解数据库压⼒⼀、硬编码⽅式1、场景由于⾸页数据变化不是很频繁，⽽且⾸页访问量相对较⼤，所以我们有必要把⾸页数据缓存到redis中，减少数据库压⼒和提⾼访问速度。

2、RedisTemplateJedis是Redis官⽅推荐的⾯向Java的操作Redis的客户端，⽽RedisTemplate是Spring Data Redis中对Jedis api的⾼度封装。

Spring Data Redis是spring⼤家族的⼀部分，提供了在srping应⽤中通过简单的配置访问redis服务，对reids底层开发包(Jedis, JRedis, and RJC)进⾏了⾼度封装，RedisTemplate提供了redis各种操作、异常处理及序列化功能，⽀持发布订阅，并对spring cache进⾏了实现。

3、引⼊redis<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><dependency><groupId>mons</groupId><artifactId>commons-pool2</artifactId></dependency>4、添加redis连接配置spring:redis:host: ipport: 端⼝号（默认6379）database: 1password: #默认为空lettuce:pool:max-active: 20 #最⼤连接数，负值表⽰没有限制，默认8max-wait: -1 #最⼤阻塞等待时间，负值表⽰没限制，默认-1max-idle: 8 #最⼤空闲连接，默认8min-idle: 0 #最⼩空闲连接，默认05、配置Redis/*** 我们⾃定义⼀个 RedisTemplate，设置序列化器，这样我们可以很⽅便的操作实例对象。

SpringBoot中使用Redis缓存注解

SpringBoot中使⽤Redis缓存注解相关注解@EnableCaching //在启动类上加上注解启动缓存//作⽤在你要缓存的数据上@Cacheable(key="#id",cacheNames="com.coydone.service.impl.MenuServiceImpl")@Cacheput //解决脏读@CachEvict//（解决脏读）@Cacheconfig//（全局的配置缓存）相关概念脏读脏读就是指当⼀个事务正在访问数据，并且对数据进⾏了修改，⽽这种修改还没有提交到数据库中，这时，另外⼀个事务也访问这个数据，然后使⽤了这个数据。

例如：张三的⼯资为5000,事务A中把他的⼯资改为8000,但事务A尚未提交。

与此同时，事务B正在读取张三的⼯资，读取到张三的⼯资为8000。

随后，事务A发⽣异常，⽽回滚了事务。

张三的⼯资⼜回滚为5000。

最后，事务B读取到的张三⼯资为8000的数据即为脏数据，事务B做了⼀次脏读。

不可重复读是指在⼀个事务内，多次读同⼀数据。

在这个事务还没有结束时，另外⼀个事务也访问该同⼀数据。

那么，在第⼀个事务中的两次读数据之间，由于第⼆个事务的修改，那么第⼀个事务两次读到的的数据可能是不⼀样的。

这样就发⽣了在⼀个事务内两次读到的数据是不⼀样的，因此称为是不可重复读。

例如：在事务A中，读取到张三的⼯资为5000，操作没有完成，事务还没提交。

与此同时，事务B把张三的⼯资改为8000，并提交了事务。

随后，在事务A中，再次读取张三的⼯资，此时⼯资变为8000。

在⼀个事务中前后两次读取的结果并不致，导致了不可重复读。

幻读是指当事务不是独⽴执⾏时发⽣的⼀种现象，例如第⼀个事务对⼀个表中的数据进⾏了修改，这种修改涉及到表中的全部数据⾏。

同时，第⼆个事务也修改这个表中的数据，这种修改是向表中插⼊⼀⾏新数据。

那么，以后就会发⽣操作第⼀个事务的⽤户发现表中还有没有修改的数据⾏，就好象发⽣了幻觉⼀样。

SpringBoot基于注解的Redis缓存实现

SpringBoot基于注解的Redis缓存实现⼀、添加Spring Data Redis依赖启动器<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency>⼆、Redis服务连接配置#MySQL数据库连接配置spring.datasource.url=jdbc:mysql://192.168.152.120:3306/springboottest?serverTimezone=UTC ername=rootspring.datasource.password=1#显⽰使⽤JPA进⾏数据库查询的SQL语句spring.jpa.show-sql=true#redis相关配置spring.redis.host=192.168.152.120spring.redis.port=6379spring.redis.password=1三、实体类四、repositorypackage com.uos.cache.repository;import ment;import org.springframework.data.jpa.repository.JpaRepository;import org.springframework.data.jpa.repository.Modifying;import org.springframework.data.jpa.repository.Query;import javax.transaction.Transactional;public interface CommentRepository extends JpaRepository<Comment,Integer> { // 根据评论id修改评论作者@Transactional@Modifying@Query("UPDATE t_comment c SET c.author= ?1 WHERE c.id = ?2")public int updateComment(String author,Integer id);}CommentRepository五、servicepackage com.uos.cache.service;import ment;import mentRepository;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.cache.annotation.*;import org.springframework.stereotype.Service;import java.util.Optional;@Servicepublic class CommentService {@Autowiredprivate CommentRepository commentRepository;@Cacheable(cacheNames = "comment",unless = "#result==null")public Comment findById(int comment_id){Optional<Comment> optional = commentRepository.findById(comment_id);if(optional.isPresent()){return optional.get();}return null;}@CachePut(cacheNames = "comment",key = "#result.id")public Comment updateComment(Comment comment){commentRepository.updateComment(comment.getAuthor(), comment.getaId());return comment;}@CacheEvict(cacheNames = "comment")public void deleteComment(int comment_id){commentRepository.deleteById(comment_id);}}CommentService六、controllerpackage com.uos.cache.controller;import ment;import mentService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class CommentController {@Autowiredprivate CommentService commentService;@GetMapping("/get/{id}")public Comment findById(@PathVariable("id") int comment_id){Comment comment = commentService.findById(comment_id);return comment;}@GetMapping("/update/{id}/{author}")public Comment updateComment(@PathVariable("id") int comment_id,@PathVariable("author") String author){Comment comment = commentService.findById(comment_id);comment.setAuthor(author);Comment updateComment = commentService.updateComment(comment);return updateComment;}@GetMapping("/delete/{id}")public void deleteComment(@PathVariable("id") int comment_id){commentService.deleteComment(comment_id);}}CommentController七、主程序类⼋、测试结果查询测试更新测试删除测试。

SpringBoot自带缓存及结合Redis使用

SpringBoot⾃带缓存及结合Redis使⽤本⽂测试环境: Spring Boot 2.1.4.RELEASE + Redis 5.0.4 + CentOS 7⾃带缓存如果没有使⽤缓存中间件，Spring Boot 会使⽤默认的缓存，我们只需启⽤即可在启动类添加 @EnableCaching 注解@SpringBootApplication@EnableCachingpublic class CacheredisApplication {public static void main(String[] args) {SpringApplication.run(CacheredisApplication.class, args);}}缓存配置@Cacheable: 先判断有没有缓存，有缓存取缓存，否则执⾏后续操作后结果存⼊缓存@CachePut: 操作后结果存⼊缓存@CacheEvict: 清除缓存具体使⽤见下⾯⽰例：@Service//@CacheConfig(cacheNames = "user") // 如果使⽤该注解, ⽅法中则可以省略 cacheNames 配置public class UserServiceImpl implements UserService {@AutowiredUserDao userDao;@Override// 缓存的最终 key 值为 user::id@Cacheable(cacheNames = "user", key = "#id")public User get(int id) {return userDao.get(id);}@Override// condition: 执⾏⽅法前判断是否使⽤注解的功能; unless: 执⾏⽅法后，判断是否使⽤注解提供的功能@CachePut(cacheNames = "user", key = "#user.id", condition = "#user.id<10", unless = "#result.status = 1")public User update(User user) {return userDao.update(user);}@Override// 默认规则: 只有⼀个参数则 key 值取该参数, 如果有多个参数则将这些参数拼接起来作为 key@CacheEvict(cacheNames = "user")public boolean delete(int id) {return userDao.delete(id);}@Override// allEntries 清除 cacheNames 下所有 key; beforeInvocation ⽅法执⾏前清除@CacheEvict(cacheNames = "user", allEntries = true, beforeInvocation = true)public boolean deleteAll() {return userDao.deleteAll();}}结合 Redis 使⽤关于 Redis 基本使⽤，参考昨天的随笔添加配置spring:cache:type: redis # 设置使⽤ redis 作为缓存 (此⾏可以不配置)redis:time-to-live: 300s# key-prefix: key # 不要配置该项# use-key-prefix: true # 不要配置该项redis:host: 192.168.30.101port: 6379database: 0# password: ******缓存类添加代码@Servicepublic class UserServiceImpl implements UserService {@AutowiredStringRedisTemplate redisTemplate;... ...}注意事项要缓存的类要实现 Serializable 接⼝存在问题 (坑)在配置⽂件配置 key-prefix 和 use-key-prefix 项⽣成的 key 会有问题:key-prefix不配置key-key-use-key-prefix不配置true falseRedis缓存内的key user::1key-11如上所⽰，如果配置了 key-prefix 和 use-key-prefix 设置的 cacheNames 会被覆盖掉，两个或以上类的对象缓存会有问题未解决问题结合 Redis 使⽤时即使使⽤⾃定义 RedisTemplate 改变了 Serializer, 但在实际序列化时仍然使⽤的是默认的JdkSerializationRedisSerializer，不知道为什么会这样 (这应该也是需要缓存的类为什么必须实现 Serializable 接⼝)，还恳请⼤神指教！源码：本⼈ C# 转 Java 的 newbie, 如果错误或不⾜欢迎指正，谢谢参考：。

SpringBoot项目中使用redis缓存的方法步骤

SpringBoot项⽬中使⽤redis缓存的⽅法步骤本⽂介绍了SpringBoot项⽬中使⽤redis缓存的⽅法步骤，分享给⼤家，具体如下：Spring Data Redis为我们封装了Redis客户端的各种操作，简化使⽤。

- 当Redis当做数据库或者消息队列来操作时，我们⼀般使⽤RedisTemplate来操作- 当Redis作为缓存使⽤时，我们可以将它作为Spring Cache的实现，直接通过注解使⽤1.概述在应⽤中有效的利⽤redis缓存可以很好的提升系统性能，特别是对于查询操作，可以有效的减少数据库压⼒。

具体的代码参照该2.添加引⽤在build.gradle加⼊compile('org.springframework.boot:spring-boot-starter-data-redis')SpringBoot会⾃动引⼊redis相关的jar包。

加⼊该引⽤后，需要在本地安装redis并启动，否则程序启动时会报错。

3.通过注解启⽤缓存在SpringBoot中启⽤redis⾮常简单，只需要在Application主类上添加@EnableCaching注解，之后在需要启⽤缓存的查询⽅法上添加@Cacheable注解。

@SpringBootApplication@EnableCachingpublic class DemoApplication implements CommandLineRunner{...查询接⼝：public interface TestRepository extends JpaRepository<Test, Integer> {@Cacheable(value = "testCache")public Test findOne(Integer id);}实体类需要实现Serializable接⼝，否则程序会报错，因为⽆法把java对象序列化到redis中。

SpringBoot基于注解的Redis缓存使用

SpringBoot基于注解的Redis缓存使用Spring Boot基于注解的Redis缓存使用Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。

本文主要介绍了Spring Boot 基于注解的Redis 缓存使用详解，下面店铺带大家一起来看看详细内容，希望对大家有所帮助!想了解更多相关信息请持续关注我们店铺!看文本之前，请先确定你看过上一篇文章《Spring Boot Redis 集成配置》并保证Redis 集成后正常可用，因为本文是基于上文继续增加的代码。

一、创建 Caching 配置类RedisKeys.Javapackage com.shanhy.example.redis;import java.util.HashMap;import java.util.Map;import javax.annotation.PostConstruct;import ponent;/*** 方法缓存key常量** @author SHANHY*/@Componentpublic class RedisKeys {// 测试 beginpublic static final String _CACHE_TEST = "_cache_test";// 缓存keypublic static final Long _CACHE_TEST_SECOND = 20L;// 缓存时间// 测试 end// 根据key设定具体的缓存时间private Map<String, Long> expiresMap = null;@PostConstructpublic void init(){expiresMap = new HashMap<>();expiresMap.put(_CACHE_TEST, _CACHE_TEST_SECOND);}public Map<String, Long> getExpiresMap(){return this.expiresMap;}}CachingConfig.javapackage com.shanhy.example.redis;import ng.reflect.Method;import java.util.ArrayList;import java.util.List;import org.springframework.cache.CacheManager;importorg.springframework.cache.annotation.CachingConfigurerSupp ort;importorg.springframework.cache.annotation.EnableCaching;importorg.springframework.cache.interceptor.KeyGenerator;importorg.springframework.cache.interceptor.SimpleKeyGenerator;import org.springframework.context.annotation.Bean;importorg.springframework.context.annotation.Configuration;importorg.springframework.data.redis.cache.RedisCacheManager;import org.springframework.data.redis.core.RedisTemplate;/*** 注解式环境管理** @author 单红宇(CSDN catoop)* @create 2016年9月12日*/@Configuration@EnableCachingpublic class CachingConfig extends CachingConfigurerSupport {/*** 在使用@Cacheable时，如果不指定key，则使用找个默认的key生成器生成的key** @return** @author 单红宇(CSDN CATOOP)* @create 2017年3月11日*/@Overridepublic KeyGenerator keyGenerator() {return new SimpleKeyGenerator() {/*** 对参数进行拼接后MD5*/@Overridepublic Object generate(Object target, Method method,Object... params) {StringBuilder sb = new StringBuilder();sb.append(target.getClass().getName());sb.append(".").append(method.getName());StringBuilder paramsSb = new StringBuilder();for (Object param : params) {// 如果不指定，默认生成包含到键值中if (param != null) {paramsSb.append(param.toString());}}if (paramsSb.length() > 0) {sb.append("_").append(paramsSb);}return sb.toString();}};}/*** 管理缓存** @param redisTemplate* @return*/@Beanpublic CacheManager cacheManager(RedisTemplate<String, Object> redisTemplate, RedisKeys redisKeys) {RedisCacheManager rcm = new RedisCacheManager(redisTemplate);// 设置缓存默认过期时间（全局的）rcm.setDefaultExpiration(1800);// 30分钟// 根据key设定具体的缓存时间，key统一放在常量类RedisKeys 中rcm.setExpires(redisKeys.getExpiresMap());List<String> cacheNames = new ArrayList<String>(redisKeys.getExpiresMap().keySet());rcm.setCacheNames(cacheNames);return rcm;}}二、创建需要缓存数据的类TestService.javapackage com.shanhy.example.service;import ng3.RandomStringUtils;import org.springframework.cache.annotation.Cacheable;import org.springframework.stereotype.Service;import com.shanhy.example.redis.RedisKeys;@Servicepublic class TestService {/*** 固定key** @return* @author SHANHY* @create 2017年4月9日*/@Cacheable(value = RedisKeys._CACHE_TEST, key = "'" + RedisKeys._CACHE_TEST + "'")public String testCache() {return RandomStringUtils.randomNumeric(4);}/*** 存储在Redis中的key自动生成，生成规则详见CachingConfig.keyGenerator()方法** @param str1* @param str2* @return* @author SHANHY* @create 2017年4月9日*/@Cacheable(value = RedisKeys._CACHE_TEST)public String testCache2(String str1, String str2) {return RandomStringUtils.randomNumeric(4);}}说明一下，其中 @Cacheable 中的 value 值是在 CachingConfig 的cacheManager 中配置的，那里是为了配置我们的缓存有效时间。

SpringBoot与Redis缓存集成实践

SpringBoot与Redis缓存集成实践一、引言随着现代应用程序的复杂性不断增加，缓存成为提高系统性能和响应速度的重要手段之一。

而SpringBoot与Redis的集成可以帮助我们更加高效地实现缓存功能。

本文将介绍SpringBoot与Redis缓存集成的实践，从配置Redis、使用RedisTemplate进行缓存操作以及解决缓存穿透与缓存雪崩等问题进行探讨。

二、配置Redis1. 引入依赖在pom.xml文件中添加SpringDataRedis的依赖：```xml<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency>```2. 配置Redis连接参数在application.properties或application.yml文件中配置Redis连接参数：```spring.redis.host=127.0.0.1spring.redis.port=6379spring.redis.database=0spring.redis.password=```其中，host为Redis服务器的IP地址，port为端口号，database为数据库索引，password为连接密码（如果有设置）。

3. 配置RedisTemplate在SpringBoot的配置类中，通过@Bean注解创建一个RedisTemplate的实例，并设置相关参数，例如连接工厂、序列化器等：```java@Configurationpublic class RedisConfig {@Beanpublic RedisTemplate<String, Object>redisTemplate(RedisConnectionFactory redisConnectionFactory) {RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();redisTemplate.setConnectionFactory(redisConnectionFactory);redisTemplate.setKeySerializer(new StringRedisSerializer());redisTemplate.setValueSerializer(newGenericJackson2JsonRedisSerializer());return redisTemplate;}}```在上述代码中，我们使用了StringRedisSerializer对key进行序列化，使用了GenericJackson2JsonRedisSerializer对value进行序列化。

springboot（12）Redis作为SpringBoot项目数据缓存

springboot（12）Redis作为SpringBoot项⽬数据缓存简介：在项⽬中设计数据访问的时候往往都是采⽤直接访问数据库，采⽤数据库连接池来实现，但是如果我们的项⽬访问量过⼤或者访问过于频繁，将会对我们的数据库带来很⼤的压⼒。

为了解决这个问题从⽽redis数据库脱颖⽽出，redis数据库出现时是以⾮关系数据库的光环展⽰在⼴⼤程序猿的⾯前的，后来redis的迭代版本⽀持了缓存数据、登录session状态（分布式session共享）等。

所以⼜被作为内存缓存的形式应⽤到⼤型企业级项⽬中。

本⽂⽬标实现SpringBoot项⽬中整合⾮关系数据库Redis作为内存缓存框架，并测试数据读取源。

Redis的安装：官⽹的仅⽀持Linux服务器的安装版本，由于开发⼈员都是在windows上⼯作，所以GitHub上的⽜⼈基于linux平台下的Redis实现了windows版本。

下载Windows版本Redis：我们直接访问github⽹址：，下载最新的windows X64版本的压缩包。

开启Redis：解压完成后我们来开启Redis数据库，Redis数据库的默认端⼝是6379，如果已经被其他应⽤程序占⽤，请⾃⾏修改redis.windows.conf 配置⽂件。

⼀、创建项⽬：项⽬依赖pom.xml，我们添加缓存的⽀持需要两个依赖，⼀个是SpringBoot内部的缓存配置、另外则是我们的redis缓存。

<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.yuqiyu</groupId><artifactId>chapter16</artifactId><version>0.0.1-SNAPSHOT</version><packaging>war</packaging><name>chapter16</name><description>Demo project for Spring Boot</description><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>1.5.2.RELEASE</version><relativePath/></parent><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.0.29</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-tomcat</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-redis</artifactId><version>1.4.3.RELEASE</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>View Code 数据库对应的实体类：@Entity@Table(name = "t_user")public class UserEntity implements Serializable {@Id@GeneratedValue@Column(name = "t_id")private Long id;@Column(name = "t_name")private String name;@Column(name = "t_age")private int age;@Column(name = "t_address")private String address;public Long getId() {return id;}public void setId(Long id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}this.age = age;}public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}}View Code 简单JPA接⼝public interface UserJPA extends JpaRepository<UserEntity,Long>{}⼆、配置⽂件application.yml，数据库连接池、jpa、本地的redis数据库连接到项⽬中spring:datasource:type: com.alibaba.druid.pool.DruidDataSourcedriver-class-name: com.mysql.jdbc.Driverurl: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8username: rootpassword: root#最⼤活跃数maxActive: 20#初始化数量initialSize: 1#最⼤连接等待超时时间maxWait: 60000#打开PSCache，并且指定每个连接PSCache的⼤⼩poolPreparedStatements: truemaxPoolPreparedStatementPerConnectionSize: 20#通过connectionProperties属性来打开mergeSql功能；慢SQL记录#connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000minIdle: 1timeBetweenEvictionRunsMillis: 60000minEvictableIdleTimeMillis: 300000validationQuery: select 1 from dualtestWhileIdle: truetestOnBorrow: falsetestOnReturn: false#配置监控统计拦截的filters，去掉后监控界⾯sql将⽆法统计,'wall'⽤于防⽕墙filters: stat, wall, log4jjpa:properties:hibernate:show_sql: trueformat_sql: true#配置redis数据库连接redis:host: 127.0.0.1port: 6379pool:max-idle: 20min-idle: 1max-active: 20max-wait: 60000database: 0 #默认是索引为的0的数据库三、创建⼀个业务逻辑服务类：UserService，我们在Service内添加redis的缓存⽀持 @CacheConfig：该注解是⽤来开启声明的类参与缓存,如果⽅法内的@Cacheable注解没有添加key值，那么会⾃动使⽤cahceNames 配置参数并且追加⽅法名。

Springboot整合redis使用技巧

Springboot整合redis使用技巧Spring CacheSpring 3.1 引入基于注解Cache支持，且提供了Cache抽象。

Spring 的缓存技术还具备相当的灵活性，不仅能够使用SpEL（Spring Expression Language）来定义缓存的key 和各种condition，还提供开箱即用的缓存临时存储方案，也支持和主流的专业缓存例如EHCache、Redis 集成。

是由底层Cache自行维护。

在Springboot中提供了基于spring cache的自动化配置，默认提供了Ehcache、Guava、Redis等的配置实现。

我们在应用开发中使用的是Redis缓存，并且出现了一些复杂的应用场景，需要对于不同缓存制定不同的策略。

查看了Springboot实现Redis自动化配置的源码。

发现在RedisCacheManager 类中有这两个属性defaultExpiration和expires。

这时候就可以通过在Spring注册一个RedisCacheManager实现缓存策略（源码）。

配置多个Cache Manager实例与使用如果想要实现多个Cache Manager实例也是可以的，比如还想要一个内存缓存GuavaCache，需要使用@Primary注解指定一个Cache Manager作为默认缓存。

（在创建bean的时候最好指定缓存管理实例的bean名称），使用的时候不指定缓存管理实例名称就使用默认缓存，指定缓存管理实例就是使用指定的缓存管理实例。

例如：@Cacheable(value = "cache ",key = "key")//使用redisCacheManager，由@Primary指定@Cacheable(cacheNames = "guavaCacheManager",value = "guavaCache ",key = "key")//使用guavaCacheManagerRedis缓存使用技巧在redisCacheManager配置中有一个比较有意思的配置属性：usePrefix；这个表示缓存数据时，缓存的键是否使用前缀。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

使用具体的代码介绍了@Cacheable，@CacheEvict，@CachePut，@CacheConfig等注解及其属性的用法。

下面简单介绍spring boot如何初始化redis缓存。

2.3. spring boot 如何初始化redis做缓存缓存管理接口org.springframework.cache.CacheManager，spring boot就是通过此类实现缓存的管理。

redis对应此接口的实现类是org.springframework.data.redis.cache.RedisCacheManager。

下面介绍此类如何生成。

首先我们配置application.properties的spring.redis.* 属性后@EnableCaching后，spring会执行RedisAutoConfiguration，初始化RedisTemplate和StringRedisTemplate@Configuration@ConditionalOnClass({ JedisConnection.class, RedisOperations.class, Jedis.class })@EnableConfigurationProperties(RedisProperties.class)public class RedisAutoConfiguration {/*** Standard Redis configuration.*/@Configurationprotected static class RedisConfiguration {….@Bean@ConditionalOnMissingBean(name = "redisTemplate")public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory)throws UnknownHostException {RedisTemplate template = new RedisTemplate();template.setConnectionFactory(redisConnectionFactory);return template;}@Bean@ConditionalOnMissingBean(StringRedisTemplate.class) public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)throws UnknownHostException {StringRedisTemplate template = new StringRedisTemplate();template.setConnectionFactory(redisConnectionFactory);return template;}}} 1234567891011121314151617181920212223242526272829303 1323334123456789101112131415161718192021222324252627 28293031323334然后RedisCacheConfiguration会将RedisAutoConfiguration生成的RedisTemplate注入方法生成RedisCacheManager 后。

@Configuration@AutoConfigureAfter(RedisAutoConfiguration.class)@ConditionalOnBean(RedisTemplate.class)@ConditionalOnMissingBean(CacheManager.class)@Conditional(CacheCondition.class)class RedisCacheConfiguration {private final CacheProperties cacheProperties;private final CacheManagerCustomizers customizerInvoker;RedisCacheConfiguration(CacheProperties cacheProperties,CacheManagerCustomizers customizerInvoker) {this.cacheProperties = cacheProperties;this.customizerInvoker = customizerInvoker;}@Beanpublic RedisCacheManager cacheManager(RedisTemplate redisTemplate) {RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);cacheManager.setUsePrefix(true);List cacheNames =this.cacheProperties.getCacheNames();if (!cacheNames.isEmpty()) {cacheManager.setCacheNames(cacheNames);}returnthis.customizerInvoker.customize(cacheManager);}} 1234567891011121314151617181920212223242526272829301 23456789101112131415161718192021222324252627282930 根据以上的分析，我们知道在spring已经帮我们生成一个RedisCacheManager并进行了配置。

最后我们再可以对这个RedisCacheManager进行二次配置，这里只列出配置key的有效期/*** 重新配置RedisCacheManager* @param rd*/@Autowiredpublic void configRedisCacheManger(RedisCacheManager rd){rd.setDefaultExpiration(100L);}123456789123456789注意：请不要在applicaion.properties中配置：spring.cache.cache-names=book1,book2，否则会导致我们新的配置无法作用到这些配置的cache上。

这是因为RedisCacheConfiguration 初始化RedisCacheManager后，会立即调用RedisCacheConfiguration 的初始化cache，而此时configRedisCacheManger还没有执行此方法，使得我们的配置无法启作用。

反之，如果不配置，则后创建cache，会使用我们的配置。

3. spring缓存注解的用法上节已经介绍如何配置缓存，这节介绍如何使用缓存。

3.1 辅助类下方会使用到的辅助类Book:public class Book implements Serializable {private static final long serialVersionUID = 2629983876059197650L;private String id;private String name; // 书名private Integer price; // 价格private Date update; //public Book(String id, String name, Integer price, Date update) {super();this.id = id; = name;this.price = price;this.update = update;}// set/get略}1234567891011121314151617181234567891011121314151617 18BookQry : 封装请求类public class BookQry {private String id;private String name; // 书名// set/get略}12345671234567AbstractService抽象类：初始化repositoryBook 值，模拟数据库数据。