前言

本節我們將學習一下SpringBoot 如何整合單機版Redis

概述

首先我得陳述一下，本節學習的SpringBoot 整合R單機版Redis總共有如下步驟。

• SpringBoot 初步整合 Spring-data-redis
  首先我們應該知道 Spring-data-redis 已近提供了對Redis很好應用的API，因而SpringBoot 整合 Redis實際上就是SpringBoot整合 Spring-data-redis

• Spring-data-redis的序列化
  我們在使用Spring-data-redis 封裝好了redisTemplate時，可能會出現如下亂碼：

  127.0.0.1:6379> keys *
  1) "\xac\xed\x00\x05t\x00#ContentPlatform2:ES:UpSertESContent"
  2) "\xac\xed\x00\x05t\x00%ContentPlatform2:Lock_v16:CJH_ARTICLE"
  3) "\xac\xed\x00\x05t\x00!ContentPlatform2:Lock_v16:V_VIDEO"
  4) "\xac\xed\x00\x05t\x00\x1bContentPlatform2:ES:Content"
  5) "\xac\xed\x00\x05t\x00#ContentPlatform2:Lock_v16:CJH_VIDEO"
  6) "\xac
   
  \xed\x00\x05t\x00%ContentPlatform2:Lock_v16:CMS_ARTICLE"

  原因是：spring-data-redis的RedisTemplate《K,V》模板類在操作redis時預設使用JdkSerializationRedisSerializer來進行序列，另外在一些需要Redis 儲存java 物件時我們也希望Redis能支援JAVA物件的快速儲存。因而在初步整合Redis之後我們需要重新自定義Redis的 SerializationRedisSerializer。

• Spring-data-redis的 redisTemplate二次定義
  首先我們應該知道Spring-data-redis 已經為我們封裝好了redisTemplate，使用預設的redistemplate 我們就能操作redis nosql 了，可是在實際的需求和場景中，我們應該重新自定義redisTemplate以滿足我們特定的需求。

整合Spring-data-redis

• 引入依賴
  SpringBoot 總的編碼風格是：約定>配置>編碼。因而SpringBoot在整合Spring-data-redis時也做了很多預設自動配置。總的來說我們只需要在pom中引入如下引用變可以直接使用redisTemplate 來操作Redis nosql。

  <!-- SpringBoot-Redis -->
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>

• SpringBoot測試redis
  引入依賴之後便可以直接使用redisTemplate 來操作Redis Nosql了

  import javax.annotation.Resource;
  
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.springframework.boot.test.context.SpringBootTest;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  import org.springframework.test.context.web.WebAppConfiguration;
  
  import com.alibaba.fastjson.JSON;
  import com.alibaba.fastjson.JSONObject;
  import com.impact.ImpactApplication;
  import com.impact.framework.redis.vo.RedisVo;
  @SpringBootTest(classes = ImpactApplication.class)
  @RunWith(SpringJUnit4ClassRunner.class)
  @WebAppConfiguration
  public class TestRedis {
      @Resource
      //private StringRedisTemplate  strRedisTemplate;
      private RedisTemplate<String, Object>  redisTemplate;
  
      @Test
      public void testSet() {
          RedisVo vo = new RedisVo() ;
          vo.setMid("studyjava");
          vo.setAge(19);
          this.redisTemplate.opsForValue().set("study", vo);
          System.out.println((JSON) JSONObject.toJSON(this.redisTemplate.opsForValue().get("study")));
      }
  }

Spring-data-redis的序列化

關於 Spring-data-redis的序列化我們來學習一下 spring-data-redis序列化策略。
spring-data-redis提供了多種serializer策略，這對使用jedis的開發者而言，實在是非常便捷。sdr提供了4種內建的serializer：

• JdkSerializationRedisSerializer：使用JDK的序列化手段(serializable介面，ObjectInputStrean，ObjectOutputStream)，資料以位元組流儲存，jdk序列化和反序列化資料
• StringRedisSerializer：字串編碼，資料以string儲存
• JacksonJsonRedisSerializer：json格式儲存
• OxmSerializer：xml格式儲存

