Spring Boot Redis 集成配置

Myth丶恋晨 2024-02-18 20:36 9阅读 0赞

Spring Boot 熟悉后，集成一个外部扩展是一件很容易的事，集成Redis也很简单，看下面步骤配置：

#### 一、添加pom依赖 ####

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-redis</artifactId>
            </dependency>

*  1
 *  2
 *  3
 *  4

#### 二、创建 RedisClient.java ####

注意该类存放的package

package org.springframework.data.redis.connection.jedis;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.UnsupportedEncodingException;
    
    import org.apache.commons.lang3.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.Protocol;
    import redis.clients.jedis.exceptions.JedisException;
    
    /**
     * 工具类 RedisClient
     * 因为本类中获取JedisPool调用的是JedisConnectionFactory中protected修饰的方法fetchJedisConnector()
     * 所以该类需要与JedisConnectionFactory在同一个package中
     *
     * @author 单红宇(CSDN CATOOP)
     * @create 2017年4月9日
     */
    public class RedisClient {
        
    
        private static Logger logger = LoggerFactory.getLogger(RedisClient.class);
    
        private JedisConnectionFactory factory;
    
        public RedisClient(JedisConnectionFactory factory) {
            super();
            this.factory = factory;
        }
    
        /**
         * put操作（存储序列化对象）+ 生效时间
         * 
         * @param key
         * @param value
         * @return
         */
        public void putObject(final String key, final Object value, final int cacheSeconds) {
            if (StringUtils.isNotBlank(key)) {
                redisTemplete(key, new RedisExecute<Object>() {
                    @Override
                    public Object doInvoker(Jedis jedis) {
                        try {
                            jedis.setex(key.getBytes(Protocol.CHARSET), cacheSeconds, serialize(value));
                        } catch (UnsupportedEncodingException e) {
                        }
    
                        return null;
                    }
                });
            }
        }
    
        /**
         * get操作（获取序列化对象）
         * 
         * @param key
         * @return
         */
        public Object getObject(final String key) {
            return redisTemplete(key, new RedisExecute<Object>() {
                @Override
                public Object doInvoker(Jedis jedis) {
                    try {
                        byte[] byteKey = key.getBytes(Protocol.CHARSET);
                        byte[] byteValue = jedis.get(byteKey);
                        if (byteValue != null) {
                            return deserialize(byteValue);
                        }
                    } catch (UnsupportedEncodingException e) {
                        return null;
                    }
                    return null;
                }
            });
        }
    
        /**
         * setex操作
         * 
         * @param key
         *            键
         * @param value
         *            值
         * @param cacheSeconds
         *            超时时间，0为不超时
         * @return
         */
        public String set(final String key, final String value, final int cacheSeconds) {
            return redisTemplete(key, new RedisExecute<String>() {
                @Override
                public String doInvoker(Jedis jedis) {
                    if (cacheSeconds == 0) {
                        return jedis.set(key, value);
                    }
                    return jedis.setex(key, cacheSeconds, value);
                }
            });
        }
    
        /**
         * get操作
         * 
         * @param key
         *            键
         * @return 值
         */
        public String get(final String key) {
            return redisTemplete(key, new RedisExecute<String>() {
                @Override
                public String doInvoker(Jedis jedis) {
                    String value = jedis.get(key);
                    return StringUtils.isNotBlank(value) && !"nil".equalsIgnoreCase(value) ? value : null;
                }
            });
        }
    
        /**
         * del操作
         * 
         * @param key
         *            键
         * @return
         */
        public long del(final String key) {
            return redisTemplete(key, new RedisExecute<Long>() {
                @Override
                public Long doInvoker(Jedis jedis) {
                    return jedis.del(key);
                }
            });
        }
    
        /**
         * 获取资源
         * 
         * @return
         * @throws JedisException
         */
        public Jedis getResource() throws JedisException {
            Jedis jedis = null;
            try {
                jedis = factory.fetchJedisConnector();
            } catch (JedisException e) {
                logger.error("getResource.", e);
                returnBrokenResource(jedis);
                throw e;
            }
            return jedis;
        }
    
        /**
         * 获取资源
         * 
         * @return
         * @throws JedisException
         */
        public Jedis getJedis() throws JedisException {
            return getResource();
        }
    
        /**
         * 归还资源
         * 
         * @param jedis
         * @param isBroken
         */
        public void returnBrokenResource(Jedis jedis) {
            if (jedis != null) {
                jedis.close();
            }
        }
    
        /**
         * 释放资源
         * 
         * @param jedis
         * @param isBroken
         */
        public void returnResource(Jedis jedis) {
            if (jedis != null) {
                jedis.close();
            }
        }
    
        /**
         * 操作jedis客户端模板
         * 
         * @param key
         * @param execute
         * @return
         */
        public <R> R redisTemplete(String key, RedisExecute<R> execute) {
            Jedis jedis = null;
            try {
                jedis = getResource();
                if (jedis == null) {
                    return null;
                }
    
                return execute.doInvoker(jedis);
            } catch (Exception e) {
                logger.error("operator redis api fail,{}", key, e);
            } finally {
                returnResource(jedis);
            }
            return null;
        }
    
        /**
         * 功能简述: 对实体Bean进行序列化操作.
         * 
         * @param source
         *            待转换的实体
         * @return 转换之后的字节数组
         * @throws Exception
         */
        public static byte[] serialize(Object source) {
            ByteArrayOutputStream byteOut = null;
            ObjectOutputStream ObjOut = null;
            try {
                byteOut = new ByteArrayOutputStream();
                ObjOut = new ObjectOutputStream(byteOut);
                ObjOut.writeObject(source);
                ObjOut.flush();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (null != ObjOut) {
                        ObjOut.close();
                    }
                } catch (IOException e) {
                    ObjOut = null;
                }
            }
            return byteOut.toByteArray();
        }
    
        /**
         * 功能简述: 将字节数组反序列化为实体Bean.
         * 
         * @param source
         *            需要进行反序列化的字节数组
         * @return 反序列化后的实体Bean
         * @throws Exception
         */
        public static Object deserialize(byte[] source) {
            ObjectInputStream ObjIn = null;
            Object retVal = null;
            try {
                ByteArrayInputStream byteIn = new ByteArrayInputStream(source);
                ObjIn = new ObjectInputStream(byteIn);
                retVal = ObjIn.readObject();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if (null != ObjIn) {
                        ObjIn.close();
                    }
                } catch (IOException e) {
                    ObjIn = null;
                }
            }
            return retVal;
        }
    
        interface RedisExecute<T> {
            T doInvoker(Jedis jedis);
        }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53
 *  54
 *  55
 *  56
 *  57
 *  58
 *  59
 *  60
 *  61
 *  62
 *  63
 *  64
 *  65
 *  66
 *  67
 *  68
 *  69
 *  70
 *  71
 *  72
 *  73
 *  74
 *  75
 *  76
 *  77
 *  78
 *  79
 *  80
 *  81
 *  82
 *  83
 *  84
 *  85
 *  86
 *  87
 *  88
 *  89
 *  90
 *  91
 *  92
 *  93
 *  94
 *  95
 *  96
 *  97
 *  98
 *  99
 *  100
 *  101
 *  102
 *  103
 *  104
 *  105
 *  106
 *  107
 *  108
 *  109
 *  110
 *  111
 *  112
 *  113
 *  114
 *  115
 *  116
 *  117
 *  118
 *  119
 *  120
 *  121
 *  122
 *  123
 *  124
 *  125
 *  126
 *  127
 *  128
 *  129
 *  130
 *  131
 *  132
 *  133
 *  134
 *  135
 *  136
 *  137
 *  138
 *  139
 *  140
 *  141
 *  142
 *  143
 *  144
 *  145
 *  146
 *  147
 *  148
 *  149
 *  150
 *  151
 *  152
 *  153
 *  154
 *  155
 *  156
 *  157
 *  158
 *  159
 *  160
 *  161
 *  162
 *  163
 *  164
 *  165
 *  166
 *  167
 *  168
 *  169
 *  170
 *  171
 *  172
 *  173
 *  174
 *  175
 *  176
 *  177
 *  178
 *  179
 *  180
 *  181
 *  182
 *  183
 *  184
 *  185
 *  186
 *  187
 *  188
 *  189
 *  190
 *  191
 *  192
 *  193
 *  194
 *  195
 *  196
 *  197
 *  198
 *  199
 *  200
 *  201
 *  202
 *  203
 *  204
 *  205
 *  206
 *  207
 *  208
 *  209
 *  210
 *  211
 *  212
 *  213
 *  214
 *  215
 *  216
 *  217
 *  218
 *  219
 *  220
 *  221
 *  222
 *  223
 *  224
 *  225
 *  226
 *  227
 *  228
 *  229
 *  230
 *  231
 *  232
 *  233
 *  234
 *  235
 *  236
 *  237
 *  238
 *  239
 *  240
 *  241
 *  242
 *  243
 *  244
 *  245
 *  246
 *  247
 *  248
 *  249
 *  250
 *  251
 *  252
 *  253
 *  254
 *  255
 *  256
 *  257
 *  258
 *  259
 *  260
 *  261
 *  262
 *  263
 *  264
 *  265
 *  266
 *  267
 *  268
 *  269
 *  270
 *  271
 *  272
 *  273
 *  274
 *  275
 *  276
 *  277
 *  278
 *  279

