基础篇：Springboot项目集成Redis组件（详细教程）

基础篇：Linux安装redis教程(详细)

---

一、Springboot项目集成Redis组件

1. 添加依赖

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

2. application.yml配置redis

spring:
  redis:
    port: 6379     # 连接端口号
    host: 192.168.124.130   # Redis 服务器地址
    password: redis@123  # 登陆密码
    database: 0  # 数据库索引（0 - 15）
    connect-timeout: 5000   # 连接超时时间（毫秒）
    jedis:
      pool:
        max-active: 8   # 最大连接数(使用负值表示没有限制) 默认为 8
        max-wait: -1    # 最大阻塞等待时间(使用负值表示没有限制) 默认为 -1 ms
        max-idle: 8     # 最大空闲连接 默认为 8
        min-idle: 0     # 最小空闲连接 默认为 0

3. 配置类 RedisConfig.java

用于自定义配置redis，由于官网给出的redisTemplate不是很好用

@Configuration
public class MyRedisConfig {

    @Resource
    private RedisConnectionFactory factory;

    @Bean
    public RedisTemplate redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        // 对key做序列化处理
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 对Value做序列化处理
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        redisTemplate.setValueSerializer(serializer);

        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        om.setTimeZone(TimeZone.getDefault());
        om.configure(MapperFeature.USE_ANNOTATIONS, false);
        om.configure(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES, false);
        om.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        om.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        serializer.setObjectMapper(om);
        
        return redisTemplate;
    }
}

4. RedisUtil工具类

方便项目后面直接使用

@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * setex
     *
     * @param key   key
     * @param value value
     * @param time  过期时间 单位：秒
     */
    public void setex(String key, Object value, long time) {
        redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    }

    /**
     * set
     * String类型的set,无过期时间
     *
     * @param key   key
     * @param value value
     */
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 批量设置key和value
     *
     * @param map map key和value的集合
     */
    public void mset(Map<String, Object> map) {
        redisTemplate.opsForValue().multiSet(map);
    }

    /**
     * 如果key不存在，则 set
     *
     * @param key   key
     * @param value value
     * @return 返回是否成功
     */
    public Boolean setnx(String key, Object value) {
        return redisTemplate.opsForValue().setIfAbsent(key, value);
    }

    /**
     * 批量插入key，如果key不存在的话
     *
     * @param map map key和value的集合
     * @return 返回是否成功
     */
    public Boolean msetnx(Map<String, Object> map) {
        return redisTemplate.opsForValue().multiSetIfAbsent(map);
    }

    /**
     * String类型的get
     *
     * @param key key
     * @return 返回value对应的对象
     */
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 删除对应key
     *
     * @param key key
     * @return 返回是否删除成功
     */
    public Boolean del(String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 批量删除key
     *
     * @param keys key的集合
     * @return 返回删除成功的个数
     */
    public Long del(List<String> keys) {
        return redisTemplate.delete(keys);
    }

    /**
     * 给某个key设置过期时间
     *
     * @param key  key
     * @param time 过期时间 单位：秒
     * @return 返回是否设置成功
     */
    public Boolean expire(String key, long time) {
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }

    /**
     * 返回是否存在该key
     *
     * @param key key
     * @return 是否存在该key
     */
    public Boolean exits(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 给key的值加上delta值,正值则自增，负值则自减
     *
     * @param key   key
     * @param delta 参数
     * @return 返回key+delta的值
     */
    public Long incrby(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }


    /**
     * 给key的值减去delta
     *
     * @param key   key
     * @param delta 参数
     * @return 返回key - delta的值
     */
    public Long decrby(String key, long delta) {
        return redisTemplate.opsForValue().decrement(key, delta);
    }

    //hash类型

    /**
     * set hash类型
     *
     * @param key     key
     * @param hashKey hashKey
     * @param value   value
     */
    public void hset(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }

    /**
     * set hash类型,并设置过期时间
     *
     * @param key     key
     * @param hashKey hashKey
     * @param value   value
     * @param time    过期时间
     * @return 返回是否成功
     */
    public Boolean hset(String key, String hashKey, Object value, long time) {
        hset(key, hashKey, value);
        return expire(key, time);
    }

    /**
     * 批量设置hash,并设置过期时间
     *
     * @param key  key
     * @param map  hashKey和value的集合
     * @param time 过期时间
     * @return 返回是否设置成功
     */
    public Boolean hmset(String key, Map<String, Object> map, long time) {
        redisTemplate.opsForHash().putAll(key, map);
        return expire(key, time);
    }

    /**
     * 获取hash类型的值
     *
     * @param key     key
     * @param hashKey hashKey
     * @return 返回对应的value
     */
    public Object hget(String key, String hashKey) {
        return redisTemplate.opsForHash().get(key, hashKey);
    }

    /**
     * 获取key下所有的hash值以及hashKey
     *
     * @param key key
     * @return 返回 hashKey 和 value 的 map集合
     */
    public Map<Object, Object> hgetAll(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 批量删除
     *
     * @param key     key
     * @param hashKey hashKey数组集合
     */
    public void hdel(String key, Object... hashKey) {
        redisTemplate.opsForHash().delete(key, hashKey);
    }

    /**
     * 判断是否存在hashKey
     *
     * @param key     key
     * @param hashKey hashKey
     * @return 是否存在
     */
    public Boolean hexists(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }
}

5. 测试

@RunWith(SpringRunner.class)
@SpringBootTest(classes = FirstDockerApplication.class)
public class UserInfoTest {

    @Autowired
    private RedisUtil redisUtil;

    @Test
    public void testSet(){
        String key = "user:" + UUID.randomUUID();
        redisUtil.setex(key,"测试redisUtil工具类",1800);
    }
}