SpringBoot构建微服务实战之整合Redis

àì夳堔傛蜴生んèń 2022-05-25 06:18 190阅读 0赞

## 前言 ##

本节我们将学习一下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。
    
        
        <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 拉起来。**

--------------------