上篇介绍了 Spring-data-jpa一些使用方法,都是基于mysql数据库来讲解的,但是在实际项目中,由于访问量的不断增大,数据库的压力会越来越大,这时候类似于mysql的数据库往往只是为了兜底或者在降级时才会有查询操作,大部分的读操作都会集中在缓存或者像elasticsearch这种全文搜索引擎,本篇主要介绍一下如何在SpringBoot中使用Redis,后续会介绍如何集成elasticsearch
1、添加Redis起步依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-redis</artifactId>
</dependency>
2、添加Redis相关配置
spring:
redis:
host: localhost
port: 6379
pool:
max-idle: 100
min-idle: 1
max-active: 1000
max-wait: -1
3、编写Redis配置类
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
/**
* 生成key的策略
* @return
*/
@Bean
public KeyGenerator keyGenerator {
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;
}
};
}
/**
* 管理缓存
*/
@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate) {
RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
return rcm;
}
/**
* RedisTemplate配置
*/
@Bean
public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
StringRedisTemplate template = new StringRedisTemplate(factory);
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper;
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
template.setValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet;
return template;
}
}
4、编写Redis操作相关Service
@Service
public class RedisService {
@Autowired
private RedisTemplate redisTemplate;
/**
* 写入缓存
* @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;
}
/**
* 批量删除对应的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 Object get(final String key) {
Object result = null;
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue;
result = operations.get(key);
return result;
}
/**
* 哈希 添加
* @param key
* @param hashKey
* @param value
*/
public void hmSet(String key, Object hashKey, Object value){
HashOperations<String, Object, Object> hash = redisTemplate.opsForHash;
hash.put(key,hashKey,value);
}
/**
* 哈希获取数据
* @param key
* @param hashKey
* @return
*/
public Object hmGet(String key, Object hashKey){
HashOperations<String, Object, Object> hash = redisTemplate.opsForHash;
return hash.get(key,hashKey);
}
/**
* 列表添加
* @param k
* @param v
*/
public void lPush(String k,Object v){
ListOperations<String, Object> list = redisTemplate.opsForList;
list.rightPush(k,v);
}
/**
* 列表获取
* @param k
* @param l
* @param l1
* @return
*/
public List<Object> lRange(String k, long l, long l1){
ListOperations<String, Object> list = redisTemplate.opsForList;
return list.range(k,l,l1);
}
/**
* 集合添加
* @param key
* @param value
*/
public void add(String key,Object value){
SetOperations<String, Object> set = redisTemplate.opsForSet;
set.add(key,value);
}
/**
* 集合获取
* @param key
* @return
*/
public Set<Object> setMembers(String key){
SetOperations<String, Object> set = redisTemplate.opsForSet;
return set.members(key);
}
/**
* 有序集合添加
* @param key
* @param value
* @param scoure
*/
public void zAdd(String key,Object value,double scoure){
ZSetOperations<String, Object> zset = redisTemplate.opsForZSet;
zset.add(key,value,scoure);
}
/**
* 有序集合获取
* @param key
* @param scoure
* @param scoure1
* @return
*/
public Set<Object> rangeByScore(String key,double scoure,double scoure1){
ZSetOperations<String, Object> zset = redisTemplate.opsForZSet;
return zset.rangeByScore(key, scoure, scoure1);
}
}
5、写一个controller打印测试一下
@RestController
@RequestMapping(value="/redis")
public class redisTestController {
@Autowired
private RedisService redisService;
@RequestMapping(value = "/test", method = {RequestMethod.GET, RequestMethod.POST})
public String redisTest{
StringBuffer sb = new StringBuffer;
redisService.set("str", "str");
sb.append("str=").append(redisService.get("str").toString).append(",");
redisService.hmSet("hmset","key","val");
sb.append("hmset=").append(redisService.hmGet("hmset","key")).append(",");
redisService.lPush("list","val");
sb.append("list=").append(redisService.lRange("list",0,1).toString).append(",");
redisService.add("set","val");
sb.append("set=").append(redisService.setMembers("set").toString).append(",");
redisService.zAdd("zset","val1",1);
redisService.zAdd("zset","val2",2);
sb.append("zset=").append(redisService.rangeByScore("zset",1,2)).append(",");
return sb.toString;
}
}
我们在浏览器中输入http://localhost:8080/redis/test,显示一下页面,ok!Redis集成完成,是不是很简单呢!!!
本文为头条号作者发布,不代表今日头条立场。