SpringBoot中怎么利用redis实现分布式缓存

这期内容当中小编将会给大家带来有关SpringBoot中怎么利用redis实现分布式缓存，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。

一二级缓存服务器

使用Redis缓存，通过网络访问还是不如从内存中获取性能好，所以通常称之为二级缓存，从内存中取得的缓存数据称之为一级缓存。当应用系统需要查询缓存的时候，先从一级缓存里查找，如果有，则返回，如果没有查找到，则再查询二级缓存，架构图如下

Spring Boot 2 自带了前面俩种缓存的实现方式，本文将简单实现第三种，高速一二级缓存实现

Redis分布式缓存

引入redis的starter

配置Redis

在application.yml中配置redis信息

spring: redis:  database: 0  host: 192.168.0.146  port: 6379  timeout: 5000

其他相关配置

# 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

配置Redis缓存序列化机制

有的时候需要将对象存进redis（例如一个JavaBean对象），但是如果对象不是可Serializable的，因此需要让JavaBean对象实现Serializable接口

public class UserPO implements Serializable {

如果只是让JavaBean实现Serializable接口也是可以存储的，但是并不好看，那么能不能将JavaBean弄成Json的样式放进redis呢。直接的方式就是自己转换，但是未免有点麻烦，那就只能修改RedisTemplate的序列化机制了，在配置类中配置上序列化的方法即可

@Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {    RedisTemplate<String, Object> template = new RedisTemplate();   template.setConnectionFactory(factory);    Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);   ObjectMapper om = new ObjectMapper();   om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);   om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);   jacksonSeial.setObjectMapper(om);    // 值采用json序列化   template.setValueSerializer(jacksonSeial);   //使用StringRedisSerializer来序列化和反序列化redis的key值   template.setKeySerializer(new StringRedisSerializer());   template.setHashKeySerializer(new StringRedisSerializer());   template.setHashValueSerializer(jacksonSeial);   template.afterPropertiesSet();    return template; }

自定义CacheManager

/**  * 选择Redis作为默认缓存工具  * @param redisTemplate  * @return  */ @Bean public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {    RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();   return RedisCacheManager       .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))       .cacheDefaults(redisCacheConfiguration).build();  }

RedisConfig完整代码

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.interceptor.KeyGenerator;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.RedisTemplate;import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;import org.springframework.data.redis.serializer.StringRedisSerializer; import java.lang.reflect.Method;import java.net.UnknownHostException;   @Configurationpublic class RedisConfig extends CachingConfigurerSupport {   /**   * 选择Redis作为默认缓存工具   * @param redisTemplate   * @return   */  @Bean  public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {     RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();    return RedisCacheManager        .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))        .cacheDefaults(redisCacheConfiguration).build();   }    /**   * 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;  }    /**   * 自定义key的生成策略   * @return   */  @Bean  public KeyGenerator myKeyGenerator(){    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();      }    };  }}

使用Redi缓存注解

service：

@CachePut(value = "user",key = "'user_'+#result.id")  public UserPO save(UserPO po) {    userJpaMapper.save(po);    return po;  }   @CachePut(value = "user",key = "'user_'+#result.id")  public UserPO update(UserPO po) {    System.out.println("数据库更新");    userMapper.update(po);    return po;  }   @Cacheable(value = "user", key = "'user_'+#id")  public UserPO getUser(Integer id){    System.out.println("访问数据库："+id);    return userJpaMapper.getOne(id);  }   @CacheEvict(value = "user", key = "'user_'+#id")  public void delete(Integer id) {    userJpaMapper.deleteById(id);  }

测试类：

@Test void contextLoads() {   Integer id = 2;   UserPO user1 = userService.getUser(id);   System.out.println("第一次查询："+user1.getUserName());    UserPO user2 = userService.getUser(id);   System.out.println("第二次查询："+user2.getUserName()); }

测试结果：第一次查询的时候访问了数据库，第二次查询的时候并没有访问数据库

通过redis-cli 可以查看到数据已经保存到了redis上面

测试类：

@Test void updataUser() {   Integer id = 4;   UserPO user1 = userService.getUser(id);   System.out.println("第一次查询："+user1.getUserName()+", 年龄："+user1.getAge());    user1.setAge(60);   userService.update(user1);    UserPO user2 = userService.getUser(id);   System.out.println("第二次查询："+user2.getUserName()+", 年龄："+user2.getAge()); }

测试结果：

Redis工具类（redisUtil.java）

1.在RedisConfig中定义redisTemplate操作对象

