（五） spring boot 配置使用 redis

柔光的暖阳◎ 2021-08-19 14:54 619阅读 0赞

实际的项目中难免会使用到缓存来提高我们程序的运行效率，用的最多的也还是 `redis` ，所以我此篇文章主要来写我们在 `springboot` 项目中如何整合与使用 `redis`

对于redis的使用其实很简单，也是数据库的一种，增删改查，没有什么太大的区别，只不过它的速度很快，因为redis使用的是内存进行查询

# 整合 redis #

--------------------

### 引入依赖 ###

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
                <version>1.5.15.RELEASE</version>
            </dependency>

### 配置文件配置 ###

## Reids配置
    # Redis服务器地址
    # 单机版配置
    spring.redis.host=114.55.27.152
    spring.redis.port=6379
    # 集群版本配置 多个之间用，逗号隔开
    ## spring.redis.cluster.nodes=127.0.0.1:6379
    
    # redis最大重连数
    redis.cluster.max-redirects=3
    # Redis服务器连接密码（默认为空）
    redis.password=
    # 最大空闲数
    redis.maxIdle=5
    # 连接池的最大数据库连接数。
    redis.maxTotal=5
    # 最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
    redis.maxWaitMillis=1000
    # 连接的最小空闲时间 默认1800000毫秒(30分钟)
    redis.minEvictableIdleTimeMillis=300000
    # 每次释放连接的最大数目,默认3
    redis.numTestsPerEvictionRun=3
    # 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
    redis.timeBetweenEvictionRunsMillis=30000
    # 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
    redis.testOnBorrow=true
    # 在空闲时检查有效性, 默认false
    redis.testWhileIdle=true

### 配置 redis 的 config 类 ###

package com.banana.demo.config;
    
    import com.banana.demo.util.RedisUtil;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    import org.springframework.stereotype.Component;
    import redis.clients.jedis.JedisPoolConfig;
    
    @Component
    public class RedisConfig { 
    
    	@Value("${redis.maxIdle}")
    	private Integer maxIdle;
    
    	@Value("${redis.maxTotal}")
    	private Integer maxTotal;
    
    	@Value("${redis.maxWaitMillis}")
    	private Integer maxWaitMillis;
    
    	@Value("${redis.minEvictableIdleTimeMillis}")
    	private Integer minEvictableIdleTimeMillis;
    
    	@Value("${redis.numTestsPerEvictionRun}")
    	private Integer numTestsPerEvictionRun;
    
    	@Value("${redis.timeBetweenEvictionRunsMillis}")
    	private long timeBetweenEvictionRunsMillis;
    
    // @Value("${redis.testOnBorrow}")
    // private boolean testOnBorrow;
    //
    // @Value("${redis.testWhileIdle")
    // private boolean testWhileIdle;
    
    	@Value("${redis.cluster.max-redirects}")
    	private Integer mmaxRedirectsac;
    
    	@Value("${redis.password}")
    	private String redispwd;
    
    	@Value("${spring.redis.host}")
    	private String host;
    
    	@Value("${spring.redis.port}")
    	private Integer port;
    
    
    	/** * JedisPoolConfig 连接池 * * @return */
    	@Bean
    	public JedisPoolConfig jedisPoolConfig() { 
    		JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
    		// 最大空闲数
    		jedisPoolConfig.setMaxIdle(maxIdle);
    		// 连接池的最大数据库连接数
    		jedisPoolConfig.setMaxTotal(maxTotal);
    		// 最大建立连接等待时间
    		jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
    		// 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
    		jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
    		// 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
    		jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
    		// 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
    		jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
    		// 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
    // jedisPoolConfig.setTestOnBorrow(testOnBorrow);
    		// 在空闲时检查有效性, 默认false
    // jedisPoolConfig.setTestWhileIdle(testWhileIdle);
    		return jedisPoolConfig;
    	}
    
    
    
    	
    	/** * 配置工厂 */
    	@Bean
    	public JedisConnectionFactory JedisConnectionFactory(JedisPoolConfig jedisPoolConfig) { 
    		JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);
    		/* * 设置密码，如果为空，则不设置 * 可在 redis.conf 文件中设置: requirepass 密码 */
    		
    		if (redispwd == null || redispwd.length() == 0) { 
    			jedisConnectionFactory.setPassword(redispwd);
    		}
    		jedisConnectionFactory.setHostName(host);
    		jedisConnectionFactory.setPort(port);
    		return jedisConnectionFactory;
    	}
    
    	/** * 实例化 RedisTemplate 对象 * @return */
    	@Bean
    	public RedisTemplate<String, Object> functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) { 
    		RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    		initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
    		return redisTemplate;
    	}
    
    	/** * 设置数据存入 redis 的序列化方式,并开启事务 * * @param redisTemplate * @param factory */
    	private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) { 
    		/* * 设置 序列化器 . * 如果不设置，那么在用实体类(未序列化)进行存储的时候，会提示错误: Failed to serialize object using DefaultSerializer; */
    		redisTemplate.setKeySerializer(new StringRedisSerializer());
    		redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    		redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
    		redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    		// 开启事务
    		redisTemplate.setEnableTransactionSupport(true);
    		// 将连接工厂设置到模板类中
    		redisTemplate.setConnectionFactory(factory);
    	}
    
    	/** * 注入封装RedisTemplate */
    	@Bean(name = "redisUtil")
    	public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) { 
    		RedisUtil redisUtil = new RedisUtil();
    		redisUtil.setRedisTemplate(redisTemplate);
    		return redisUtil;
    	}
    }

