四川盐亭网站制作公司

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

今天就跟大家聊聊有关使用SpringBoot怎么实现redis分布式缓存，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。

10年积累的网站建设、网站制作经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先制作网站后付款的网站建设流程，更有安多免费网站建设让你可以放心的选择与我们合作。

架构图：

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

一二级缓存服务器

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

使用SpringBoot怎么实现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 redisTemplate(RedisConnectionFactory factory) {
 
   RedisTemplate 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;
 
 
 
@Configuration
public 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 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;
  }
 
 
  /**
   * 自定义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());
 }

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

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

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

使用SpringBoot怎么实现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());
 }

测试结果：

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

Redis工具类（redisUtil.java）

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

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

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工具类
 */
@Component
public class RedisUtil {
  @Autowired
  private RedisTemplate redisTemplate;
  @Autowired
  private ValueOperations valueOperations;
  @Autowired
  private HashOperations hashOperations;
  @Autowired
  private ListOperations listOperations;
  @Autowired
  private SetOperations setOperations;
  @Autowired
  private ZSetOperations 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 hmget(String key){
    return hashOperations.entries(key);
  }
 
  /**
   * HashSet
   * @param key 键
   * @param map 对应多个键值
   * @return true 成功 false 失败
   */
  public boolean hmset(String key, Map 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 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 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 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 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 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 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分布式缓存
看完上述内容，你们对使用SpringBoot怎么实现redis分布式缓存有进一步的了解吗？如果还想了解更多知识或者相关内容，请关注创新互联行业资讯频道，感谢大家的支持。
            
            
                            

                分享题目：使用SpringBoot怎么实现redis分布式缓存                

                文章起源：http://scyanting.com/article/pcocgj.html
            
        
        

            
其他资讯