SpringBoot 整合redis实现缓存

一、
1、引入maven依赖
org.springframework.boot
spring-boot-starter-data-redis
2.2.2.RELEASE

2、配置application.properties
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=0

3、redis属性配置文件
package com.example.demo.conf;
/**

• @Description: redis配置
• @Author: Top
• @Version: V1.0
• @Date: 2020-03-06 14:53
  /
  import com.fasterxml.jackson.annotation.JsonAutoDetect;
  import com.fasterxml.jackson.annotation.PropertyAccessor;
  import com.fasterxml.jackson.databind.ObjectMapper;
  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.connection.RedisConnectionFactory;
  import org.springframework.data.redis.core.;
  import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  import org.springframework.data.redis.serializer.StringRedisSerializer;

/**

• @Description: 配置
• @Author: Top
• @Version: V1.0
• @Date: 2020-03-08 18:18
  */
  @Configuration
  @EnableCaching //开启缓存
  public class RedisConfig extends CachingConfigurerSupport {

/**

• 选择redis作为默认缓存工具
• @param redisTemplate
• @return
  */
  //@Bean
  //public CacheManager cacheManager(RedisTemplate redisTemplate) {
  // RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
  // return rcm;
  //}

/**

• retemplate相关配置
• @param factory
• @return
  */
  @Bean
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

RedisTemplate<String, Object> 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<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
  return redisTemplate.opsForHash();
  }

/**

• 对redis字符串类型数据操作
• @param redisTemplate
• @return
  */
  @Bean
  public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
  return redisTemplate.opsForValue();
  }

/**

• 对链表类型的数据操作
• @param redisTemplate
• @return
  */
  @Bean
  public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
  return redisTemplate.opsForList();
  }

/**

• 对无序集合类型的数据操作
• @param redisTemplate
• @return
  */
  @Bean
  public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
  return redisTemplate.opsForSet();
  }

/**

• 对有序集合类型的数据操作
• @param redisTemplate
• @return
  */
  @Bean
  public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
  return redisTemplate.opsForZSet();
  }
  }

4、使用
redis在程序中的使用，主要有2种方式：
（1）第一种方法：使用Spring注解：@Cacheable 、@CachePut、@CacheEvict （默认情况下不支持过期时间，如果需要过期时间，需要单独处理）（这种方式不推荐使用）
例子如下：
package com.demo.service;

import com.demo.dao.UserDetailsMapper;
import com.demo.pojo.UserDetails;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

