版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本篇文章只是简单的SpringBoot整合redis及redis的简单工具类
1.导入pom文件
<!--redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>2.application.properties
# redis (RedisProperties)
# Redis数据库索引（默认为0）
spring.redis.database=10
# Redis服务器地址
spring.redis.host=192.168.1.103
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=-1
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=1003.RedisUtil工具类
package com.example.demo.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundZSetOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import java.io.Serializable;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* Created by 李庆伟 on 2018/10/15.
*/
@SuppressWarnings("unchecked")
@Component
public class RedisUtil {
@SuppressWarnings("rawtypes")
@Autowired
private RedisTemplate redisTemplate;
/**
* 批量删除对应的value
*
* @param keys
*/
public void remove(final String... keys) {
for (String key : keys) {
remove(key);
}
}
/**
* 批量删除key
*
* @param pattern
*/
public void removePattern(final String pattern) {
Set<Serializable> keys = redisTemplate.keys(pattern);
if (keys.size() > 0)
redisTemplate.delete(keys);
}
/**
* 删除对应的value
*
* @param key
*/
public void remove(final String key) {
if (exists(key)) {
redisTemplate.delete(key);
}
}
/**
* 判断缓存中是否有对应的value
*
* @param key
* @return
*/
public boolean exists(final String key) {
return redisTemplate.hasKey(key);
}
/**
* 读取缓存
*
* @param key
* @return
*/
public String get(final String key) {
Object result = null;
redisTemplate.setValueSerializer(new StringRedisSerializer());
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
result = operations.get(key);
if(result==null){
return null;
}
return result.toString();
}
/**
* 写入缓存
*
* @param key
* @param value
* @return
*/
public boolean set(final String key, Object value) {
boolean result = false;
try {
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
operations.set(key, value);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 写入缓存
*
* @param key
* @param value
* @return
*/
public boolean set(final String key, Object value, Long expireTime) {
boolean result = false;
try {
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
operations.set(key, value);
redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
public boolean hmset(String key, Map<String, String> value) {
boolean result = false;
try {
redisTemplate.opsForHash().putAll(key, value);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
public Map<String,String> hmget(String key) {
Map<String,String> result =null;
try {
result= redisTemplate.opsForHash().entries(key);
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 递增
*
* @param key 键
* @paramby 要增加几(大于0)
* @return
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @paramby 要减少几(小于0)
* @return
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
/**
* redis zset可已设置排序（案例，热搜）
*
* @param key 键
* @paramby
* @return
*/
public void zadd(String key ,String name) {
BoundZSetOperations<Object, Object> boundZSetOperations = redisTemplate.boundZSetOps(key);
//自增长后的数据
boundZSetOperations.incrementScore(name,1);
}
}
4.测试
package com.example.demo.controller;
import com.example.demo.utils.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
/**
* Created by 李庆伟 on 2018/7/24.
*/
@RequestMapping("/redisUtil")
@RestController
public class RedisController {
@Autowired
private RedisUtil redisUtil;
/**
* redis添加测试
* @param redisKey
* @param redisValue
*/
@RequestMapping("addRedis")
@ResponseBody
public String addRedis(String redisKey,String redisValue){
redisUtil.set(redisKey,redisValue);
return "addRedis添加redis数据成功";
}
/**
* redis key获取value测试
* @param redisKey
*/
@RequestMapping("getValueByRedis")
@ResponseBody
public String getValueByRedis(String redisKey){
Object obj = redisUtil.get(redisKey);
if(obj!=null){
System.out.print((String) obj);
return (String) obj;
}else {
return null;
}
}
/**
* 案例1
* 可以增加热搜，但是在取热搜词的时候，Map排序问题
*
* redis key获取value测试 模拟热搜 增加1
* @param hotWord
*/
@RequestMapping("updateValueByHotWord")
@ResponseBody
public String updateValueByHotWord(String hotWord){
Map<String,String> obj = redisUtil.hmget("mapHot");
if(obj==null){
Map<String ,String> mapHot = new HashMap<String ,String>();
mapHot.put(hotWord,"1");
redisUtil.hmset("mapHot",mapHot);
}else {
if(obj.get(hotWord)==null){
obj.put(hotWord,"1");
}else {
obj.put(hotWord,Integer.parseInt(obj.get(hotWord))+1+"");
}
redisUtil.hmset("mapHot",obj);
}
return "热搜已更新";
}
}