SpringBoot整合redis

bootstrap.yml配置中在spring：下一层添加

配置redis服务器的IP端口以及连接池的参数设置

redis:
    host: 10.15.255.15
    port: 6379
    database: 5
    lettuce:
      pool:
        max-active: 1024
        max-wait: -1
        max-idle: 50
        min-idle: 0

pom.xml配置中加入maven依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
	<exclusions>
		<!--表示不适用lettuce而用下面的Jeids代替-->
		<exclusion>
			<groupId>io.lettuce</groupId>
			<artifactId>lettuce-core</artifactId>
		</exclusion>
	</exclusions>
</dependency>
<!--Jedis客户端-->
<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
</dependency>

RedisTemplate

• 是什么？  Spring封装了RedisTemplate对象来进行对Redis的各种操作，它支持所有的Redis原生的api。RedisTemplate位于spring-data-redis包下。RedisTemplate提供了redis各种操作、异常处理及序列化，支持发布订阅。
• 怎么用？编写RedisConfig配置类，配置

@Configuration
@EnableCaching
public class RedisConfig {

    @Bean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        final RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
        template.setConnectionFactory(connectionFactory);
        //设置key和value的序列化规则
        template.setValueSerializer(new GenericToStringSerializer<String>(String.class));
        template.setKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }
}

• 封装redis的基本操作类

@Service
public class RedisBase {

    /**
     * redisTemplate
     */
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 删除缓存
     * 根据key精确匹配删除
     * 
     * @param key key
     */
    public void deleteKey(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * 取得缓存（字符串类型）
     * 
     * @param key key
     * @return String
     */
    public String getString(String key) {
        final String value = (String) redisTemplate.boundValueOps(key).get();
        return value;
    }

    /**
     * 将value字符串对象写入缓存
     * 
     * @param key key
     * @param value value
     */
    public void setString(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 将value对象写入缓存
     * 
     * @param key key
     * @param value value
     */
    public void set(String key, Object value) {
        if (value.getClass().equals(String.class)) {
            redisTemplate.opsForValue().set(key, value.toString());
        }

    }

    /**
     * 指定缓存的失效时间
     * 
     * @param key key
     * @param timeout timeout
     *            失效时间(秒)
     */
    public void expire(String key, long timeout) {
        if (timeout > 0) {
            redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
        }
    }

    /**
     * 获取过期时间
     * @param key
     * @return
     */
    public Long getExpire(String key) {
        return redisTemplate.boundValueOps(key).getExpire();
    }

    /**
     * 模糊查询keys
     * 
     * @param pattern pattern
     * @return set
     */
    public Set<String> keys(String pattern) {
        return redisTemplate.keys(pattern);
    }

    /**
     * 计数器
     * 
     * @param key key
     */
    public void increment(String key) {
        redisTemplate.opsForValue().increment(key, 1);
    }

    /**
     * 可设置步长计数器
     * @param key
     * @param step
     */
    public Long increment(String key, Long step) {
        return redisTemplate.opsForValue().increment(key, step);
    }

    /**
     * 首次设置返回true
     * @param key
     * @param value
     * @return
     */
    public Boolean setIfAbsent(String key, Object value) {
        return redisTemplate.opsForValue().setIfAbsent(key, value);
    }

    /**
     * 批量设置hash键值对
     * @param key
     * @param dataMap
     */
    public void putAll(String key, Map<Object, Object> dataMap) {
        redisTemplate.boundHashOps(key).putAll(dataMap);
    }

    /**
     * 设置hash键值对
     * @param key
     * @param hkey
     * @param hval
     */
    public void put(String key, Object hkey, Object hval) {
        redisTemplate.boundHashOps(key).put(hkey, hval);
    }

    /**
     * 获取单个hash键值对的值
     * @param key
     * @param hkey
     * @return
     */
    public Object get(String key, Object hkey) {
        return redisTemplate.boundHashOps(key).get(hkey);
    }

    /**
     * 批量获取hash键值对得值
     * @param key
     * @param keys
     * @return
     */
    public List<Object> multiGet(String key, List<String> keys) {
        return redisTemplate.boundHashOps(key).multiGet(Collections.singleton(keys));
    }

    /**
     * 获取hash单个键值对
     * @param key
     * @return
     */
    public Map<Object, Object> entries(String key) {
        return redisTemplate.boundHashOps(key).entries();
    }

}

然后编写启动服务，编写测试类。