咨询热线 ：
028-86922220
×
01
关于我们

公司简介

发展历程

02
服务项目

高端网站建设

微信开发

APP开发

网络营销服务

电商网站定制

生物医药网站建设

外贸网站建设

教育培训网站建设

03
小程序开发

小程序开发

功能应用

客户案例

04
案例展示

网站建设案例

小程序案例

电商平台案例

APP案例

系统平台案例

05
建站动态

网站建设

网站设计

常见问题

小程序

06
联系我们

公司地址

人才招聘

地址：成都市太升南路288号锦天国际A幢1002号

电话：028-86922220

028-86922220

重庆分公司，新征程启航

为企业提供网站建设、域名注册、服务器等服务

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://cqcxhl.com/article/ppgsci.html
        
    
    

        
其他资讯

        
    




    

        

            

                

                

                    
分享至：

                    

                        
                        
                        
                        
                    

                    
                

            

            

                

                    
关于我们

                    

                        公司简介
                        发展历程
                    

                

                

                    
服务项目

                    

                        高端网站建设
                        小程序开发
                        APP开发
                        网络营销
                    

                

                

                    
建站知识

                    

                        网站建设
                        网站设计
                        网站制作
                        小程序
                    

                

                

                    
联系我们

                    

                        公司地址
                        人才招聘
                    

                

            

            

                

                    成都
                    重庆
                

                

                    

                        

                            

                            
电话：028-86922220

                        

                        

                            

                            
地址：成都市太升南路288号锦天国际A幢1002号

                        

                    

                    

                        

                            

                            
电话：028-86922220

                        

                        

                            

                            
地址：重庆市南岸区弹子石腾龙大道58号2栋21-6

                        

                    

                

            

        

    

    
版权所有：成都创新互联科技有限公司重庆分公司
        渝ICP备2021005571号-4
    







    
        

            

            
在线咨询

        

    
    
        

            

            
服务热线

        

        
服务热线：028-86922220

    
    
        

            

            
TOP