#### 三、创建Redis配置类 ####

RedisConfig.java

package com.shanhy.example.redis;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    import org.springframework.data.redis.connection.jedis.RedisClient;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    /**
     * Redis配置
     * 
     * @author 单红宇(CSDN catoop)
     * @create 2016年9月12日
     */
    @Configuration
    public class RedisConfig {
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) {
            RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
            template.setConnectionFactory(factory);
            template.setKeySerializer(new StringRedisSerializer());
            template.setValueSerializer(new RedisObjectSerializer());
            template.afterPropertiesSet();
            return template;
        }
    
        @Bean
        public RedisClient redisClient(JedisConnectionFactory factory){
            return new RedisClient(factory);
        }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34

RedisObjectSerializer.java

package com.shanhy.example.redis;
    
    import org.springframework.core.convert.converter.Converter;
    import org.springframework.core.serializer.support.DeserializingConverter;
    import org.springframework.core.serializer.support.SerializingConverter;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.SerializationException;
    
    /**
     * 实现对象的序列化接口
     * @author   单红宇(365384722)
     * @myblog  http://blog.csdn.net/catoop/
     * @create    2017年4月9日
     */
    public class RedisObjectSerializer implements RedisSerializer<Object> {
    
        private Converter<Object, byte[]> serializer = new SerializingConverter();
        private Converter<byte[], Object> deserializer = new DeserializingConverter();
    
        static final byte[] EMPTY_ARRAY = new byte[0];
    
        @Override
        public Object deserialize(byte[] bytes) {
            if (isEmpty(bytes)) {
                return null;
            }
    
            try {
                return deserializer.convert(bytes);
            } catch (Exception ex) {
                throw new SerializationException("Cannot deserialize", ex);
            }
        }
    
        @Override
        public byte[] serialize(Object object) {
            if (object == null) {
                return EMPTY_ARRAY;
            }
    
            try {
                return serializer.convert(object);
            } catch (Exception ex) {
                return EMPTY_ARRAY;
            }
        }
    
        private boolean isEmpty(byte[] data) {
            return (data == null || data.length == 0);
        }
    
    }

#### 四、创建测试方法 ####

下面代码随便放一个Controller里

@Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
        /**
         * 缓存测试
         *
         * @return
         * @author  SHANHY
         * @create  2016年9月12日
         */
        @RequestMapping("/redisTest")
        public String redisTest() {
            try {
                redisTemplate.opsForValue().set("test-key", "redis测试内容", 2, TimeUnit.SECONDS);// 缓存有效期2秒
    
                logger.info("从Redis中读取数据：" + redisTemplate.opsForValue().get("test-key").toString());
    
                TimeUnit.SECONDS.sleep(3);
    
                logger.info("等待3秒后尝试读取过期的数据：" + redisTemplate.opsForValue().get("test-key"));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            return "OK";
        }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26

#### 五、配置文件配置Redis ####

application.yml

spring:
      # Redis配置
      redis:
        host: 192.168.1.101
        port: 6379
        password:
        # 连接超时时间（毫秒）
        timeout: 10000
        pool:
          max-idle: 20
          min-idle: 5
          max-active: 20
          max-wait: 2

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13

这样就完成了Redis的配置，可以正常使用 redisTemplate 了。