springboot集成redis

springboot集成redis

pom依赖

<!--Redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.3.5.RELEASE</version>
</dependency>
<!--lettuce pool连接池-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.9.0</version>
</dependency>
<!--   lombok   -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.6</version>
</dependency>

<!--&lt;!&ndash;Jackson&ndash;&gt;
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.4</version>
</dependency>-->
<!--<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.13.4</version>
</dependency>-->

application.yml配置

spring:
  redis:
    database: 0
    host: 204.204.202.112
    port: 6379
    connect-timeout: 30000
    lettuce:
      pool:
        # 最大阻塞等待时间，负数表示没有限制
        max-wait: -1
        # 连接池中的最大空闲连接
        max-idle: 10
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中最大连接数，负数表示没有限制
        max-active: 50
    password: admin

RedisConfig类主要设置RedisTemplate

/**
 * Redis配置
 * 主要指定自定义序列化器,避免序列化反序列化失败
 */
@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 参照StringRedisTemplate内部实现指定序列化器
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 设置key的序列化器
        redisTemplate.setKeySerializer(keySerializer());
        redisTemplate.setHashKeySerializer(keySerializer());
        // 设置value的序列化器
        // 解决autoType is not support.xx.xx的问题
        String[] acceptNames = {"org.springframework.security.core.authority.SimpleGrantedAuthority"};
        GenericFastJsonRedisSerializer serializer = new GenericFastJsonRedisSerializer(acceptNames);
        redisTemplate.setValueSerializer(serializer);
        redisTemplate.setHashValueSerializer(serializer);
        return redisTemplate;
    }

    private RedisSerializer<String> keySerializer(){
        return new StringRedisSerializer();
    }

    //使用Jackson序列化器
    private RedisSerializer<Object> valueSerializer(){
        return new GenericJackson2JsonRedisSerializer();
    }
}

RedisUtils工具类封装RedisTemplate的各种方法

@Slf4j
@Component
public class RedisUtils {

    private final RedisTemplate<String, Object> redisTemplate;
    @Autowired
    public RedisUtils(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            log.info("Redis连接失败，可能是Redis服务未启动。" + e.getMessage());
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public boolean del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                Boolean delete = redisTemplate.delete(key[0]);
                return delete;
            } else {
                Long delete = redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
                return true;
            }
        }
        return false;
    }

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            log.info("插入操作时，Redis连接失败，可能是Redis服务未启动。" + e.getMessage());
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time, TimeUnit timeUnit) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, timeUnit);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

创建实体类，实现序列化接口，否则无法存入 Redis 数据库

@Data
public class RedisValueDO  implements Serializable {
    private Integer id;
    private Date time;
    private String station;
}

定义redis过期时间

public class AuthConstant {
    /**
     * 令牌有效时长
     */
    public static final Long EXPIRATION_TIME_IN_SECOND = 60*60L;

    /**
     * 过期时间剩余多少时间时续签
     */
    public static final Long RENEWAL_TIME_IN_SECOND = 60*30L;
}

测试具体redis方法

@Component
public class RedisTask {
    private final RedisUtils redisUtils;
    @Autowired
    public RedisTask(RedisUtils redisUtils) {
        this.redisUtils = redisUtils;
    }
    @PostConstruct
    public void task1() {
        RedisValueDO valueDO = new RedisValueDO();
        valueDO.setId(1);
        valueDO.setStation("910");
        valueDO.setTime(new Date());
        //设置redis缓存
        redisUtils.set("login:" + "test-key", valueDO, AuthConstant.EXPIRATION_TIME_IN_SECOND, TimeUnit.SECONDS);

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //获取redis值
        RedisValueDO value = (RedisValueDO)redisUtils.get("login:" + "test-key");
        System.out.println(value.getTime());

        System.out.println(value);

        //redis是否存在某个key
        boolean hasKey = redisUtils.hasKey("login:" + "test-key");
        System.out.println(hasKey);

        // redis过期时间
        long expire = redisUtils.getExpire("login:" + "test-key");
        System.out.println(expire);
    }
}

可能出现的异常

java: NoClassDefFoundError: com/fasterxml/jackson/core/exc/StreamWriteException
java: NoClassDefFoundError: com/fasterxml/jackson/core/exc/StreamWriteException