其中JdkSerializationRedisSerializer和StringRedisSerializer是最基礎的序列化策略，其中“JacksonJsonRedisSerializer”與“OxmSerializer”都是基於stirng儲存，因此它們是較為“高階”的序列化(最終還是使用string解析以及構建java物件)。

RedisTemplate中需要宣告4種serializer，預設為“JdkSerializationRedisSerializer”：

• keySerializer ：對於普通K-V操作時，key採取的序列化策略
• valueSerializer：value採取的序列化策略
• hashKeySerializer： 在hash資料結構中，hash-key的序列化策略
• hashValueSerializer：hash-value的序列化策略

無論如何，建議key/hashKey採用StringRedisSerializer

下面我們將著重學習一下 JacksonJsonRedisSerializer

• 新建 RedisConfig.java

  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.data.redis.connection.RedisConnectionFactory;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  import org.springframework.data.redis.serializer.StringRedisSerializer;
  
  import com.fasterxml.jackson.annotation.JsonAutoDetect;
  import com.fasterxml.jackson.annotation.PropertyAccessor;
  import com.fasterxml.jackson.databind.ObjectMapper;
  
  @Configuration
  public class RedisConfig {
  
       /**
       * redisTemplate 序列化使用的jdkSerializeable, 儲存二進位制位元組碼, 所以自定義序列化類
       * @param redisConnectionFactory
       * @return
       */
      @Bean
      public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
          RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
          redisTemplate.setConnectionFactory(redisConnectionFactory);
  
          // 使用Jackson2JsonRedisSerialize 替換預設序列化
          Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
  
          ObjectMapper objectMapper = new ObjectMapper();
          objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
          objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  
          jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
  
          // 設定value的序列化規則和 key的序列化規則
          redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
          redisTemplate.setKeySerializer(new StringRedisSerializer());
          redisTemplate.afterPropertiesSet();
          return redisTemplate;
      }

  此時便重新定義了Redis的serializer 呼叫時只需在呼叫類中引用RedisTemplate Bean即可

  @Resource
  private RedisTemplate<String, Object> redisTemplate;

RedisTemplate Re-definition

關於RedisTemplate的重新定義，首先我們要清楚自己的需求，源生的RedisTemplate是否能滿足我的需求，重新定義並不代表源生的就很LOW，在需求面前只有高效和更高效一說。

• 定義重定義redisTemplate介面

  import java.util.List;
  
  /**
   * 二次封裝 RedisTemplate Interface
   * 以後根據需要可重新自定義
   * @author Dustyone
   *  * ImpactInit
   */
  public interface RedisService {
      /**
       * PUT K-V
       * @param key
       * @param value
       * @return
       */
      public boolean set(String key, String value);
  
      /**
       * Get Object By Key
       * @param key
       * @return
       */
      public Object get(String key);
  
      /**
       * Setting key expire Time
       * 以秒為單位
       * @param key
       * @param expire
       * @return
       */
      public boolean expire(String key, long expire);
  
      /**
       * PUT K-LIST
       * @param key
       * @param list
       * @return
       */
      public <T> boolean setList(String key, List<T> list);
  
      /**
       * GET K-LIST
       * @param key
       * @param clz
       * @return
       */
      public <T> List<T> getList(String key, Class<T> clz);
  
      /**
       * 將所有指定的值插入到存於 key 的列表的頭部
       * PUT K-O
       * @param key
       * @param obj
       * @return
       */
      public long setObject(String key, Object obj);
  
      /**
       * 重複新增指定Key中的指定元素
       * @param key
       * @param obj
       * @return
       */
      public long getObject(String key, Object obj);
  
  }

  更多的方法可以自己去定義，這裡就需要對Redis的一些基本命令要了解了。

