SpringBoot集成redis依赖包及步骤

redis作为nosql数据库，通常用于缓存，加锁和分布式缓存等，特地学习了如何融入SpringBoot

1、在maven中引入spring-boot-starter-data-redis包

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

		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-pool2</artifactId>
		</dependency>

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.47</version>
		</dependency>

		<!--huTool工具-->
		<dependency>
			<groupId>cn.hutool</groupId>
			<artifactId>hutool-all</artifactId>
			<version>5.8.5</version>
		</dependency>

2、配置文件中的redis连接设置 

映射的是org.springframework.boot.autoconfigure.data.redis.RedisProperties

中的属性

集群：

spring.redis.password=123456
spring.redis.cluster.nodes=10.193.240.170:7000,10.193.241.0:7001 
spring.redis.cluster.max-redirects=3

单个实例：

 spring.redis.host=localhost # Redis服务器地址
 spring.redis.database=0  # Redis数据库索引（默认为0）
 spring.redis.port=6379 # Redis服务器连接端口
 spring.redis.password=123456 # Redis服务器连接密码（默认为空）
 spring.redis.timeout=300ms # 连接超时时间（毫秒）

3、redisTemplate配置类Config

@Configuration
@Slf4j
public class RedisTemplateConfig {

    @Autowired
    private RedisProperties redisProperties;

    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate stringRedisTemplate1(RedisConnectionFactory redisConnectionFactory) {
        String prefix = StrUtil.isBlank(redisProperties.getBizPrefix()) ? ""
                : redisProperties.getBizPrefix() + RedisConstants.BIZ_PREFIX_SPLIT;
        log.info("biz-prefix > {}", prefix);

        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        RedisSerializer<Object> redisSerializer = redisSerializer();
        // 值采用json序列化
        template.setValueSerializer(redisSerializer);
        template.setKeySerializer(new StringRedisSerializer(prefix));
        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer(prefix));
        template.setHashValueSerializer(redisSerializer);
        template.afterPropertiesSet();
        return template;
    }


    @Bean
    public RedisSerializer<Object> redisSerializer() {
        //创建JSON序列化器
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //必须设置，否则无法将JSON转化为对象，会转化成Map类型
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(objectMapper);
        return serializer;
    }


}

4、RedisProperties属性类

package com.example.data.redis.config.property;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Data
@Component
@ConfigurationProperties(prefix = "demo.redis")
public class RedisProperties {
    /**
     * 是否开启 true/false
     */
    private boolean enabled = true;

    /**
     * 业务标识前缀
     */
    private String bizPrefix;

}

5、在service注入

要注意这里RedisTemplate配置类config的返回泛型和注入的泛型要一致，不然会提示

 The following candidates were found but could not be injected:
    - Bean method 'stringRedisTemplate' in 'RedisAutoConfiguration' not loaded because @ConditionalOnMissingBean (types: org.springframework.data.redis.core.StringRedisTemplate; SearchStrategy: all) found beans of type 'org.springframework.data.redis.core.StringRedisTemplate' stringRedisTemplate

注入代码如下：

/**
 * redis操作service实现类
 */
@Service
public class RedisServiceImpl implements RedisService {

    @Autowired
    private RedisTemplate   redisTemplate;

    /**
     * 设置缓存
     * Params:
     * key – 缓存键 value – 缓存value expSec – 失效时间(秒)
     */
    @Override
    public void set(String key, Object value, long time) {
        redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    }

