redis简单封装和使用

1、准备工作

• 项目中引入jar包，maven的方式

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

• 配置文件配置redis的数据源

spring.redis.database=1
spring.redis.host=localhost
spring.redis.password=123456
spring.redis.port=6379

2、常用方法的抽象

public interface S2Cache {

    /**
     * 缓存名称
     *
     * @return
     */
    String getName();

    /**
     * 是否存在
     *
     * @param key
     * @return
     */
    boolean exists(final String key);

    /**
     * 获取缓存
     *
     * @param key
     * @return
     */
    Object get(final String key);

    /**
     * 获取缓存
     *
     * @param key
     * @param clazz
     * @param <T>
     * @return
     */
    <T> T get(final String key, Class<T> clazz);


    /**
     * 批量获取缓存
     *
     * @param keys
     * @param clazz
     * @param <V>
     * @return
     */
    <V> List<V> multiGet(Collection<String> keys, Class<V> clazz);

    /**
     * 获取缓存列表
     *
     * @param key
     * @param clazz
     * @param <T>
     * @return
     */
    <T> List<T> getList(final String key, Class<T> clazz);

    /**
     * 设置缓存
     *
     * @param key
     * @param value
     * @return
     */
    void set(final String key, Object value);

    /**
     * 设置缓存
     *
     * @param key
     * @param value
     * @param expireTime
     * @return
     */
    void set(final String key, Object value, Long expireTime);

    /**
     * 删除缓存
     *
     * @param key
     */
    void remove(final String key);


    /**
     * 删除缓存
     *
     * @param keys
     */
    void remove(final String... keys);

    /**
     * 自增
     *
     * @param key
     * @param value
     * @return
     */
    long increment(final String key, long value);


    /**
     * 入队
     *
     * @param key
     * @param value
     * @param hashKey
     * @return
     */
    void hashPush(final String key, String hashKey, Object value);

    /**
     * 入队
     *
     * @param key
     * @param value
     * @param hashKey
     * @param expireTime
     * @return
     */
    void hashPush(final String key, String hashKey, Object value, Long expireTime);

    /**
     * 批量入队
     *
     * @param key
     * @param map
     * @return
     */
    void hashPush(final String key, Map<String, Object> map);

    /**
     * 批量入队
     *
     * @param key
     * @param map
     * @param expireTime
     * @return
     */
    void hashPush(final String key, Map<String, Object> map, Long expireTime);

    /**
     * 出队
     *
     * @param key
     * @param hashKey
     * @return
     */
    Object hashPop(final String key, String hashKey);

    /**
     * 出队
     *
     * @param key
     * @param hashKey
     * @param clazz
     * @param <T>
     * @return
     */
    <T> T hashPop(final String key, String hashKey, Class<T> clazz);

    /**
     * 是否存在hash缓存
     *
     * @param key
     * @param hashKey
     * @return
     */
    boolean hashHasKey(final String key, String hashKey);

    /**
     * 删除hash缓存
     *
     * @param key
     * @param hashKey
     */
    void hashRemove(final String key, String hashKey);

    /**
     * key集合
     *
     * @param key
     * @return
     */
    Set<Object> hashKeys(final String key);

    /**
     * value集合
     *
     * @param key
     * @return
     */
    List<Object> hashValues(final String key);


    /**
     * 集合自增
     *
     * @param key
     * @param hashKey
     * @param value
     * @return
     */
    long hashIncrement(final String key, String hashKey, long value);


    Map<Object, Object> hashEntries(String hashKey);
}

3、常用方法的实现

@Component
public class RedisCache implements S2Cache {

    @Value("${www.s2cache.expireTime:10800}")
    public Long expireTime;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;


    @Override
    public String getName() {
        return "redis";
    }

    @Override
    public boolean exists(String key) {
        return redisTemplate.hasKey(key);
    }

    @Override
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    @Override
    public <T> T get(String key, Class<T> clazz) {
        return JSON.parseObject(JSON.toJSONString(get(key)), clazz);
    }

    /**
     * 批量获取缓存
     *
     * @param keys
     * @param clazz
     * @return
     */
    @Override
    public <V> List<V> multiGet(Collection<String> keys, Class<V> clazz) {

        return (List<V>) redisTemplate.opsForValue().multiGet(keys);
    }

    /**
     * 获取缓存
     *
     * @param key
     * @param clazz
     * @return
     */
    @Override
    public <T> List<T> getList(String key, Class<T> clazz) {
        return JSON.parseArray(JSON.toJSONString(get(key)), clazz);
    }


    @Override
    public void set(String key, Object value) {
        set(key, value, expireTime);
    }

    @Override
    public void set(String key, Object value, Long expireTime) {
        if (expireTime == null) {
            redisTemplate.opsForValue().set(key, value);
        } else {
            redisTemplate.opsForValue().set(key, value, expireTime, TimeUnit.SECONDS);
        }
    }

    @Override
    public void remove(String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    @Override
    public void remove(String... keys) {
        for (String key : keys) {
            if (exists(key)) {
                remove(key);
            }
        }
    }

    @Override
    public long increment(String key, long value) {

        return redisTemplate.opsForValue().increment(key, value);
    }

    @Override
    public void hashPush(String key, String hashKey, Object value) {
        hashPush(key, hashKey, value, null);
    }

    @Override
    public void hashPush(String key, String hashKey, Object value, Long expireTime) {
        HashOperations<String, String, Object> hashOperations = redisTemplate.opsForHash();
        hashOperations.put(key, hashKey, value);

        if (expireTime != null) {
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
        }
    }

    /**
     * 批量入队
     *
     * @param key
     * @param map
     * @return
     */
    @Override
    public void hashPush(String key, Map<String, Object> map) {
        hashPush(key, map, null);
    }

    /**
     * 批量入队
     *
     * @param key
     * @param map
     * @param expireTime
     * @return
     */
    @Override
    public void hashPush(String key, Map<String, Object> map, Long expireTime) {

        HashOperations<String, String, Object> hashOperations = redisTemplate.opsForHash();
        hashOperations.putAll(key, map);

        if (expireTime != null) {
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
        }
    }

    @Override
    public Object hashPop(String key, String hashKey) {
        return redisTemplate.opsForHash().get(key, hashKey);
    }

    /**
     * 出队
     *
     * @param key
     * @param hashKey
     * @param clazz
     * @return
     */
    @Override
    public <T> T hashPop(String key, String hashKey, Class<T> clazz) {
        return JSON.parseObject(JSON.toJSONString(hashPop(key, hashKey)), clazz);
    }

    @Override
    public boolean hashHasKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    @Override
    public void hashRemove(String key, String hashKey) {
        redisTemplate.opsForHash().delete(key, hashKey);
    }

    @Override
    public Set<Object> hashKeys(String key) {
        return redisTemplate.opsForHash().keys(key);
    }

    @Override
    public List<Object> hashValues(String key) {
        return redisTemplate.opsForHash().values(key);
    }

    @Override
    public long hashIncrement(String key, String hashKey, long value) {
        return redisTemplate.opsForHash().increment(key, hashKey, value);
    }

    @Override
    public Map<Object, Object> hashEntries(String hashKey) {
        return redisTemplate.opsForHash().entries(hashKey);
    }
}

4、具体使用

1. 直接把上面两个文件放到项目中，通过调用方法的方式进行redis缓存
2. 可以单建一个项目，将上面两个文件放到该项目中，然后打包为jar文件，在项目中需要有使用就引入进去，这样更通用
3. 抽象类的方法是常用方法，根据具体使用场景，增加自定义抽象方法，不管是使用redis还是其他，都可以实现该抽象类，只是具体实现不同