springboot redis缓存配置
发表于：2024-10-04 作者：千家信息网编辑
千家信息网最后更新 2024年10月04日，今天小编就为大家带来一篇springboot redis缓存配置的文章。小编觉得挺实用的，为此分享给大家做个参考。一起跟随小编过来看看吧。开启远程访问：找到redis中的redis.conf文件并编辑
千家信息网最后更新 2024年10月04日springboot redis缓存配置
今天小编就为大家带来一篇springboot redis缓存配置的文章。小编觉得挺实用的，为此分享给大家做个参考。一起跟随小编过来看看吧。
开启远程访问：
找到redis中的redis.conf文件并编辑（在安装路径中找到）
vim ./redis.conf
1、找到bind 127.0.0.1并注释掉
默认127.0.0.1只能本地访问，注释掉即可ip访问
2、修改 protected-mode 属性值为no
注释掉并把保护模式禁用以后可以IP访问
3、修改daemonize属性将no 改为yes
将daemonize设置为yes即启动后台运行
4、开放6379端口
/sbin/iptables -I INPUT -p tcp --dport 6379 -j ACCEPT
默认不对外开放6379
5、启动redis
redis-server /myconf/redis.conf
redis-server默认在/usr/local/bin路径下，redis.conf在redis的安装路径下
6、测试连接
redis-cli -h 192.168.126.129 -p 6379
redis-cli -h redis服务器IP -p 6379 -a 密码（没有设置redis密码不要写空，否则报错）
java代码编写：
项目源码结构
一个user表
代码：
pom.xml文件（可以根据自己的需要来添加或修改）
org.springframework.boot spring-boot-starter-web org.mybatis.spring.boot mybatis-spring-boot-starter 1.3.2 mysql mysql-connector-java 5.1.39 org.springframework.boot spring-boot-starter-test test org.springframework.boot spring-boot-starter-data-redis org.springframework.boot spring-boot-starter-cache
下面是springboot的配置文件application.yml，配置redis（里面都有注释解释）
server: port: 8081 #数据库连接spring: datasource: url: jdbc:mysql://localhost:3306/mytest_springboot_cache?useUnicode=true driver-class-name: com.mysql.jdbc.Driver username: root password: lzh ## Redis 配置 redis: ## Redis数据库索引（默认为0） database: 0 ## Redis服务器地址 host: 192.168.126.129 ## Redis服务器连接端口 port: 6379 ## Redis服务器连接密码（默认为空） password: jedis: pool: ## 连接池最大连接数（使用负值表示没有限制） #spring.redis.pool.max-active=8 max-active: 8 ## 连接池最大阻塞等待时间（使用负值表示没有限制） #spring.redis.pool.max-wait=-1 max-wait: -1 ## 连接池中的最大空闲连接 #spring.redis.pool.max-idle=8 max-idle: 8 ## 连接池中的最小空闲连接 #spring.redis.pool.min-idle=0 min-idle: 0 ## 连接超时时间（毫秒） timeout: 1200 #将themilef的默认缓存禁用，热加载生效 thymeleaf: cache: false #mybatis的下划线转驼峰配置 configuration: map-underscore-to-camel-case: true #另外一种打印语句的方式 log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #打印sql时的语句logging: level: com: acong: dao: debug file: d:/logs/bsbdj.log
接着是实体类，这个比较简单就不多说了
package com.lzh.springbootstudytest.bean; import java.io.Serializable; /** * @author lzh * create 2019-09-18-22:32 */public class User implements Serializable { private static final long serialVersionUID = 1L; private int uid; private String userName; private String passWord; private int salary; public int getUid() { return uid; } public void setUid(int uid) { this.uid = uid; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public String getPassWord() { return passWord; } public void setPassWord(String passWord) { this.passWord = passWord; } public int getSalary() { return salary; } public void setSalary(int salary) { this.salary = salary; } public User(int uid, String userName, String passWord, int salary) { super(); this.uid = uid; this.userName = userName; this.passWord = passWord; this.salary = salary; } public User() { super(); }} 这是controller类，用于暴露接口访问
package com.lzh.springbootstudytest.controller; import com.lzh.springbootstudytest.bean.User;import com.lzh.springbootstudytest.service.UserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.ResponseBody;import org.springframework.web.bind.annotation.RestController; import java.util.HashMap;import java.util.List;import java.util.Map; /** * @author lzh * create 2019-09-18-22:36 */@RestControllerpublic class TestController { @Autowired private UserService userService; @RequestMapping("/queryAll") public List queryAll(){ List lists = userService.queryAll(); return lists; } @RequestMapping("/findUserById") public Map findUserById(@RequestParam int id){ User user = userService.findUserById(id); Map result = new HashMap<>(); result.put("uid", user.getUid()); result.put("uname", user.getUserName()); result.put("pass", user.getPassWord()); result.put("salary", user.getSalary()); return result; } @RequestMapping("/updateUser") public String updateUser(){ User user = new User(); user.setUid(1); user.setUserName("cat"); user.setPassWord("miaomiao"); user.setSalary(4000); int result = userService.updateUser(user); if(result != 0){ return "update user success"; } return "fail"; } @RequestMapping("/deleteUserById") public String deleteUserById(@RequestParam int id){ int result = userService.deleteUserById(id); if(result != 0){ return "delete success"; } return "delete fail"; }} 配置redistemplate序列化
package com.lzh.springbootstudytest.config; import com.fasterxml.jackson.annotation.JsonAutoDetect;import com.fasterxml.jackson.annotation.PropertyAccessor;import com.fasterxml.jackson.databind.ObjectMapper;import org.springframework.cache.CacheManager;import org.springframework.cache.annotation.CachingConfigurerSupport;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.cache.RedisCacheWriter;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.StringRedisSerializer; import java.time.Duration; /** * @author lzh * create 2019-09-24-15:07 */@Configuration@EnableCachingpublic class RedisConfig extends CachingConfigurerSupport { /** * 选择redis作为默认缓存工具 * @param redisConnectionFactory * @return */ /*@Bean //springboot 1.xx public CacheManager cacheManager(RedisTemplate redisTemplate) { RedisCacheManager rcm = new RedisCacheManager(redisTemplate); return rcm; }*/ @Bean public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) { RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig() .entryTtl(Duration.ofHours(1)); // 设置缓存有效期一小时 return RedisCacheManager .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory)) .cacheDefaults(redisCacheConfiguration).build(); } /** * retemplate相关配置 * @param factory * @return */ @Bean public RedisTemplate redisTemplate(RedisConnectionFactory factory) { RedisTemplate template = new RedisTemplate<>(); // 配置连接工厂 template.setConnectionFactory(factory); //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式） Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class); ObjectMapper om = new ObjectMapper(); // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常 om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); jacksonSeial.setObjectMapper(om); // 值采用json序列化 template.setValueSerializer(jacksonSeial); //使用StringRedisSerializer来序列化和反序列化redis的key值 template.setKeySerializer(new StringRedisSerializer()); // 设置hash key 和value序列化模式 template.setHashKeySerializer(new StringRedisSerializer()); template.setHashValueSerializer(jacksonSeial); template.afterPropertiesSet(); return template; } /** * 对hash类型的数据操作 * * @param redisTemplate * @return */ @Bean public HashOperations hashOperations(RedisTemplate redisTemplate) { return redisTemplate.opsForHash(); } /** * 对redis字符串类型数据操作 * * @param redisTemplate * @return */ @Bean public ValueOperations valueOperations(RedisTemplate redisTemplate) { return redisTemplate.opsForValue(); } /** * 对链表类型的数据操作 * * @param redisTemplate * @return */ @Bean public ListOperations listOperations(RedisTemplate redisTemplate) { return redisTemplate.opsForList(); } /** * 对无序集合类型的数据操作 * * @param redisTemplate * @return */ @Bean public SetOperations setOperations(RedisTemplate redisTemplate) { return redisTemplate.opsForSet(); } /** * 对有序集合类型的数据操作 * * @param redisTemplate * @return */ @Bean public ZSetOperations zSetOperations(RedisTemplate redisTemplate) { return redisTemplate.opsForZSet(); }} 接着是Mapper持久层Dao，这里主要用注解写比较方便，也可以使用mybatis的xml配置文件写sql语句
package com.lzh.springbootstudytest.mapper; import com.lzh.springbootstudytest.bean.User;import org.apache.ibatis.annotations.*; import java.util.List; /** * @author lzh * create 2019-09-18-22:32 */@Mapperpublic interface UserDao { @Select("select * from user") List queryAll(); @Select("select * from user where uid = #{id}") User findUserById(int id); @Update("UPDATE USER SET username = CASE WHEN (#{userName} != NULL) AND (#{userName} != '') THEN #{userName},PASSWORD = CASE WHEN (#{passWord} != NULL) AND (#{passWord} != '') THEN #{passWord},salary = CASE WHEN (#{salary} != 0) THEN #{salary} WHERE uid = #{uid}") int updateUser(@Param("user") User user); @Delete("delete from user where uid = #{id}") int deleteUserById(int id); } service层，这里主要是使用redis模板来写
package com.lzh.springbootstudytest.service; import com.lzh.springbootstudytest.bean.User;import com.lzh.springbootstudytest.mapper.UserDao;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.data.redis.core.ValueOperations;import org.springframework.stereotype.Service; import java.util.List;import java.util.concurrent.TimeUnit; /** * @author lzh * create 2019-09-18-22:33 */@Servicepublic class UserService { @Autowired private UserDao userDao; @Autowired private RedisTemplate redisTemplate; public List queryAll() { return userDao.queryAll(); } /** * 获取用户策略：先从缓存中获取用户，没有则取数据表中 数据，再将数据写入缓存 */ public User findUserById(int id) { String key = "user_" + id; ValueOperations operations = redisTemplate.opsForValue(); //判断redis中是否有键为key的缓存 boolean hasKey = redisTemplate.hasKey(key); if (hasKey) { User user = operations.get(key); System.out.println("从缓存中获得数据："+user.getUserName()); System.out.println("------------------------------------"); return user; } else { User user = userDao.findUserById(id); System.out.println("查询数据库获得数据："+user.getUserName()); System.out.println("------------------------------------"); // 写入缓存 operations.set(key, user, 5, TimeUnit.HOURS); return user; } } /** * 更新用户策略：先更新数据表，成功之后，删除原来的缓存，再更新缓存 */ public int updateUser(User user) { ValueOperations operations = redisTemplate.opsForValue(); int result = userDao.updateUser(user); if (result != 0) { String key = "user_" + user.getUid(); boolean haskey = redisTemplate.hasKey(key); if (haskey) { redisTemplate.delete(key); System.out.println("删除缓存中的key-----------> " + key); } // 再将更新后的数据加入缓存 User userNew = userDao.findUserById(user.getUid()); if (userNew != null) { operations.set(key, userNew, 3, TimeUnit.HOURS); } } return result; } /** * 删除用户策略：删除数据表中数据，然后删除缓存 */ public int deleteUserById(int id) { int result = userDao.deleteUserById(id); String key = "user_" + id; if (result != 0) { boolean hasKey = redisTemplate.hasKey(key); if (hasKey) { redisTemplate.delete(key); System.out.println("删除了缓存中的key:" + key); } } return result; } } 这里主要是使用RedisTemplate来对远程redis操作，每次访问controller暴露的接口，首先判断redis缓存中是否存在该数据，若不存在就从数据库中读取数据，然后保存到redis缓存中，当下次访问的时候，就直接从缓存中取出来。
这样就不用每次都执行sql语句，能够提高访问速度。 但是在保存数据到缓存中，通过设置键和值和超时删除，注意设置超时删除缓存时间不要太长，否则会给服务器带来压力。
执行spring boot的启动类，访问http://localhost:8081/findUserById?id=1
再次访问http://localhost:8081/findUserById?id=1就是从缓存中获取保存的数据
以上就是springboot redis缓存配置的详细内容，代码示例简单明了，如果在日常工作遇到此问题。通过这篇文章，希望你能有所收获，更多详情敬请关注行业资讯频道！
缓存
数据
配置
序列
类型
服务器
服务
数据库
文件
注释
用户
语句
更新
最大
代码
密码
数据表
时间
策略
路径
数据库的安全要保护哪些东西
数据库安全各自的含义是什么
生产安全数据库录入
数据库的安全性及管理
数据库安全策略包含哪些
海淀数据库安全审计系统
建立农村房屋安全信息数据库
易用的数据库客户端支持安全管理
连接数据库失败ssl安全错误
数据库的锁怎样保障安全
roblox服务器怎么断开连接
惠州软件开发公司价格
网络技术三级选择填空
湖南米尚网络技术有限公司
移动软件开发的考研
网络安全管理学习资料
永劫无间开个服务器多少钱
asf云服务器
面向对象数据库技术课本
河南人工智能软件开发价钱是多少
安徽多线程服务器虚拟主机
2022年山东春季高考网络技术
软路由如何搭建plex服务器
软件开发对ipv6的支持
网络安全购物英语作业
当前网络技术带来的影响
网络安全论文1500
网络安全手抄报模板边框
北京智诚天泽网络技术
上海当乐网络技术有限公司
惠州软件开发公司价格
对大学生使用数据库的建议
中国软件开发技术网
软件开发需要联网吗
学什么网络技术兼职
数据库增加字段代码语句
可信赋能网络安全技术
数据库研发工程师
网络服务器机柜
重庆琪惠软件开发有限公司
