Java操作redis

//jedis连接池

public class RedisClientPool

{

    /**
     * redis 地址
     */
    public static String HOST = "172.15.0.103";


    /***
     * redis端口
     */
    public static String PORT = "6379";


    /**
     * 连接超时时间
     */
    public static String TIMEOUT = "60000";


    /***
     * 最大空闲等待时间
     */
    public static String MaxWaitMillis = "100";


    /**
     * 最大空闲时间
     **/
    public static String MAXIDLE = "10000";


    public static RedisClientPool redisClientPool = getInstance ();


    public static JedisPool jedisPool;


    public static synchronized RedisClientPool getInstance ()
    {
        if (null == redisClientPool)
        {
            redisClientPool = new RedisClientPool ();
        }
        return redisClientPool;
    }


    public RedisClientPool ()
    {
        if (null == jedisPool)
        {
            init ();
        }
    }


    /**
     * 初始化Jedis <一句话功能简述> <功能详细描述>
     * 
     * @return
     * @see [类、类#方法、类#成员]
     */
    private static JedisPoolConfig initPoolConfig ()
    {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig ();
        // 控制一个pool最多有多少个状态为idle的jedis实例
        jedisPoolConfig.setMaxIdle (Integer.parseInt (MAXIDLE));
        // 最大能够保持空闲状态的对象数
        // jedisPoolConfig.setMaxIdle(100);
        // 超时时间
        jedisPoolConfig.setMaxWaitMillis (Integer.parseInt (MaxWaitMillis));
        // 在borrow一个jedis实例时，是否提前进行alidate操作；如果为true，则得到的jedis实例均是可用的；
        jedisPoolConfig.setTestOnBorrow (true);
        // 在还会给pool时，是否提前进行validate操作
        jedisPoolConfig.setTestOnReturn (true);


        return jedisPoolConfig;
    }


    /**
     * 关闭资源 <一句话功能简述> <功能详细描述>
     * 
     * @return
     * @see [类、类#方法、类#成员]
     */
    public void release (Jedis jedis)
    {
        if (jedis != null)
        {
            jedis.close ();
        }


    }


    /**
     * 初始化jedis连接池
     */
    public static void init ()
    {
        JedisPoolConfig jedisPoolConfig = initPoolConfig ();
        // 构造连接池
        jedisPool = new JedisPool (jedisPoolConfig, HOST, Integer.parseInt (PORT), Integer.parseInt (TIMEOUT));
    }

}

public class PrivacyInfoRedis implements Serializable
{


    /**
     * serialVersionUID:TODO
     * 
     * @since Ver 1.1
     */


    private static final long serialVersionUID = -4901453654037220554L;
    /**
     * 用户身份证号码
     */
    private String idCard;
    /**
     * 访问者姓名
     */
    private String userName;
    /**
     * 认证状态，true为认证通过，false认证不通过
     */
    private boolean validateFlag;
    /**
     * 创建时间
     */


    private Date createTime;
    /**
     * 机构名称
     */
    private String orgName;


    public String getOrgName ()
    {
        return orgName;
    }


    public void setOrgName (String orgName)
    {
        this.orgName = orgName;
    }


    public boolean isValidateFlag ()
    {
        return validateFlag;
    }


    public void setValidateFlag (boolean validateFlag)
    {
        this.validateFlag = validateFlag;
    }


    public Date getCreateTime ()
    {
        return createTime;
    }


    public void setCreateTime (Date createTime)
    {
        this.createTime = createTime;
    }


    public String getIdCard ()
    {
        return idCard;
    }


    public void setIdCard (String idCard)
    {
        this.idCard = idCard;
    }


    public String getUserName ()
    {
        return userName;
    }


    public void setUserName (String userName)
    {
        this.userName = userName;
    }


    public static long getSerialversionuid ()
    {
        return serialVersionUID;
    }
}

 

//实现

public class PrivacyInfoRedisServiceImpl implements IPrivacyInfoRedisService
{
    public final static String PRIVACY_CHARACTER = "UTF-8";
    /**
     * 隐私验证信息过期时间
     */
    public static String PRIVACY_VALIDTIME = PropertiesUtils.getPropertiesFromPlatform ("php", "php.privacy.validtime");