• 實現介面

  import java.util.List;
  import java.util.concurrent.TimeUnit;
  
  import javax.annotation.Resource;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.stereotype.Service;
  
  import com.impact.framework.redis.template.RedisService;
  
  /**
   * RedisTemplate的二次封裝實現方法
   * @author Dustyone
   *
   */
  @Service
  public class RedisServiceImpl implements RedisService {
  
      private static final Logger log = LoggerFactory.getLogger(RedisServiceImpl.class);
  
      //引入 Spring封裝好了的RedisTemplate
      @Resource
      private RedisTemplate<String, Object> redisTemplate;
  
      @Override
      public boolean set(String key, String value) {
          boolean flag = false;
          try {
              this.redisTemplate.opsForValue().set(key, value);
              flag = this.redisTemplate.opsForValue().get(key) == null
                      || "".equals(this.redisTemplate.opsForValue().get(key)) ? false : true;
          } catch (Exception e) {
              log.error(e.getMessage());
              e.printStackTrace();
          }
          return flag;
      }
  
      @Override
      public Object get(String key) {
          Object retsult = null;
          try {
              retsult = this.redisTemplate.opsForValue().get(key);
          } catch (Exception e) {
              log.error(e.getMessage());
              e.printStackTrace();
          }
          return retsult;
      }
  
      @Override
      public boolean expire(String key, long expire) {
          boolean flag = false;
          try {
              flag = redisTemplate.expire(key, expire, TimeUnit.SECONDS);
          } catch (Exception e) {
              log.error(e.getMessage());
              e.printStackTrace();
          }
          return flag;
      }
  
      @Override
      public <T> boolean setList(String key, List<T> list) {
          return false;
      }
  
      @Override
      public <T> List<T> getList(String key, Class<T> clz) {
          // TODO Auto-generated method stub
          return null;
      }
  
      @Override
      public long setObject(String key, Object obj) {
          long ret = -1;
          try {
              this.redisTemplate.opsForValue().set(key, obj);
              ret = this.redisTemplate.opsForValue().get(key) == null
                      || "".equals(this.redisTemplate.opsForValue().get(key)) ? -1 : 1;
          } catch (Exception e) {
              log.error(e.getMessage());
              e.printStackTrace();
          }
          return ret;
      }
  
      @Override
      public long getObject(String key, Object obj) {
          // TODO Auto-generated method stub
          return 0;
      }
  
  }

  實現方法我們也可以靈活的定義。

• Controller測試

  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.ResponseBody;
  
  import com.alibaba.druid.support.json.JSONUtils;
  import com.alibaba.fastjson.JSON;
  import com.alibaba.fastjson.JSONObject;
  import com.impact.framework.redis.template.service.RedisServiceImpl;
  import com.impact.framework.redis.vo.RedisVo;
  
  @Controller
  @RequestMapping("/redis")
  public class RedisController {
  
      @Autowired
      private RedisServiceImpl redisServiceImpl;
  
      @GetMapping("addStr")
      @ResponseBody
      public String addRedisKV(){
          boolean flag = false;
          try {
              flag = redisServiceImpl.set("RedisKey", "RedisValue");
          } catch (Exception e) {
              e.printStackTrace();
          }
          return "儲存K-V狀況: "+flag;
      }
  
      @GetMapping("addObj")
      @ResponseBody
      public void addRedisObject(){
          JSONObject obj = new JSONObject();
          try {
              RedisVo vo = new RedisVo("Redis",185);
              redisServiceImpl.setObject("RedisVO1", vo);
  
              obj.put("vo", (JSON) JSONObject.toJSON(redisServiceImpl.get("RedisVO1")));
          } catch (Exception e) {
              e.printStackTrace();
          }
  
          JSONUtils.toJSONString(obj);
      }
  
      @GetMapping("/getObj/{key}")
      @ResponseBody
      public Object getObjectBuKey(@PathVariable("key") String key){
          Object result = null;
          try {
              result  = redisServiceImpl.get(key);
          } catch (Exception e) {
              e.printStackTrace();
          }
          return result;
      }
  }

  當然在測試之前我們需要把Redis的Service 拉起來。