SpringBootRedis集成配置详解

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

站在用户的角度思考问题，与客户深入沟通，找到廉江网站设计与廉江网站推广的解决方案，凭借多年的经验，让设计与互联网技术结合，创造个性化、用户体验好的作品，建站类型包括：成都网站制作、做网站、外贸营销网站建设、企业官网、英文网站、手机端网站、网站推广、域名注册、雅安服务器托管、企业邮箱。业务覆盖廉江地区。

一、添加pom依赖

    
      org.springframework.boot
      spring-boot-starter-redis

二、创建 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() {
        @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() {
      @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() {
      @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() {
      @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() {
      @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 redisTemplete(String key, RedisExecute 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 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 redisTemplate(JedisConnectionFactory factory) {
    RedisTemplate template = new RedisTemplate();
    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 {

  private Converter serializer = new SerializingConverter();
  private Converter 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 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 了。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持创新互联。
            
            
                        

            新闻名称：SpringBootRedis集成配置详解            

            新闻来源：http://scjbc.cn/article/ppgsci.html
        
    
    

        
其他资讯

        
    




    

        

            
            

                
 联系小谭 

                
 

          企业微信号 

            

        

        
 

        

            友情链接：
            重庆移动机房托管   主机租用   定制网站设计   营销推广   西信服务器托管   德阳服务器托管   成都网站维护   成都响应式网站建设   成都画册设计   温江做网站公司           

        

        123ABC 成都网站建设，成都定制网站建设——全心全意建网站公司