redis缓存工具类，提供序列化接口

1、序列化工具类

package com.qicheshetuan.backend.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializeUtil {

    //序列化
    public static byte[] serialize(Object object) {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try {

            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            byte[] bytes = baos.toByteArray();
            return bytes;
        } catch (Exception e) {
        }
        return null;
    }
    //反序列化
    public static Object unserialize(byte[] bytes) {
        ByteArrayInputStream bais = null;
        try {

            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {
        }
        return null;
    }
}

2、redis工具类

@Component
public class RedisClientUtil {
    @Autowired
    private JedisPool jedisPool;
    
    /**
     * 获取Jedis实例
     *
     * @return
     */
    public Jedis getJedis() {
        return jedisPool.getResource();
    }
    
    /**
     * 判断某个key是否存在
     *
     * @param key
     * @return
     */
    public boolean exist(String key) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.exists(key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 返还到连接池
            returnResource(jedis);
        }
        return false;
    }

    /**
     * 以key删除某个数据
     *
     * @param key
     * @return
     */
    public Long del(String key) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.del(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            // 返还到连接池
            returnResource(jedis);
        }
    }
  /**
     * 将jedis返还到连接池
     *
     * @param jedis
     */
    public void returnResource(Jedis jedis) {
        if (jedis != null) {
            jedisPool.returnResource(jedis);
        }
    }

    /**
     * 存放数据
     *
     * @param key     存储的key
     * @param value   需要存储的数据
     * @param express key失效时间
     * @return
     */
    public <T> boolean setObject(String key, T value, int express) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            byte[] bytes = SerializeUtil.serialize(value);
            jedis.set(key.getBytes(), bytes);
            jedis.expire(key, express);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //返还到连接池
            returnResource(jedis);
        }
        return false;
    }

    /**
     * 删除key集合
     */
    public <T> boolean delKeys(List<String> keys) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            for (String key : keys) {
                jedis.del(key.getBytes());
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //返还到连接池
            returnResource(jedis);
        }
        return false;
    }

    /**
     * 获取数据
     *
     * @param key 存储的key
     * @return
     */
    public <T> T getObject(String key) {
        Object value = null;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            byte[] bytes = jedis.get(key.getBytes());
            value = SerializeUtil.unserialize(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 返还到连接池
            returnResource(jedis);
        }
        if (value != null) {
            return (T) value;
        }
        return null;
    }

    /**
     * 将key的时间置为0，即清除缓存
     *
     * @param key 将key的时间置为0，即清除缓存
     */
    public void expire(String key) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.expire(key, 0);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 返还到连接池
            returnResource(jedis);
        }
    }

    /**
     * 删除以某字符串为前缀的key集合
     */
    public <T> boolean delKeysMatch(String keyMatch) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            Set<String> keys = jedis.keys(keyMatch + "*");
            Iterator<String> it = keys.iterator();
            while (it.hasNext()) {
                String keyStr = it.next();
                jedis.del(keyStr);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //返还到连接池
            returnResource(jedis);
        }
        return false;
    }
}