    @Override
    public void addPrivacy (String uuId, PrivacyInfoRedis privacyInfoRedis)
    {
        Jedis redisClient = null;
        try
        {
            if (privacyInfoRedis != null)
            {
                privacyInfoRedis.setCreateTime (new Date ());// 设置服务的创建时间
                Map <byte[], byte[]> privacyMap = new ConcurrentHashMap <byte[], byte[]> ();
                privacyMap.put (uuId.getBytes (PRIVACY_CHARACTER), serialize (privacyInfoRedis));
                // 获取jedis的实例对象
                redisClient = RedisClientPool.jedisPool.getResource ();
                // 设置map集合到redis服务器
                redisClient.hmset (RedisKeyConstant.PRIVACY_VERIFYCODE_KEY.getBytes (PRIVACY_CHARACTER), privacyMap);
            }
        }
        catch (Exception e)
        {
            // 释放连接
            RedisClientPool.getInstance ().release (redisClient);
        }
        finally
        {
            // 释放连接
            RedisClientPool.getInstance ().release (redisClient);
        }
    }


    @Override
    public long deletePrivacy (String uuId)
    {
        Jedis redisClient = null;
        long result = 0;
        try
        {
            redisClient = RedisClientPool.jedisPool.getResource ();
            result = redisClient.hdel (RedisKeyConstant.PRIVACY_VERIFYCODE_KEY.getBytes (PRIVACY_CHARACTER),
                                       uuId.getBytes (PRIVACY_CHARACTER));
        }
        catch (Exception e)
        {
            RedisClientPool.getInstance ().release (redisClient);
            result = 0;
        }
        finally
        {
            RedisClientPool.getInstance ().release (redisClient);
        }
        return result;
    }


    @Override
    public PrivacyInfoRedis queryPrivacy (String uuId)
    {


        PrivacyInfoRedis result = null;
        Jedis redisClient = null;
        try
        {
            redisClient = RedisClientPool.jedisPool.getResource ();
            byte[] data = redisClient.hget (RedisKeyConstant.PRIVACY_VERIFYCODE_KEY.getBytes (PRIVACY_CHARACTER),
                                            uuId.getBytes (PRIVACY_CHARACTER));
            if (data != null)
            {
                result = (PrivacyInfoRedis) unserizlize (data);
            }
        }
        catch (Exception e)
        {
            RedisClientPool.getInstance ().release (redisClient);
            result = null;
        }
        finally
        {
            RedisClientPool.getInstance ().release (redisClient);
        }
        return result;
    }


    @Override
    public boolean isValidPrivacy (String uuId)
    {
        PrivacyInfoRedis bean = queryPrivacy (uuId);// 根据uuid查询隐私信息
        if (bean == null)
        {
            return false;
        }
        if (StringUtils.isBlank (bean.getIdCard ()))
        {
            return false;
        }


        // 验证码创建时间
        Date createTime = bean.getCreateTime ();


        Calendar calendar = Calendar.getInstance ();
        calendar.setTime (createTime);
        calendar.add (Calendar.SECOND, PRIVACY_VALIDTIME == null ? 240 : Integer.parseInt (PRIVACY_VALIDTIME));
        long createMillis = calendar.getTimeInMillis ();


        calendar.setTime (new Date ());
        long currentMillis = calendar.getTimeInMillis (); // 当前毫秒数


        // 判断验证码是否超过有效期
        if (currentMillis > createMillis)
        {
            return false;
        }
        return true;
    }


    // 序列化
    public static byte[] serialize (Object obj)
    {
        ObjectOutputStream obi = null;
        ByteArrayOutputStream bai = null;
        try
        {
            bai = new ByteArrayOutputStream ();
            obi = new ObjectOutputStream (bai);
            obi.writeObject (obj);
            byte[] byt = bai.toByteArray ();
            return byt;
        }
        catch (IOException e)
        {
            e.printStackTrace ();
        }
        return null;
    }


    // 反序列化
    public static Object unserizlize (byte[] byt)
    {
        ObjectInputStream oii = null;
        ByteArrayInputStream bis = null;
        bis = new ByteArrayInputStream (byt);
        try
        {
            oii = new ObjectInputStream (bis);
            Object obj = oii.readObject ();
            return obj;
        }
        catch (Exception e)
        {


            e.printStackTrace ();
        }


        return null;
    }
}