Redis数据类型

      在项目中使用redis，主要是从性能和并发两个维度去考虑。试想一下，一条冗长的sql语句或者存储过程在数据库中执行一次需要1分钟以上，且该sql是高并发下的使用场景，如果以这样的响应速度，那是万万达不到要求的，所以，这里就要采用redis进行预加载缓存，这里我就不说怎么运用redis了，主要说说redis中如何存储多种形式的数据。

      redis缓存中主要使用的类和集合主要涉及到以下几种：

            ValueOperations<String, T> valueOperations

            HashOperations<String, String, T> hashOperations

            ListOperations<String,String> listOperations;

            SetOperations<String,String> setOperations;

        当然，我们也可以用这几种进行相应的组合，所以说，redis中存储数据的格式的场景非常多，我们需要尽可能的灵活运用。下面我介绍下几种常见的存储格式

       1.key---value的形式

此种方式就是以key-value的形式保存在数据库中的展现形式，

package com.youfuli.vendor.service.impl;

import com.youfuli.vendor.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Service
public class RedisServiceImpl<T> implements RedisService<T> {

    @Value("redis.cache.common")
    private String commonCacheName;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Resource
    private ValueOperations<String, T> valueOperations;

    @Resource
    private HashOperations<String, String, T> hashOperations;

    /**
     * 添加
     *
     * @param key    key
     * @param value  对象
     * @param expire 过期时间(单位:秒),传入 -1 时表示不设置过期时间
     */
    @Override
    public void put(String key, T value, long expire) {
        valueOperations.set(key, value);
        if (expire != -1) {
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
    }



    /**
     * 添加
     *
     * @param key    key
     * @param value  对象
     * @param expire 过期时间(单位:秒),传入 -1 时表示不设置过期时间
     */
    @Override
    public void put(String cacheName, String key, T value, long expire) {
        hashOperations.put(cacheName, key, value);
        if (expire != -1) {
            redisTemplate.expire(cacheName, expire, TimeUnit.SECONDS);
        }
    }


    /**
     * 删除
     *
     * @param key 传入key的名称
     */
    @Override
    public void remove(String key) {
        remove(commonCacheName, key);
    }

    /**
     * 删除
     *
     * @param cacheName 缓存名称
     * @param key       传入key的名称
     */
    @Override
    public void remove(String cacheName, String key) {
        hashOperations.delete(cacheName, key);
    }

    /**
     * 查询
     *
     * @param key 查询的key
     * @return
     */
    @Override
    public T get(String key) {
        return valueOperations.get(key);
    }

    /**
     * 查询
     *
     * @param cacheName 缓存名称
     * @param key       查询的key
     * @return
     */
    @Override
    public T get(String cacheName, String key) {
        return hashOperations.get(cacheName, key);
    }

    /**
     * 获取当前redis默认缓存下所有对象
     *
     * @return
     */
    @Override
    public List<T> getAll() {
        return getAll(commonCacheName);
    }

    /**
     * 获取当前redis指定缓存下所有对象
     *
     * @return
     */
    @Override
    public List<T> getAll(String cacheName) {
        return hashOperations.values(cacheName);
    }

    /**
     * 查询查询当前redis默认缓存下所有key
     *
     * @return
     */
    @Override
    public Set<String> getKeys() {
        return getKeys(commonCacheName);
    }

    /**
     * 查询查询当前redis指定缓存下所有key
     *
     * @return
     */
    @Override
    public Set<String> getKeys(String cacheName) {
        return hashOperations.keys(cacheName);
    }

    /**
     * 判断key是否存在redis中
     *
     * @param key 传入key的名称
     * @return
     */
    @Override
    public boolean isKeyExists(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 判断key是否存在redis中
     *
     * @param key 传入key的名称
     * @return
     */
    @Override
    public boolean isKeyExists(String cacheName, String key) {
        return hashOperations.hasKey(cacheName, key);
    }

    /**
     * 查询当前key下缓存数量
     *
     * @return
     */
    @Override
    public long count() {
        return count(commonCacheName);
    }

    /**
     * 查询当前key下缓存数量
     *
     * @return
     */
    @Override
    public long count(String cacheName) {
        return hashOperations.size(cacheName);
    }

    /**
     * 清空redis
     */
    @Override
    public void empty() {
        empty(commonCacheName);
    }

    /**
     * 清空redis
     */
    @Override
    public void empty(String cacheName) {
        Set<String> set = hashOperations.keys(cacheName);
        set.stream().forEach(key -> hashOperations.delete(cacheName, key));
    }
}

valueOperations的格式存储的就是key-value的数据格式，hashOperations的格式存储的就是key-key-value的数据格式，具体在redis manager中的展现如下：

此种情况适用于一个对象下面存放多条数据的情况，在redis中存储是不冲突的，会将key1重复的数据合并，进而可以保存多条key2形式的数据。

  其实我们可以感觉到，redis中存储数据的方式和我们编程语言的存储方式是很相似的，list,set,map格式的数据都是可以实现存储的，在这里我要提醒大家一个错误，

redis manager可视化界面上出现在这样的情况的时候，我们需要确定我们服务端和客户端的版本，一般情况下是版本冲突导致的，这里给大家介绍下我的redis服务端版本为3.2.100，客户端版本为0.9.3.817，其他情况下就需要进行见招拆招了咯。

 redi还可以对高并发大数据量的情况下进行数据处理，对一些耗时长的操作进行缓存预热，提前进行加载，redis其实还是挺好用的，希望后面我可以更深层次的运用。