java中如何在redis中如何建立文件夹 java往redis里写数据

简单的使用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即可</br>
//  * @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<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
      // 设置序列化
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, Visibility.ANY);
    om.enableDefaultTyping(DefaultTyping.NON_FINAL);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    // 配置redisTemplate
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
    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<product>,也就是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<Product> queryWrapper = QueryGenerator.initQueryWrapper(tProduct, req.getParameterMap());
   queryWrapper.eq("del_flag","1");
   Page<Product> page = new Page<Product>(pageNo, pageSize);
   IPage<Product> pageList = tProductService.page(page, queryWrapper);
　　//判断一下是否有数据,这里的判断有点多余,但是由于没有数据并且不加判断直接使用会报错,所以这里加了一个判断
   if (this.tProductService.list(queryWrapper).size()>0){
      List<Product> 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<product>,所以就用该类型接收,

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

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

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