redis各种数据类型进行操作

1.数据操作Dao

/**
 * RedisManager 操作类
 * 使用SpringDataRedis进行整合
 *
 * @author yy
 * @since 1.0.0, 2019年08月20日
 */
@Component
public class RedisManager {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /*
     * 一、Key 键操作
     */

    /**
     * 实现命令：TTL key，以秒为单位，返回给定 key的剩余生存时间(TTL, time to live)。
     *
     * @param key 要操作的Key
     * @return 剩余生存秒数
     */
    public long ttl(String key) {
        return stringRedisTemplate.getExpire(key);
    }

    /**
     * 实现命令：expire 设置过期时间，单位:秒
     *
     * @param key     要操作的Key
     * @param timeout 过期时间，单位：秒
     * @return 操作是否成功
     */
    public Boolean expire(String key, long timeout) {
        return stringRedisTemplate.expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 实现命令：INCR key
     * 将 key 中储存的数字值增一个值delta
     *
     * @param key   key值
     * @param delta 对应增加的量
     * @return 执行完成后Value的值
     */
    public long incr(String key, long delta) {
        return stringRedisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 实现命令：KEYS pattern
     * 查找所有符合给定模式 pattern的 key
     *
     * @param pattern 去匹配的模式
     * @return 匹配的结果
     */
    public Set<String> keys(String pattern) {
        return stringRedisTemplate.keys(pattern);
    }

    /**
     * 实现命令：DEL key，删除一个key
     *
     * @param key 要删除的KEY
     * @return 是否操作成功
     */
    public Boolean del(String key) {
        return stringRedisTemplate.delete(key);
    }

    /*
     * 二、String（字符串）操作
     */

    /**
     * 实现命令：SET key value，设置一个key-value（将字符串值 value关联到 key）
     *
     * @param key   对应要保存的key
     * @param value 要保存的value值
     */
    public void set(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }

    /**
     * 实现命令：SET key value EX seconds
     * 设置key-value和超时时间（秒）
     *
     * @param key     对应要保存的key
     * @param value   对应的value值
     * @param timeout 超时时间（以秒为单位）
     */
    public void set(String key, String value, long timeout) {
        stringRedisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    }

    /**
     * 实现命令：GET key，返回 key所关联的字符串值。
     *
     * @param key 对应需要查询的key
     * @return value key对应的value值
     */
    public String get(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    /*
     * 三、Hash（哈希表）操作
     */

    /**
     * 实现命令：HSET key field value，
     * 将哈希表 key中的域 field的值设为 value
     *
     * @param key   对应要设置的key
     * @param field 对应hash中的字段名称
     * @param value 要设置的值
     */
    public void hset(String key, String field, Object value) {
        stringRedisTemplate.opsForHash().put(key, field, value);
    }
    public void hmset(String key, Map<Object, Object> value ) {
        stringRedisTemplate.opsForHash().putAll(key,  value);
    }
    public Set<Object> hkeys(String key) {
      return   stringRedisTemplate.opsForHash().keys(key);
    }

    /**
     * 实现命令：HGET key field，返回哈希表 key中给定域 field的值
     *
     * @param key   对应要的key值
     * @param field 对应hash中的字段名称
     * @return 获取的结果
     */
    public String hget(String key, String field) {
        return (String) stringRedisTemplate.opsForHash().get(key, field);
    }

    /**
     * 实现命令：HDEL key field [field ...]，删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
     *
     * @param key    对应要的key值
     * @param fields 对应要删除的字段数据-可变长参数列表
     * @return 成功删除了几个属性
     */
    public Long hdel(String key, Object... fields) {
        return stringRedisTemplate.opsForHash().delete(key, fields);
    }

    /**
     * 实现命令：HGETALL key，返回哈希表 key中，所有的域和值。
     *
     * @param key 对应要获取的hash的key值
     * @return key对应的查询结果，hash整体
     */
    public Map<Object, Object> hgetall(String key) {
        return stringRedisTemplate.opsForHash().entries(key);
    }

    /*
     * 四、List（列表）
     */

    /**
     * 实现命令：LPUSH key value
     * 将一个值 value插入到列表 key的表头
     *
     * @param key   对应要加的节点Key值
     * @param value 要添加的value
     * @return 执行 LPUSH命令后，列表的长度。
     */
    public long lpush(String key, String value) {
        return stringRedisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * 实现命令：LPOP key，
     * 移除并返回列表 key的头元素。
     *
     * @param key 要移除的对象
     * @return 列表key的头元素。
     */
    public String lpop(String key) {
        return stringRedisTemplate.opsForList().leftPop(key);
    }

    /**
     * 实现命令：RPUSH key value，
     * 将一个值 value插入到列表 key的表尾(最右边)。
     *
     * @param key   要插入的key值
     * @param value 要插入的value值
     * @return 执行 LPUSH命令后，列表的长度。
     */
    public long rpush(String key, String value) {
        return stringRedisTemplate.opsForList().rightPush(key, value);
    }

    public void zadd(String key, String value,  double score) {
        stringRedisTemplate.opsForZSet().add(key,value, score);
    }
    public Set<String> zrange(String key,long start, long end) {
         return stringRedisTemplate.opsForZSet().range(key, start,  end);
    }


    public Set<ZSetOperations.TypedTuple<String> > rangeWithScores(String key, long start, long end) {
        return stringRedisTemplate.opsForZSet().rangeWithScores(key, start,  end);
    }

    public void publish(String channel, TaskSynData taskSynData) {
        stringRedisTemplate.convertAndSend(channel, taskSynData);
    }
}

2.功能测试

@Slf4j
@SpringBootTest
@RunWith(SpringRunner.class)
public class RedisTestControllerTest {
    @Autowired
    private RedisManager redisTemplate;
    /**
     * 获取注入的lua脚本文件
     */
    @Autowired
    private DefaultRedisScript<String> getLua;

    @Test
    public void testRedis() {
        //设置值到redis
        redisTemplate.set("name", "lucy");
        //从redis获取值
        String name = redisTemplate.get("name");
        System.out.println(name);
    }

    @Test
    public void lpush() {
        //设置值到redis
        for (int i = 0; i < 2; i++) {
            redisTemplate.lpush("lpush_x", "kkkkkkkkk" + i);
        }
    }
    @Test
    public void hset() {
        //从redis获取值
        redisTemplate.hset("keyx", "key2", "565");
        redisTemplate.hset("keyx", "key3", "76876");
        redisTemplate.hset("keyx", "key4", "90768");
    }

    @Test
    public void hget() {
        //从redis获取值
        String name = redisTemplate.hget("keyx", "key1");
        System.out.println(name);
    }

    @Test
    public void hgetall() {
        //从redis获取值
        Map<Object, Object> name = redisTemplate.hgetall("keyx");
        System.out.println(name);
    }

    @Test
    public void hmset() {
        Map<Object, Object> value = new HashMap<>();
        value.put("name", "lily");
        value.put("age", "1");
        value.put("sex", "男");
        //从redis获取值
        redisTemplate.hmset("value123", value);
    }

    @Test
    public void hkeys() {
        //从redis获取值
        Set<Object> name = redisTemplate.hkeys("keyx");
        System.out.println(name);
    }

    @Test
    public void zadd() {
        //从redis获取值
        redisTemplate.zadd("key12", "3545", 3);
        redisTemplate.zadd("key12", "345667", 5);
    }

    @Test
    public void zrange() {
        //从redis获取值
        Set<String> name = redisTemplate.zrange("key12", 0, 2);
        System.out.println(name);
    }

    @Test
    public void rangeWithScores() {
        //从redis获取值
        Set<ZSetOperations.TypedTuple<String>> name = redisTemplate.rangeWithScores("key12", 1, 3);
        System.out.println(JSON.toJSONString(name));
    }
    @Test
    public void lpop() {
        //从redis获取值
        String name = redisTemplate.lpop("lpush_x");
        System.out.println(name);
    }
}