### 添加 redis 的工具类 ###

代码过长，影响排版，在文章后面添加

此工具类提供了对于redis中的不同的数据类型进行的操作，对其进行了封装，使用简单

### 配置在项目的使用中 ###

每次查询都把用户的信息存放进redis中，保存30s自动清空，这样其实可以很大程度长来保存好用户的信息，也能提高效率，然后我们保存好信息之后可以去redis中查看是否存在

//根据Id查询User
        @GetMapping("/user/{id}")
        @ApiOperation(value = "通过id查询用户", notes = "通过id查询user信息")
        @ApiImplicitParam(name = "id", value = "用户id", dataType = "String", required = true)
        @Cacheable("user-key")
        public User getUserById(@PathVariable Integer id) { 
            User user = (User) redisUtil.get("user_" + id);
            if (user == null) { 
                user = userDao.selectById(id);
                if (user == null) return null;
                redisUtil.set(String.valueOf(user.getId()), user.toString(), 30);
            }
            return user;
        }

访问完毕之后，我们就可以在redis中查看当前key的值是否存在了

因为封装了工具类之后，再去进行get和set就会比较方便，如果还是直接的使用原生的redisTemplate就会显得比较麻烦，原生的redisTemplate被封装进了redis的工具类中，可以进行查看

# 常见错误 #

--------------------

### Could not read JSON ###

如果出现如下错误，请确定所需实体，是否添加了无参的构造函数

> 2019-11-26 14:53:52.184 ERROR 39364 — \[nio-8088-exec-4\] o.a.c.c.C.\[.\[.\[/\].\[dispatcherServlet\] : Servlet.service() for servlet \[dispatcherServlet\] in context with path \[\] threw exception \[Request processing failed; nested exception is org.springframework.data.redis.serializer.SerializationException: Could not read JSON: Cannot construct instance of `com.banana.demo.entity.User` (no Creators, like default construct, exist): cannot deserialize from Object value (no delegate- or property-based Creator)

出现原因：  
redis的这些序列化方式，使用的是无参构造函数进行创建对象set方法进行赋值，方法中存在有参的构造函数，默认存在的无参构造函数是不存在的（继承自object），必须显式的去重写

### java.util.NoSuchElementException: Timeout waiting for idle object at ###

出现这个原因是redis的连接配小了，考虑配大一些，另外也要避免这类的错误，如果redis访问失败，考虑首是否可以查询数据库

> 2019-11-26 15:13:43.505 ERROR 42572 — \[nio-8088-exec-5\] o.a.c.c.C.\[.\[.\[/\].\[dispatcherServlet\] : Servlet.service() for servlet \[dispatcherServlet\] in context with path \[\] threw exception \[Request processing failed; nested exception is org.springframework.data.redis.RedisConnectionFailureException: Cannot get Jedis connection; nested exception is redis.clients.jedis.exceptions.JedisExhaustedPoolException: Could not get a resource since the pool is exhausted\] with root cause

修改一下配置文件的 `maxIdle` 和 `maxTotal` 的值，配的相对较大一点即可

# redis 工具类 #

--------------------

package com.banana.demo.util;
    
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.util.CollectionUtils;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    public class RedisUtil { 
    
    	private RedisTemplate<String, Object> redisTemplate;
    
    	public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) { 
    		this.redisTemplate = redisTemplate;
    	}
    
    	// =============================common============================
    	/** * 指定缓存失效时间 * * @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<Object> 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<Object> 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 值 * @param time 时间(秒) * @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 值 * @param time 时间(秒) * @return */
    	public boolean lSet(String key, List<Object> 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<Object> 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;
    		}
    	}
    
    }

# 推荐阅读 #

--------------------

**[SpringBoot整合redis][SpringBoot_redis]**

# 本系列文章 #

--------------------

**[Banana的SpringBoot系列博客][Banana_SpringBoot]**

[（一） SpringBoot 项目初始化 + 配置swagger页面][SpringBoot _ _ _swagger]

[（二） SpringBoot 整合 MyBatis-plus][SpringBoot _ MyBatis-plus]

[（三） SpringBoot之使用Swagger配置详解][SpringBoot_Swagger]

[（四） spring boot 多环境配置][spring boot]

[（五） spring boot 配置使用 redis][spring boot _ redis]

[SpringBoot_redis]: http://www.spring4all.com/article/17662
[Banana_SpringBoot]: https://blog.csdn.net/qq1515312832/category_9540232.html
[SpringBoot _ _ _swagger]: https://blog.csdn.net/qq1515312832/article/details/103192645
[SpringBoot _ MyBatis-plus]: https://blog.csdn.net/qq1515312832/article/details/103219467
[SpringBoot_Swagger]: https://blog.csdn.net/qq1515312832/article/details/103212461
[spring boot]: https://blog.csdn.net/qq1515312832/article/details/103232875
[spring boot _ redis]: https://blog.csdn.net/qq1515312832/article/details/103251335