redis-06 springBoot整合

Jedis

是redis官方推荐的java连接开发工具，使用java操作redis中间件。

springBoot整合

新版使用lettuce的库操作redis 连接池
RedisTemplate 所有的操作都需要序列化
1、导入依赖

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

2、配置连接

spring.redis.host=12.70.0.1
spring.redis.port=6379

3、测试

@Autowired
private RedisTemplate redisTemplate;
// opsForValue() 操作字符串
// opsForList() 操作list
// opsForSet() 操作set
// opsForHash() 操作hash
@Test
void contextLoads() {
  redisTemplate.opsForValue().set("key", "value");
  redisTemplate.opsForValue().get("key")
  redisTemplate.opsForList().leftPush("listKey", “v1”,“v2”);
}

// 获取连接对象
RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
connection .flushDb();
connection.flushAll();

自定义redisTemplate

在源码中 RedisAutoConfiguration类中 返回的RedisTemplate 的Bean 如下

@Bean
@Conditiona10nMissingBean(name = 'redisTemplate')
pubic RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory ) throws UnknownHostException {
    RedisTemplate<Object, Object> template = new RedisTemplate<>();
    template.setConnectionFactory( redisConnectionFactory );
    return template;
}

@Conditiona10nMissingBean(name = 'redisTemplate')的意思是只有当 Spring 容器中不存在名为 redisTemplate 的 Bean 时，当前被注解的配置才会生效（即创建这个 Bean）。看源码可知RedisTemplate的key也是Object 我们日常使用的时候会很不方便经常会需要强制转换，所以为了效率和开发便捷我们要自定义一个RedisTemplate类来替换掉它

@Configuration
public class RedisConfig {
    @Bean
    @SuppressWarnings("all")
    pubic RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory ) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory( redisConnectionFactory );

        // 序列化配置
        // jackson的序列化
        Jackson2HsonRedisSerializer jackson2HsonRedisSerializer = new Jackson2HsonRedisSerializer (Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        // 使用ObjectMapper 进行转译
        jackson2HsonRedisSerializer.setObjectMapper(om);
        // string的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用string的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2HsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2HsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

自定义一个redis工具类 RedisUtil

@Component
public final class RedisUtil {
    @Autowired
    private RedisTemplate<String, object> redisTemplate;
    // =================== common =====================
    /**
      * 指定缓存失效时间
      * @param key 键
      * @param time 时间(秒)
      */
    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获取过期时间
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS)
    }

    // 判断key是否存在
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    // 删除缓存
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length ==1) {
                redisTemplate.delete(key[0])
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    // ==================== string ======================
    // 普通缓存获取
    public Object get(String key) {
      return key == null ? null : redisTemplate.opsForValue().get(key)
    }  
    
    //普通缓存写入
    public boolean set (String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    // 递增
    public long incr (String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta)
    }

    // 递减
    public long decr (String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta)
    }
    
    // ===================== map =======================
    // HashGet
    public Object hget (String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    // 获取hashKey对应的所有键值对
    public Map<Object, Object> hmget (String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    // HashSet
    public boolean hmset (String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().pullAll (key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
  ....
}