com.open.capacity.redis.util.RedisUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of redis-spring-boot-starter Show documentation
There is a newer version: 1.0.0.RC4
Show newest version
package com.open.capacity.redis.util;

import java.util.*;
import java.util.concurrent.TimeUnit;

import org.apache.commons.lang3.StringUtils;
import org.springframework.dao.DataAccessException;
import org.springframework.data.geo.Circle;
import org.springframework.data.geo.Distance;
import org.springframework.data.geo.GeoResults;
import org.springframework.data.geo.Metrics;
import org.springframework.data.geo.Point;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisServerCommands;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.TimeoutUtils;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.util.CollectionUtils;

import lombok.extern.slf4j.Slf4j;


/**
 * @author 作者 owen
 * @version 创建时间：2017年04月23日 下午20:01:06 类说明
 * redis工具类
 */
@Slf4j
@SuppressWarnings("all")
public class RedisUtil {


    private StringRedisTemplate stringRedisTemplate;

    private HashOperations hashOperations;

	private RedisConnectionFactory redisConnectionFactory;
 
    /*
     * json序列化方式
     */
    private static GenericJackson2JsonRedisSerializer redisObjectSerializer = new GenericJackson2JsonRedisSerializer();

    /*
     * 默认RedisObjectSerializer序列化
     */
    private RedisTemplate redisTemplate;

    /*
     * redis工具类
     *
     * @param redisTemplate
     * @param stringRedisTemplate
     * @param hashOperations
     */
    public RedisUtil(LettuceConnectionFactory lettuceConnectionFactory, StringRedisTemplate stringRedisTemplate,
                     HashOperations hashOperations) {
        this.redisConnectionFactory = redisConnectionFactory;
        this.stringRedisTemplate = stringRedisTemplate;
        this.hashOperations = hashOperations;
        RedisTemplate redisTemplate = new RedisTemplate();
        RedisSerializer stringSerializer = new StringRedisSerializer();
        RedisSerializer redisObjectSerializer = new GenericJackson2JsonRedisSerializer();
		redisTemplate.setConnectionFactory(lettuceConnectionFactory);
		redisTemplate.setKeySerializer(new StringRedisSerializer()); // key的序列化类型
		redisTemplate.setValueSerializer(redisObjectSerializer); // value的序列化类型
        redisTemplate.setHashKeySerializer(stringSerializer);
        redisTemplate.setHashValueSerializer(redisObjectSerializer);
		redisTemplate.afterPropertiesSet();
        
		this.redisTemplate = redisTemplate ;
    }


    /*
     * 获取消息
     *
     * @param topicGroup
     * @param channel
     * @return
     */
    public String getMsg(String topicGroup, String channel) {
        return hashOperations.get(topicGroup, channel);
    }

    /*
     * 删除消息
     *
     * @param topicGroup
     * @param channel
     * @return
     */
    public boolean removeMsg(String topicGroup, String channel) {
        publishMsg(topicGroup, channel, StringUtils.EMPTY);

        return hashOperations.delete(topicGroup, channel) == 1;
    }

    /*
     * 发送消息，存redis hash
     *
     * @param topicGroup
     * @param channel
     * @param msg
     * @return
     */
    public boolean publishMsg(String topicGroup, String channel, String msg) {
        hashOperations.put(topicGroup, channel, msg);
        //向通道发送消息的方法
        stringRedisTemplate.convertAndSend(topicGroup + "-" + channel, msg);
        return true;
    }

    /*
     * 订阅回调
     *
     * @param msg
     * @param redisSubscribeCallback
     */
    public void subscribeConfig(String msg, RedisSubscribeCallback redisSubscribeCallback) {
        redisSubscribeCallback.callback(msg);
    }

    /*
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        return redisTemplate.execute(new RedisCallback() {

            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                long rawTimeout = TimeoutUtils.toMillis(time, TimeUnit.SECONDS);
                try {
                    return connection.pExpire(key.getBytes(), rawTimeout);
                } catch (Exception e) {
                    // Driver may not support pExpire or we may be running on
                    // Redis 2.4
                    return connection.expire(key.getBytes(), TimeoutUtils.toSeconds(rawTimeout, TimeUnit.SECONDS));
                }
            }
        });
    }

    /*
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {

        return redisTemplate.execute(new RedisCallback() {

            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {

                try {
                    return connection.pTtl(key.getBytes(), TimeUnit.SECONDS);
                } catch (Exception e) {
                    // Driver may not support pTtl or we may be running on Redis
                    // 2.4
                    return connection.ttl(key.getBytes(), TimeUnit.SECONDS);
                }
            }
        });
    }

    /*
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        return redisTemplate.execute((RedisCallback) connection -> connection.exists(key.getBytes()));
    }

    // ============================Object=============================

    /*
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {

        Object value = redisTemplate.execute(new RedisCallback