Spring Boot Redis 集成配置详解

 更新时间:2017年05月13日 16:56:18   作者:catoop   我要评论
本篇文章主要介绍了Spring Boot Redis 集成配置详解,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧

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

一、添加pom依赖

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

二、创建 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);
  }
}

三、创建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);
  }
}

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)
 * @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";
  }

五、配置文件配置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

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

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持澳门金沙网上娱乐。

相关文章

  • Java实现的串口通信功能示例

    Java实现的串口通信功能示例

    这篇文章主要介绍了Java实现的串口通信功能,结合实例形式分析了java串口通信的具体操作步骤与相关注意事项,需要的朋友可以参考下
    2018-01-01
  • 解析Java实现随机验证码功能的方法详解

    解析Java实现随机验证码功能的方法详解

    本篇文章是对Java实现随机验证码功能的方法进行了详细的分析介绍,需要的朋友参考下
    2013-05-05
  • 安装多个版本JDK后使用时的切换方法总结

    安装多个版本JDK后使用时的切换方法总结

    我们平时在window上做开发的时候,可能需要同时开发两个甚至多个项目,有时不同的项目对JDK的版本要求有区别,下面这篇文章主要给大家介绍了安装多个版本JDK后使用的切换方法,需要的朋友可以参考借鉴,下面来一起看看吧。
    2017-01-01
  • SpringCloud Edgware.SR3版本中Ribbon的timeout设置方法

    SpringCloud Edgware.SR3版本中Ribbon的timeout设置方法

    今天小编就为大家分享一篇关于SpringCloud Edgware.SR3版本中Ribbon的timeout设置方法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
    2018-12-12
  • Java自定义注解的详解

    Java自定义注解的详解

    这篇文章主要介绍了Java自定义注解的详解的相关资料,Java注解提供了关于代码的一些信息,但并不直接作用于它所注解的代码内容,需要的朋友可以参考下
    2017-08-08
  • OpenCV Java实现人脸识别和裁剪功能

    OpenCV Java实现人脸识别和裁剪功能

    这篇文章主要为大家详细介绍了OpenCV Java实现人脸识别和裁剪功能,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2019-05-05
  • Spring RestTemplate具体使用详解

    Spring RestTemplate具体使用详解

    这篇文章主要介绍了Spring RestTemplate具体使用详解,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2019-04-04
  • Java中Set与List的关系与区别介绍

    Java中Set与List的关系与区别介绍

    这篇文章主要介绍了Java中Set与List的关系与区别介绍,本文总结它们两个接口都是继承自Collection、它们之间的存储方式不一样,需要的朋友可以参考下
    2015-03-03
  • java微信公众号开发第一步 公众号接入和access_token管理

    java微信公众号开发第一步 公众号接入和access_token管理

    这篇文章主要为大家介绍了java微信公众号开发,主要内容包括公众号接入和access_token管理,感兴趣的小伙伴们可以参考一下
    2016-01-01
  • Java 文件上传的实例详解

    Java 文件上传的实例详解

    这篇文章主要介绍了Java 文件上传的实例详解的相关资料,希望通过本文大家能掌握这部分内容,使用几种文件上传的方法,需要的朋友可以参考下
    2017-09-09

最新评论