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;
     }
 }

SerializeUtil

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;
     }
 }

RedisClientUtil