    /**
     * 设置缓存
     * @param key
     * @param value
     */
    @Override
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key,value);
    }

    /**
     * 获取缓存对象,返回string
     * Params:
     * key – 缓存键
     * Returns:
     * 返回缓存实体
     */
    @Override
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 删除缓存数据
     * Params:
     * @param key – 缓存键
     * @return
     */
    @Override
    public Boolean del(String key) {
        return redisTemplate.delete(key);
    }

    @Override
    public Long del(List<String> keys) {
        return redisTemplate.delete(keys);
    }

    /**
     * 指定缓存失效时间
     * Params:
     * key – 键 time – 时间(秒)
     * Returns:
     * true成功 false失败
     */
    @Override
    public Boolean expire(String key, long time) {
        return redisTemplate.expire(key,time,TimeUnit.SECONDS);
    }

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

    /**
     * 判断key是否存在
     * Params:
     * key – 键
     * Returns:
     * true 存在 false不存
     * @param key
     * @return
     */
    @Override
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 将键对应的值按指定步长增加
     * @param key
     * @param delta
     * @return
     */
    @Override
    public Long incr(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 将键对应的值按指定步长减少
     * @param key
     * @param delta
     * @return
     */
    @Override
    public Long decr(String key, long delta) {
        return redisTemplate.opsForValue().decrement(key, delta);
    }

    /**
     * 获取指定变量中的hashMap值
     * @param key
     * @param hashKey
     * @return
     */
    @Override
    public Object hGet(String key, String hashKey) {
        return redisTemplate.opsForHash().get(key, hashKey);
    }
    /**
     * 设置指定变量中的hashMap值，并设置过期时间
     * @param key
     * @param hashKey
     * @return
     */
    @Override
    public Boolean hSet(String key, String hashKey, Object value, long time) {
        redisTemplate.opsForHash().put(key, hashKey, value);
        return expire(key, time);
    }

    /**
     * 新增hashMap值
     * @param key
     * @param hashKey
     * @param value
     */
    @Override
    public void hSet(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }

    @Override
    public Map<Object, Object> hGetAll(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    @Override
    public Boolean hSetAll(String key, Map<String, Object> map, long time) {
        redisTemplate.opsForHash().putAll(key, map);
        return expire(key, time);
    }

    @Override
    public void hSetAll(String key, Map<String, ?> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }

    @Override
    public void hDel(String key, Object... hashKey) {
        redisTemplate.opsForHash().delete(key, hashKey);
    }

    @Override
    public Boolean hHasKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    @Override
    public Long hIncr(String key, String hashKey, Long delta) {
        return redisTemplate.opsForHash().increment(key,hashKey,delta);
    }

    @Override
    public Long hDecr(String key, String hashKey, Long delta) {
        return redisTemplate.opsForHash().increment(key, hashKey, -delta);
    }

    /**
     * 根据key获取set集合
     * @param key
     * @return
     */
    @Override
    public Set<Object> sMembers(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 添加key
     * @param key
     * @param values
     * @return
     */
    @Override
    public Long sAdd(String key, Object... values) {
        return redisTemplate.opsForSet().add(key, values);
    }

    @Override
    public Long sAdd(String key, long time, Object... values) {
        Long count = redisTemplate.opsForSet().add(key, values);
        expire(key, time);
        return count;
    }

    @Override
    public Boolean sIsMember(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key,value);
    }

    @Override
    public Long sSize(String key) {
        return redisTemplate.opsForSet().size(key);
    }

    @Override
    public Long sRemove(String key, Object... values) {
        return redisTemplate.opsForSet().remove(key,values);
    }

    @Override
    public List<Object> lRange(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    @Override
    public Long lSize(String key) {
        return redisTemplate.opsForList().size(key);
    }

    @Override
    public Object lIndex(String key, long index) {
        return redisTemplate.opsForList().index(key, index);
    }

    @Override
    public Long lPush(String key, Object value) {
        return redisTemplate.opsForList().rightPush(key, value);
    }

    @Override
    public Long lPush(String key, Object value, long time) {
        Long index = redisTemplate.opsForList().rightPush(key, value);
        expire(key, time);
        return index;
    }

    @Override
    public Long lPushAll(String key, Object... values) {
        return redisTemplate.opsForList().rightPushAll(key, values);
    }

    @Override
    public Long lPushAll(String key, Long time, Object... values) {
        Long count = redisTemplate.opsForList().rightPushAll(key, values);
        expire(key, time);
        return count;
    }

    @Override
    public Long lRemove(String key, long count, Object value) {
        return redisTemplate.opsForList().remove(key, count, value);
    }
}

配置好后就重启启动OK