简单的使用redis存、取数据

首先，redis配置类如下：

package org.jeecg.config;

import java.lang.reflect.Method;

import java.time.Duration;

import java.util.Arrays;

import javax.annotation.Resource;

import org.jeecg.common.constant.CacheConstant;

import org.springframework.cache.CacheManager;

import org.springframework.cache.annotation.CachingConfigurerSupport;

import org.springframework.cache.annotation.EnableCaching;

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.lettuce.LettuceConnectionFactory;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.RedisSerializationContext;

import org.springframework.data.redis.serializer.RedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;

import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;

import com.fasterxml.jackson.annotation.PropertyAccessor;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.fasterxml.jackson.databind.ObjectMapper.DefaultTyping;

import static java.util.Collections.singletonMap;

@Configuration

@EnableCaching // 开启缓存支持

public class RedisConfig extends CachingConfigurerSupport {

@Resource

private LettuceConnectionFactory lettuceConnectionFactory;

// /**

// * @description 自定义的缓存key的生成策略 若想使用这个key

// * 只需要讲注解上keyGenerator的值设置为keyGenerator即可

// * @return 自定义策略生成的key

// */

// @Override

// @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.getDeclaringClass().getName());

// Arrays.stream(params).map(Object::toString).forEach(sb::append);

// return sb.toString();

// }

// };

// }

/**

* RedisTemplate配置

*

* @param lettuceConnectionFactory

* @return

*/

@Bean

public RedisTemplate redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {

// 设置序列化

Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

ObjectMapper om = new ObjectMapper();

om.setVisibility(PropertyAccessor.ALL, Visibility.ANY);

om.enableDefaultTyping(DefaultTyping.NON_FINAL);

jackson2JsonRedisSerializer.setObjectMapper(om);

// 配置redisTemplate

RedisTemplate redisTemplate = new RedisTemplate();

redisTemplate.setConnectionFactory(lettuceConnectionFactory);

RedisSerializer> stringSerializer = new StringRedisSerializer();

redisTemplate.setKeySerializer(stringSerializer);// key序列化

redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);// value序列化

redisTemplate.setHashKeySerializer(stringSerializer);// Hash key序列化

redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);// Hash value序列化

redisTemplate.afterPropertiesSet();

return redisTemplate;

}

/**

* 缓存配置管理器

*

* @param factory

* @return

*/

@Bean

public CacheManager cacheManager(LettuceConnectionFactory factory) {

// 配置序列化(缓存默认有效期 6小时)

RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofHours(6));

RedisCacheConfiguration redisCacheConfiguration = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))

.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));

// 以锁写入的方式创建RedisCacheWriter对象

//RedisCacheWriter writer = RedisCacheWriter.lockingRedisCacheWriter(factory);

// 创建默认缓存配置对象

/* 默认配置，设置缓存有效期 1小时*/

//RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofHours(1));

/* 自定义配置test:demo 的超时时间为 5分钟*/

RedisCacheManager cacheManager = RedisCacheManager.builder(RedisCacheWriter.lockingRedisCacheWriter(factory)).cacheDefaults(redisCacheConfiguration)

.withInitialCacheConfigurations(singletonMap(CacheConstant.TEST_DEMO_CACHE, RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(5)).disableCachingNullValues()))

.transactionAware().build();

return cacheManager;

}

}

这个redisconfig配置类我是直接搬过来了,本章内容只用到了其中的redisTemplate方法.

一般也都会有对应的一个redisUtil类，redisUtil里面的方法也都是基于上面的redisconfig中的方法，

此处省略redisUtil中方法介绍；

redis的使用简单点来说就是先将数据存入redis，用到的时候再直接从redis中取所需的数据。在此处我举个例子，

目前需要一个基础数据(比如产品信息)的所有信息，类型是List,也就是list实体,那么我就可以作如下操作:

先在productController中依赖注入RedisTemplate:

@Autowired

private RedisTemplate redisTemplate;

然后在该控制层的分页查询方法中将所有产品信息存入redis(也就是说,在产品信息页面加载的时候把所有数据存入redis,

当然,不局限于只加在这里):

@AutoLog(value = "产品-分页列表查询")

@ApiOperation(value="产品-分页列表查询", notes="产品-分页列表查询")

@GetMapping(value = "/list")

@TenantPermission

public Result> queryPageList(Product tProduct,

@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,

@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,

HttpServletRequest req) {

//使用Mybatisplus中QueryWrapper查询

QueryWrapper queryWrapper = QueryGenerator.initQueryWrapper(tProduct, req.getParameterMap());

queryWrapper.eq("del_flag","1");

Page page = new Page(pageNo, pageSize);

IPage pageList = tProductService.page(page, queryWrapper);

//判断一下是否有数据,这里的判断有点多余,但是由于没有数据并且不加判断直接使用会报错,所以这里加了一个判断

if (this.tProductService.list(queryWrapper).size()>0){

List productList = this.tProductService.list(queryWrapper);

//把数据存入redis,不同仓库之间数据先要清空

redisTemplate.delete("productList");

redisTemplate.opsForList().rightPushAll("productList",productList);

}else{

redisTemplate.delete("productList");

}

return Result.ok(pageList);

}

在这里我是先用redisTemplate.delete方法删除缓存,再把查出的数据存入redis,因为所做系统

涉及到不同租户看到不同数据,所以查出数据的不同也会导致redis中数据不一样.这样下来,向redis中存数据算是完成了.

接下来,从redis中取数据:

因为我存入redis的数据类型是list,所以就用该类型接收,

List redisProductList = redisTemplate.boundListOps("productList").range(0,-1);

这里.range(0,-1)就是取所有数据,当然,如果只取前十条数据也可以写成.range(0,10),写成-1就是取所有.

本章内容是基于配置好的redis的存取数据,这里只是介绍了存取集合类型的数据,如果要存取其他类型可以看下底层方法.