/**   * 对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();  }

2.在redisUtil工具类中使用这些对象，并构建其操作方法

package com.meng.demo.utils; import org.springframework.beans.factory.annotation.Autowired;import org.springframework.data.redis.core.*;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;  /** * redis工具类 */@Componentpublic class RedisUtil {  @Autowired  private RedisTemplate<String, Object> redisTemplate;  @Autowired  private ValueOperations<String, Object> valueOperations;  @Autowired  private HashOperations<String, String, Object> hashOperations;  @Autowired  private ListOperations<String, Object> listOperations;  @Autowired  private SetOperations<String, Object> setOperations;  @Autowired  private ZSetOperations<String, Object> zSetOperations;    /**=============================共同操作============================*/  /**   * 指定缓存失效时间   * @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 可以传一个值或多个   */  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));      }    }  }  /**============================ValueOperations操作=============================*/  /**   * 普通缓存放入   * @param key 键   * @param value 值   * @return true-成功、 false-失败   */  public boolean set(String key,Object value) {    try {      valueOperations.set(key, value);      return true;    } catch (Exception e) {      e.printStackTrace();      return false;    }  }  /**   * 普通缓存放入并设置时间   * @param key 键   * @param value 值   * @param expireTime 时间(秒) expireTime要大于0 如果expireTime小于等于0 将设置无限期   * @return true成功 false失败   */  public boolean set(String key,Object value,long expireTime){    try {      if(expireTime > 0){        valueOperations.set(key, value, expireTime, TimeUnit.SECONDS);      }else{        set(key, value);      }      return true;    } catch (Exception e) {      e.printStackTrace();      return false;    }  }  /**   * 普通缓存获取   * @param key 键   * @return 值   */  public Object get(String key){    return key==null ? null:valueOperations.get(key);  }  /**   * 递增   * @param key 键   * @return   */  public long incr(String key, long delta){    if(delta<0){      throw new RuntimeException("递增因子必须大于0");    }    return valueOperations.increment(key, delta);  }  /**   * 递减   * @param key   * @param delta 要减少几(小于0)   * @return   */  public long decr(String key, long delta){    if(delta<0){      throw new RuntimeException("递减因子必须大于0");    }    return valueOperations.increment(key, -delta);  }   /**================================HashOperations操作=================================*/  /**   * HashGet   * @param key 键 不能为null   * @param item 项 不能为null   * @return 值   */  public Object hget(String key,String item){    return hashOperations.get(key, item);  }   /**   * 获取hashKey对应的所有键值   * @param key 键   * @return 对应的多个键值   */  public Map<String, Object> hmget(String key){    return hashOperations.entries(key);  }   /**   * HashSet   * @param key 键   * @param map 对应多个键值   * @return true 成功 false 失败   */  public boolean hmset(String key, Map<String,Object> map){    try {      hashOperations.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 {      hashOperations.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 {      hashOperations.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 {      hashOperations.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){    hashOperations.delete(key,item);  }   /**   * 判断hash表中是否有该项的值   * @param key 键 不能为null   * @param item 项 不能为null   * @return true 存在 false不存在   */  public boolean hHasKey(String key, String item){    return hashOperations.hasKey(key, item);  }   /**   * hash递增 如果不存在,就会创建一个 并把新增后的值返回   * @param key 键   * @param item 项   * @param by 要增加几(大于0)   * @return   */  public double hincr(String key, String item,double by){    return hashOperations.increment(key, item, by);  }   /**   * hash递减   * @param key 键   * @param item 项   * @param by 要减少记(小于0)   * @return   */  public double hdecr(String key, String item,double by){    return hashOperations.increment(key, item,-by);  }   /**============================set=============================   /**   * 根据key获取Set中的所有值   * @param key 键   * @return   */  public Set<Object> sGet(String key){    try {      return setOperations.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 setOperations.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 setOperations.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 = setOperations.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 setOperations.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 = setOperations.remove(key, values);      return count;    } catch (Exception e) {      e.printStackTrace();      return 0;    }  }  /**===============================ListOperations=================================   /**   * 获取list缓存的内容   * @param key 键   * @param start 开始   * @param end 结束 0 到 -1代表所有值   * @return   */  public List<Object> lGet(String key, long start, long end){    try {      return listOperations.range(key, start, end);    } catch (Exception e) {      e.printStackTrace();      return null;    }  }  /**   * 获取list缓存的所有内容   * @param key   * @return   */  public List<Object> lGetAll(String key){    return lGet(key,0,-1);  }   /**   * 获取list缓存的长度   * @param key 键   * @return   */  public long lGetListSize(String key){    try {      return listOperations.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 listOperations.index(key, index);    } catch (Exception e) {      e.printStackTrace();      return null;    }  }  /**   * 将list放入缓存   * @param key 键   * @param value 值   * @return   */  public boolean lSet(String key, Object value) {    try {      listOperations.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 {      listOperations.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<Object> value) {    try {      listOperations.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<Object> value, long time) {    try {      listOperations.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 {      listOperations.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 = listOperations.remove(key, count, value);      return remove;    } catch (Exception e) {      e.printStackTrace();      return 0;    }  }}

3.测试

@Test void test01(){   redisUtil.set("meng","yang");   Object key = redisUtil.get("meng");   System.out.println(key); }

上述就是小编为大家分享的SpringBoot中怎么利用redis实现分布式缓存了，如果刚好有类似的疑惑，不妨参照上述分析进行理解。如果想知道更多相关知识，欢迎关注亿速云行业资讯频道。