/**

• Created by toutou on 2019/1/20.
  */
  @Service
  public class CacheServiceImpl implements CacheService{

  @Autowired
  UserDetailsMapper userDetailsMapper;

  @Override
  @Cacheable(value = “user_details”, key = “#uid”, unless="#result == null")
  public UserDetails getUserDetailsByUid(int uid){
  System.out.println(" Cacheable 有请求过来了");
  UserDetails userDetails = userDetailsMapper.getUserDetailsByUid(uid);
  return userDetails;
  }

  @Override
  @CachePut(value = “user_details”, key = “#user.id”)
  public UserDetails updateUserInfo(UserDetails user){
  System.out.println(" CachePut 有请求过来了");
  if(userDetailsMapper.updateByPrimaryKeySelective(user) > 0) {
  // 这里也可以直接在updateByPrimaryKeySelective的方法里，修改后直接查询出该记录返回UserDetails实例，看需求。
  user = userDetailsMapper.getUserDetailsByUid(user.getId());
  return user;
  }else{
  return null;
  }
  }

  @Override
  @CacheEvict(value = “user_details”, key = “#uid”)
  public int delUserInfoById(int uid){
  System.out.println(" CacheEvict 有请求过来了");
  return userDetailsMapper.deleteByPrimaryKey(uid);
  }

}

 （2）第二种方法是：使用 RedisTemplate创建工具类 （推荐这种使用方法，更加灵活方便）
         第一步：先创建工具类
          package com.example.demo.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**

• @Description: redis工具类
• @Author: Top
• @Version: V1.0
• @Date: 2020-03-06 14:56
  */
  @Component
  public class RedisUtil {

@Autowired
private RedisTemplate<String, Object> redisTemplate;

/**

• 指定缓存失效时间
• @param key 键
• @param time 时间(秒)
• @return
  */
  public boolean expire(String key, long time) {
  try {
  if (time > 0) {
  redisTemplate.expire(key, time, TimeUnit.SECONDS);
  }
  return true;
  } catch (Exception e) {
  e.printStackTrace();
  return false;
  }
  }

/**

• 根据key 获取过期时间
• @param key 键 不能为null
• @return 时间(秒) 返回0代表为永久有效
  */
  public long getExpire(String key) {
  return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  }

/**

• 判断key是否存在
• @param key 键
• @return true 存在 false不存在
  */
  public boolean hasKey(String key) {
  try {
  return redisTemplate.hasKey(key);
  } catch (Exception e) {
  e.printStackTrace();
  return false;
  }
  }

/**

• 删除缓存
• @param key 可以传一个值 或多个
  */
  @SuppressWarnings(“unchecked”)
  public void del(String… key) {
  if (key != null && key.length > 0) {
  if (key.length == 1) {
  redisTemplate.delete(key[0]);
  } else {
  redisTemplate.delete(CollectionUtils.arrayToList(key));
  }
  }
  }

// String=
/**

• 普通缓存获取
• @param key 键
• @return 值
  */
  public Object get(String key) {
  return key == null ? null : redisTemplate.opsForValue().get(key);
  }

/**

• 普通缓存放入
• @param key 键
• @param value 值
• @return true成功 false失败
  */
  public boolean set(String key, Object value) {
  try {
  redisTemplate.opsForValue().set(key, value);
  return true;
  } catch (Exception e) {
  e.printStackTrace();
  return false;
  }
  }

/**

• 普通缓存放入并设置时间
• @param key 键
• @param value 值
• @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
• @return true成功 false 失败
  */
  public boolean set(String key, Object value, long time) {
  try {
  if (time > 0) {
  redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  } else {
  set(key, value);
  }
  return true;
  } catch (Exception e) {
  e.printStackTrace();
  return false;
  }
  }

/**

• 递增
• @param key 键
• @param delta 要增加几(大于0)
• @return
  */
  public long incr(String key, long delta) {
  if (delta < 0) {
  throw new RuntimeException(“递增因子必须大于0”);
  }
  return redisTemplate.opsForValue().increment(key, delta);
  }

/**

• 递减
• @param key 键
• @param delta 要减少几(小于0)
• @return
  */
  public long decr(String key, long delta) {
  if (delta < 0) {
  throw new RuntimeException(“递减因子必须大于0”);
  }
  return redisTemplate.opsForValue().increment(key, -delta);
  }

// Map=
/**

• HashGet
• @param key 键 不能为null
• @param item 项 不能为null
• @return 值
  */
  public Object hget(String key, String item) {
  return redisTemplate.opsForHash().get(key, item);
  }

/**

• 获取hashKey对应的所有键值
• @param key 键
• @return 对应的多个键值
  */
  public Map<Object, Object> hmget(String key) {
  return redisTemplate.opsForHash().entries(key);
  }

/**

• HashSet
• @param key 键
• @param map 对应多个键值
• @return true 成功 false 失败
  */
  public boolean hmset(String key, Map<String, Object> map) {
  try {
  redisTemplate.opsForHash().putAll(key, map);
  return true;
  } catch (Exception e) {
  e.printStackTrace();
  return false;
  }
  }

/**

• HashSet 并设置时间
• @param key 键
• @param map 对应多个键值
• @param time 时间(秒)
• @return true成功 false失败
  */
  public boolean hmset(String key, Map<String, Object> map, long time) {
  try {
  redisTemplate.opsForHash().putAll(key, map);
  if (time > 0) {
  expire(key, time);
  }
  return true;
  } catch (Exception e) {
  e.printStackTrace();
  return false;
  }
  }

/**

• 向一张hash表中放入数据,如果不存在将创建
• @param key 键
• @param item 项
• @param value 值
• @return true 成功 false失败
  */
  public boolean hset(String key, String item, Object value) {
  try {
  redisTemplate.opsForHash().put(key, item, value);
  return true;
  } catch (Exception e) {
  e.printStackTrace();
  return false;
  }
  }

/**

• 向一张hash表中放入数据,如果不存在将创建
• @param key 键
• @param item 项
• @param value 值
• @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
• @return true 成功 false失败
  */
  public boolean hset(String key, String item, Object value, long time) {
  try {
  redisTemplate.opsForHash().put(key, item, value);
  if (time > 0) {
  expire(key, time);
  }
  return true;
  } catch (Exception e) {
  e.printStackTrace();
  return false;
  }
  }

/**

• 删除hash表中的值
• @param key 键 不能为null
• @param item 项 可以使多个 不能为null
  */
  public void hdel(String key, Object… item) {
  redisTemplate.opsForHash().delete(key, item);
  }

/**

• 判断hash表中是否有该项的值
• @param key 键 不能为null
• @param item 项 不能为null
• @return true 存在 false不存在
  */
  public boolean hHasKey(String key, String item) {
  return redisTemplate.opsForHash().hasKey(key, item);
  }

/**

• hash递增 如果不存在,就会创建一个 并把新增后的值返回
• @param key 键
• @param item 项
• @param by 要增加几(大于0)
• @return
  */
  public double hincr(String key, String item, double by) {
  return redisTemplate.opsForHash().increment(key, item, by);
  }

/**

• hash递减
• @param key 键
• @param item 项
• @param by 要减少记(小于0)
• @return
  */
  public double hdecr(String key, String item, double by) {
  return redisTemplate.opsForHash().increment(key, item, -by);
  }

// set=
/**

• 根据key获取Set中的所有值
• @param key 键
• @return
  */
  public Set sGet(String key) {
  try {
  return redisTemplate.opsForSet().members(key);
  } catch (Exception e) {
  e.printStackTrace();
  return null;
  }
  }

/**

• 根据value从一个set中查询,是否存在
• @param key 键
• @param value 值
• @return true 存在 false不存在
  */
  public boolean sHasKey(String key, Object value) {
  try {
  return redisTemplate.opsForSet().isMember(key, value);
  } catch (Exception e) {
  e.printStackTrace();
  return false;
  }
  }

/**

• 将数据放入set缓存
• @param key 键
• @param values 值 可以是多个
• @return 成功个数
  */
  public long sSet(String key, Object… values) {
  try {
  return redisTemplate.opsForSet().add(key, values);
  } catch (Exception e) {
  e.printStackTrace();
  return 0;
  }
  }

/**

• 将set数据放入缓存
• @param key 键
• @param time 时间(秒)
• @param values 值 可以是多个
• @return 成功个数
  */
  public long sSetAndTime(String key, long time, Object… values) {
  try {
  Long count = redisTemplate.opsForSet().add(key, values);
  if (time > 0)
  {
  expire(key, time);
  }
  return count;
  } catch (Exception e) {
  e.printStackTrace();
  return 0;
  }
  }

/**

• 获取set缓存的长度
• @param key 键
• @return
  /
  public long sGetSetSize(String key) {
  try {
  return redisTemplate.opsForSet().size(key);
  } catch (Exception e) {
  e.printStackTrace();
  return 0;
  }
  }
  /*
• 移除值为value的
• @param key 键
• @param values 值 可以是多个
• @return 移除的个数
  */
  public long setRemove(String key, Object… values) {
  try {
  Long count = redisTemplate.opsForSet().remove(key, values);
  return count;
  } catch (Exception e) {
  e.printStackTrace();
  return 0;
  }
  }

// =list===
/**

• 获取list缓存的内容
• @param key 键
• @param start 开始
• @param end 结束 0 到 -1代表所有值
• @return
  */
  public List lGet(String key, long start, long end) {
  try {
  return redisTemplate.opsForList().range(key, start, end);
  } catch (Exception e) {
  e.printStackTrace();
  return null;
  }
  }

/**

• 获取list缓存的长度
• @param key 键
• @return
  */
  public long lGetListSize(String key) {
  try {
  return redisTemplate.opsForList().size(key);
  } catch (Exception e) {
  e.printStackTrace();
  return 0;
  }
  }

/**

• 通过索引 获取list中的值
• @param key 键
• @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
• @return
  */
  public Object lGetIndex(String key, long index) {
  try {
  return redisTemplate.opsForList().index(key, index);
  } catch (Exception e) {
  e.printStackTrace();
  return null;
  }
  }

/**

• 将list放入缓存
• @param key 键
• @param value 值
• @return
  */
  public boolean lSet(String key, Object value) {
  try {
  redisTemplate.opsForList().rightPush(key, value);
  return true;
  } catch (Exception e) {
  e.printStackTrace();
  return false;
  }
  }

/**

• 将list放入缓存
• @param key 键
• @param value 值
• @param time 时间(秒)
• @return
  */
  public boolean lSet(String key, Object value, long time) {
  try {
  redisTemplate.opsForList().rightPush(key, value);
  if (time > 0){
  expire(key, time);
  }
  return true;
  } catch (Exception e) {
  e.printStackTrace();
  return false;
  }
  }

/**

• 将list放入缓存
• @param key 键
• @param value 值
• @return
  */
  public boolean lSet(String key, List value) {
  try {
  redisTemplate.opsForList().rightPushAll(key, value);
  return true;
  } catch (Exception e) {
  e.printStackTrace();
  return false;
  }
  }

/**

• 将list放入缓存
• @param key 键
• @param value 值
• @param time 时间(秒)
• @return
  */
  public boolean lSet(String key, List value, long time) {
  try {
  redisTemplate.opsForList().rightPushAll(key, value);
  if (time > 0){
  expire(key, time);
  }
  return true;
  } catch (Exception e) {
  e.printStackTrace();
  return false;
  }
  }

/**

• 根据索引修改list中的某条数据
• @param key 键
• @param index 索引
• @param value 值
• @return
  */
  public boolean lUpdateIndex(String key, long index, Object value) {
  try {
  redisTemplate.opsForList().set(key, index, value);
  return true;
  } catch (Exception e) {
  e.printStackTrace();
  return false;
  }
  }

/**

• 移除N个值为value

• @param key 键

• @param count 移除多少个

• @param value 值

• @return 移除的个数
  */
  public long lRemove(String key, long count, Object value) {
  try {
  Long remove = redisTemplate.opsForList().remove(key, count, value);
  return remove;
  } catch (Exception e) {
  e.printStackTrace();
  return 0;
  }
  }
  }

  第二步：在代码中使用缓存工具类 RedisUtil
  package com.example.demo.controller;
  import com.example.demo.common.HouseMovingInfoVO;
  import com.example.demo.common.Result;
  import com.example.demo.common.ResultCode;
  import com.example.demo.entity.HouseMovingInfo;
  import com.example.demo.service.HouseMovingService;
  import com.example.demo.utils.RedisUtil;
  import com.example.demo.utils.ResultBulider;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Date;
import java.util.List;

/**

• @Description: 使用缓存
• @Author: Top
• @Version: V1.0
• @Date: 2020-01-15 15:03
  */
  @RestController
  @RequestMapping("/api/{edition}/page")
  public class MyPageHelperController {

@Autowired
private RedisTemplate redisTemplate;
@Autowired
private HouseMovingService houseMovingService;
@Autowired
private RedisUtil redisUtil;

@GetMapping("/myPage1")
@ResponseBody
public Result myPage1(HttpServletRequest request, HttpServletResponse response,
@PathVariable(“edition”) String edition,
@RequestParam(value = “pageNum”, required = false) Integer pageNum,
@RequestParam(value = “pageSize”, required = false) Integer pageSize) {
try {
Result result = new Result();

//查询缓存
List houseMovingInfoVOs= (List)redisTemplate.opsForValue().get(“allStude”);
if(null == houseMovingInfoVOs) {
//缓存为空，查询一遍数据库
List houseMovingInfoVOList = houseMovingService.selectBycity(pageNum,pageSize);
//把数据库查询出来数据，放入Redis中
redisUtil.set(“allStude”,houseMovingInfoVOList, 300);
result.setData(houseMovingInfoVOList);
}else{
result.setData(houseMovingInfoVOs);
}
return result;
} catch (Exception e) {
e.printStackTrace();
return ResultBulider.faile(ResultCode.DATA_IS_WRONG);
}
}

@PostMapping("/add")
@ResponseBody
public Result add(HttpServletRequest request, HttpServletResponse response,
@PathVariable(“edition”) String edition,
@RequestBody HouseMovingInfoVO houseMovingInfoVO) {
Result result = new Result();
try {
redisUtil.del(“allStude”);
HouseMovingInfo houseMovingInfo = new HouseMovingInfo();
houseMovingInfo.setCt(new Date());
houseMovingInfo.setEt(new Date());
houseMovingInfo.setUserName(“张贵”);
houseMovingInfo.setType((byte) 0);
houseMovingInfo.setJobNumber(“top”+System.currentTimeMillis());
houseMovingService.insert(houseMovingInfo);
redisUtil.del(“allStude”);
return result;
} catch (Exception e) {
e.printStackTrace();
return ResultBulider.faile(ResultCode.DATA_IS_WRONG);
}
}

@GetMapping("/add1")
@ResponseBody
public Result add1(HttpServletRequest request, HttpServletResponse response) {
Result result = new Result();
try {
Object fu = redisUtil.get(“fu”);
if(null == fu || Long.valueOf(String.valueOf(fu)) < 5){
System.out.println(“不够5”);
redisUtil.incr(“fu”, 1);
}else{
System.out.println(“够5”);
}
return result;
} catch (Exception e) {
e.printStackTrace();
return ResultBulider.faile(ResultCode.DATA_IS_WRONG);
}
}
}

知识点：

1、单线程的redis为什么这么快？
· 完全基于内存，绝大部分请求是纯粹的内存操作，非常快速
· 数据结构简单，对数据操作也简单，
· 采用单线程，避免了不必要的上下文切换和竞争，也不存在多进程或者多线程导致的切换而消耗CPU，不用去考虑各种锁的问题
· 使用多路I/O复用，非阻塞额IO（“多路”指的是多个网络连接，“复用”指的是复用同一个线程）
· 使用底层模型不同，Redis直接自己构建了VM机制，因为一般的应用调用系统函数的化，会浪费一定的时间去移动和请求
2、Redis集群模式
· 主从模式 - 当主服务器宕机后，需要手动把一台服务器切换为主服务器，这一步是需要人工干预的，费事费力，还会造成一段时间内服务的不可用。所以主从模式不是推荐的方式。
· 哨兵模式 - Redis Sentinel是一个分布式的架构，它本身也是一个独立的Redis节点，只不过它不存储数据，只支持命令，它能够自动完成故障发现和故障转移，并通知应用，从而实现高可用。哨兵模式其实是有2个集群在同时同作：一个是Sentinel集群，一个是数据节点集群。Redis Sentinel包含若干个Sentinel节点和Redis数据节点，每个Sentinel节点会多数据节点和其他的Sentinel节点进行监控，当发现节点异常时，会对节点做下线标示，如果被标示的是主节点，此时会与其他Sentinel进行协商，当大多是Sentinel节点都认为主节点不可达时候，会发起选举，选出一个Sentinel节点来完成自动故障转移的工作，同时会将这个变化通知给Redis的应用方。这个过程是自动化的，无需人工干预。虽然哨兵模式比主从模式提高了不少系统的高可用性，但是该模式不能水平扩容，不能动态增、删节点啊，这也是限制哨兵模式广泛应用的主要原因。Redis也是看到了这个情况，所以在Redis3.x以后的版本提供了一个更加强大集群模式，那就是Cluster集群模式。
在这里插入图片描述

 · Cluster集群 - Redis Cluster集群节点最下配置6个节点以上（3主3从），其中主节点提供读写操作，从节点为备用节点，不提供请求，只作为故障转移使用。
   Cluster模式优点：
    （1）无中心架构
    （2）数据按照solt存储分布在多个节点，节点间数据共享，可以动态调整数据分布
    （3）可线性扩展到1000多个节点，节点可动态添加或删除
    （4）部分节点不可用时，集群仍可用。通过增加Slave做standby数据副本，能够实现故障自动转移，节点之间通过gossip协议交换状态信息，用投票机制完成Slave到Master的角色提升