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的存取數據,這里只是介紹了存取集合類型的數據,如果要存取其他類型可以看下底層方法.