liuyiyou
liuyiyou

BaseRedis

import com.iba.frame.redis.PojoSerializable;
import com.iba.frame.util.CommonUtil;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisConnectionUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Repository;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

@Repository("baseRedis")
public abstract class BaseRedis {

    // 加载数据的时候每页加载1000条，免得数据库超时
    protected final Integer LOAD_PAGE_SIZE = 1000;
    @Autowired
    protected RedisTemplate redisTemplate;
    @Autowired
    protected RedisTemplate transRedisTemplate;
    private Logger logger = Logger.getLogger(BaseRedis.class);

    // @Autowired
    // protected Jedis jedis;

    /////////////////////////////////////////////////////////////////
    /////////////////////////// 普通通用接口////////////////////////////
    /////////////////////////////////////////////////////////////////

    /**
     * 设置一个结构数据
     *
     * @param key
     * @param value
     * @param seconds
     * @return
     */
    protected Long incr(final String key) {
        Long result = redisTemplate.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                return connection.incr(byteKey);
            }
        });
        return result;
    }

    /**
     * 设置一个结构数据
     *
     * @param key
     * @param value
     * @param seconds
     * @return
     */
    protected Long decr(final String key) {
        Long result = redisTemplate.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                return connection.decr(byteKey);
            }
        });
        return result;
    }

    /**
     * 设置一个结构数据
     *
     * @param key
     * @param value
     * @param seconds
     * @return
     */
    protected boolean set(final String key, final String value, final long seconds) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteValue = serializer.serialize(value);
                if (seconds > 0) {
                    connection.setEx(byteKey, seconds, byteValue);
                } else {
                    connection.set(byteKey, byteValue);
                }
                return true;
            }
        });
        return result;
    }

    /**
     * @param key
     * @param value
     * @param seconds
     * @param suppressTran 是否压制事务，true，表示在事务环境中立即执行（不进redis队列）
     * @return
     */
    protected boolean set(final String key, final String value, final long seconds, final boolean suppressTran) {
        RedisTemplate realTemp = suppressTran ? redisTemplate : transRedisTemplate;
        boolean result = realTemp.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteValue = serializer.serialize(value);
                if (seconds > 0) {
                    connection.setEx(byteKey, seconds, byteValue);
                } else {
                    connection.set(byteKey, byteValue);
                }
                return true;
            }
        });
        return result;
    }

    /**
     * 设置一个结构数据(主要用于保存bean对象，初始化incr值请使用String类型的方法)
     *
     * @param key
     * @param value
     * @param seconds
     * @return
     */
    protected boolean set(final String key, final Serializable value, final long seconds) {
        boolean result = transRedisTemplate.execute((RedisCallback) connection -> {
            if(transRedisTemplate.getValueSerializer() instanceof  Jackson2JsonRedisSerializer){
                Jackson2JsonRedisSerializer valueSerializer = (Jackson2JsonRedisSerializer)transRedisTemplate.getValueSerializer();
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteValue = valueSerializer.serialize(value);
                if (seconds > 0) {
                    connection.setEx(byteKey, seconds, byteValue);
                } else {
                    connection.set(byteKey, byteValue);
                }
            }else{
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteValue = CommonUtil.transObj2ByteArray(value);
                if (seconds > 0) {
                    connection.setEx(byteKey, seconds, byteValue);
                } else {
                    connection.set(byteKey, byteValue);
                }
            }

            return true;
        });
        return result;
    }

    /**
     * 根据Key获取对象
     *
     * @param key
     * @return
     */
    protected Object get(final String key) {
        Object result = redisTemplate.execute((RedisCallback) connection -> {
            RedisSerializer serializer = getRedisSerializer();
            byte[] byteKey = serializer.serialize(key);
            byte[] value = connection.get(byteKey);
            if (value == null) {
                return null;
            }
            Object dataObj = serializer.deserialize(value);
            return dataObj;
        });
        return result;
    }

    /**
     * 根据Key获取对象
     *
     * @param key
     * @return
     */
    protected  T get(final String key, final Class clazz) {
        T result = redisTemplate.execute((RedisCallback) connection -> {
            RedisSerializer serializer = getRedisSerializer();
            byte[] byteKey = serializer.serialize(key);
            byte[] value = connection.get(byteKey);
            if (value == null) {
                return null;
            }
            if(transRedisTemplate.getValueSerializer() instanceof  Jackson2JsonRedisSerializer){
                Jackson2JsonRedisSerializer valueSerializer = (Jackson2JsonRedisSerializer)transRedisTemplate.getValueSerializer();
                Object dataObj = valueSerializer.deserialize(value);
                System.out.println("dataObj1::"+dataObj);
                return (T)dataObj;
            }else{
                T dataObj = CommonUtil.transByteArray2Obj(value, clazz);
                System.out.println("dataObj1::"+dataObj);
                return dataObj;
            }

        });
        return result;
    }

    protected Object mget(final List keys) {
        Object result = redisTemplate.execute(new RedisCallback() {
            @Override
            public List doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                List listByteKeys = new ArrayList();
                for (String key : keys) {
                    byte[] byteKey = serializer.serialize(key);
                    listByteKeys.add(byteKey);
                }

                List listByteValues = connection.mGet(listByteKeys.toArray(new byte[listByteKeys.size()][]));
                List listValue = new ArrayList();
                for (byte[] value : listByteValues) {
                    listValue.add(serializer.deserialize(value));
                }
                return listValue;
            }
        });
        return result;
    }

    /**
     * @param argKey
     * @return
     */
    protected Object keys(final String argKey) {
        Object result = redisTemplate.execute(new RedisCallback() {
            @Override
            public List doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(argKey);
                Set setBytes = connection.keys(byteKey);
                List listValue = new ArrayList();
                for (byte[] value : setBytes) {
                    listValue.add(serializer.deserialize(value));
                }
                return listValue;
            }
        });
        return result;
    }

    protected  List mget(final List keys, final Class clazz) {
        List result = redisTemplate.execute(new RedisCallback>() {
            @Override
            public List doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                List listByteKeys = new ArrayList();
                for (String key : keys) {
                    byte[] byteKey = serializer.serialize(key);
                    listByteKeys.add(byteKey);
                }

                List listByteValues = connection.mGet(listByteKeys.toArray(new byte[listByteKeys.size()][]));
                List listValue = new ArrayList();
                for (byte[] value : listByteValues) {
                    listValue.add(CommonUtil.transByteArray2Obj(value, clazz));
                }
                return listValue;
            }
        });
        return result;
    }

    protected boolean exists(final String key) {
        boolean result = redisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                return connection.exists(byteKey);
            }
        });
        return result;
    }

    protected Long ttl(final String key) {
        Long result = redisTemplate.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);

                return connection.ttl(byteKey);
            }
        });
        return result;
    }

    /////////////////////////////////////////////////////////////////
    /////////////////////////// Set 操作接口 //////////////////////////
    /////////////////////////////////////////////////////////////////
    protected boolean sadd(final String key, final String value) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteValue = serializer.serialize(value);
                connection.sAdd(byteKey, byteValue);
                return true;
            }
        });
        return result;
    }

    /**
     * 仅限于基本对象使用，Bean对象禁止使用
     *
     * @param key
     * @param value
     * @return
     */
    protected boolean sadd(final String key, final Serializable value) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteValue = CommonUtil.transObj2ByteArray(value);
                connection.sAdd(byteKey, byteValue);
                return true;
            }
        });
        return result;
    }

    protected boolean sadd(final String key, final List values) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                List byteValues = new ArrayList(values.size());
                for (String v : values) {
                    byteValues.add(serializer.serialize(v));
                }
                connection.sAdd(byteKey, byteValues.toArray(new byte[values.size()][]));

                return true;
            }
        });
        return result;
    }

    protected boolean sadd(final String key, final Set values) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[][] byteValues = new byte[values.size()][];
                int i = 0;
                for (Serializable v : values) {
                    byteValues[i++] = CommonUtil.transObj2ByteArray(v);
                }
                connection.sAdd(byteKey, byteValues);
                return true;
            }
        });
        return result;
    }

    /**
     * 增加sadd类型
     *
     * @param key
     * @param values
     * @return
     */
    protected boolean sadd(final String key, final Collection values) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[][] byteValues = new byte[values.size()][];
                int i = 0;
                for (Serializable v : values) {
                    byteValues[i++] = CommonUtil.transObj2ByteArray(v);
                }
                connection.sAdd(byteKey, byteValues);
                return true;
            }
        });
        return result;
    }

    protected Long scard(final String key) {
        Object result = redisTemplate.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                Long count = connection.sCard(byteKey);
                return count;
            }
        });
        return Long.parseLong(String.valueOf(result));
    }

    @SuppressWarnings("rawtypes")
    protected Object smembers(final String key) {
        Object result = redisTemplate.execute(new RedisCallback() {
            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);

                Set setValue = connection.sMembers(byteKey);

                Iterator iter = setValue.iterator();

                List listObj = new ArrayList();
                while (iter.hasNext()) {
                    Object obj = serializer.deserialize((byte[]) iter.next());
                    listObj.add(obj);
                }
                return listObj;
            }
        });
        return result;
    }

    protected  Set smembers(final String key, final Class clazz) {
        Set result = redisTemplate.execute(new RedisCallback>() {
            @Override
            public Set doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                Set setValue = connection.sMembers(byteKey);
                Iterator iter = setValue.iterator();
                Set result = new HashSet();
                while (iter.hasNext()) {
                    T tmp = CommonUtil.transByteArray2Obj(iter.next(), clazz);
                    result.add(tmp);
                }
                if (result.size() == 0) {
                    return null;
                }
                return result;
            }
        });
        return result;
    }

    protected Set smembersString(final String key) {
        Set result = redisTemplate.execute(new RedisCallback>() {
            @Override
            public Set doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                Set setValue = connection.sMembers(byteKey);
                Iterator iter = setValue.iterator();
                Set setStr = new HashSet();
                while (iter.hasNext()) {
                    String obj = serializer.deserialize(iter.next());
                    setStr.add(obj);
                }
                return setStr;
            }
        });
        return result;
    }

    /**
     * 移出set中指定元素，在事务中无法返回结果，若业务需要判断移出是否成功，请使用smember判断
     *
     * @param key
     * @param value
     * @return
     */
    protected boolean srem(final String key, final String value) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteValue = serializer.serialize(value);
                Long index = connection.sRem(byteKey, byteValue);
                return index != null && index > 0L;
            }
        });
        return result;
    }

    protected boolean srem(final String key, final Serializable value) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteValue = CommonUtil.transObj2ByteArray(value);
                Long index = connection.sRem(byteKey, byteValue);
                return index != null && index > 0L;
            }
        });
        return result;

    }

    protected boolean srem(final String key, final List values) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[][] byteValues = new byte[values.size()][];
                for (int i = 0; i < values.size(); i++) {
                    byteValues[i] = serializer.serialize(values.get(i));
                }
                Long index = connection.sRem(byteKey, byteValues);
                return true;
            }
        });
        return result;

    }

    /////////////////////////////////////////////////////////////////
    /////////////////////////// ZSet接口//////////////////////////////
    /////////////////////////////////////////////////////////////////
    protected boolean zadd(final String key, final Double score, final String value) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteValue = serializer.serialize(value);
                connection.zAdd(byteKey, score, byteValue);
                return true;
            }
        });
        return result;
    }

    protected boolean zrem(final String key, final String value) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteValue = serializer.serialize(value);
                connection.zRem(byteKey, byteValue);
                return true;
            }
        });
        return result;
    }

    protected Object zrange(final String key, final Long begin, final Long end) {
        Object result = redisTemplate.execute(new RedisCallback() {
            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);

                Set setValue = connection.zRange(byteKey, begin, end);
                Iterator iter = setValue.iterator();
                List listObj = new ArrayList();
                while (iter.hasNext()) {
                    Object obj = serializer.deserialize(iter.next());
                    listObj.add(obj);
                }
                return listObj;
            }
        });
        return result;
    }

    @SuppressWarnings("rawtypes")
    protected Object zrangebyscore(final String key, final Double begin, final Double end) {
        Object result = redisTemplate.execute(new RedisCallback() {
            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);

                Set setValue = connection.zRangeByScore(byteKey, begin, end);
                Iterator iter = setValue.iterator();
                List listObj = new ArrayList();
                while (iter.hasNext()) {
                    Object obj = serializer.deserialize((byte[]) iter.next());
                    listObj.add(obj);
                }
                return listObj;
            }
        });
        return result;
    }

    /////////////////////////////////////////////////////////////////
    /////////////////////////// HSet接口//////////////////////////////
    /////////////////////////////////////////////////////////////////
    protected boolean hset(final String key, final String field, final String value, final Long seconds) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteField = serializer.serialize(field);
                byte[] byteValue = serializer.serialize(value);
                connection.hSet(byteKey, byteField, byteValue);
                if (seconds.equals(0L)) {
                    connection.persist(byteKey);
                } else {
                    connection.expire(byteKey, seconds);// 设置过期时间
                }
                return true;
            }
        });
        return result;
    }

    protected boolean hset(final String key, final String field, final Serializable value, final Long seconds) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteField = serializer.serialize(field);
                byte[] byteValue = CommonUtil.transObj2ByteArray(value);
                connection.hSet(byteKey, byteField, byteValue);
                if (seconds.equals(0L)) {
                    connection.persist(byteKey);
                } else {
                    connection.expire(byteKey, seconds);// 设置过期时间
                }
                return true;
            }
        });
        return result;
    }

    protected Object hget(final String key, final String field) {
        Object result = redisTemplate.execute(new RedisCallback() {
            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteField = serializer.serialize(field);
                byte[] value = connection.hGet(byteKey, byteField);
                if (value == null) {
                    logger.error("未找到redis中保存的数据" + new String(byteKey));
                    return null;
                }
                Object dataObj = serializer.deserialize(value);
                return dataObj;
            }
        });
        return result;
    }

    protected  T hget(final String key, final String field, final Class clazz) {
        T result = redisTemplate.execute(new RedisCallback() {
            @Override
            public T doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteField = serializer.serialize(field);
                byte[] value = connection.hGet(byteKey, byteField);
                if (value == null) {

                    return null;
                }
                T dataObj = CommonUtil.transByteArray2Obj(value, clazz);
                return dataObj;
            }
        });
        return result;
    }

    protected Long hincrBy(final String key, final String field, Long incrBy) {
        Long result = redisTemplate.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteField = serializer.serialize(field);
                Long value = connection.hIncrBy(byteKey, byteField, incrBy);
                if (value == null) {
                    return 0L;
                }
                return value;
            }
        });
        return result;
    }

    protected Double hincrFloatBy(final String key, final String field, Double incrBy) {
        Double result = redisTemplate.execute(new RedisCallback() {
            @Override
            public Double doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteField = serializer.serialize(field);
                Double value = connection.hIncrBy(byteKey, byteField, incrBy);
                if (value == null) {
                    return 0.0;
                }
                return value;
            }
        });
        return result;
    }

    @SuppressWarnings("rawtypes")
    protected Object hkeys(final String key) {
        Object result = redisTemplate.execute(new RedisCallback() {
            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);

                Set setValue = connection.hKeys(byteKey);

                Iterator iter = setValue.iterator();

                List listObj = new ArrayList();
                while (iter.hasNext()) {
                    Object obj = serializer.deserialize((byte[]) iter.next());
                    listObj.add(obj);
                }
                return listObj;
            }
        });
        return result;
    }

    protected Set hkeysSerial(final String key) {
        Set result = redisTemplate.execute(new RedisCallback>() {
            @Override
            public Set doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);

                Set setValue = connection.hKeys(byteKey);

                Iterator iter = setValue.iterator();

                Set keys = new HashSet();
                while (iter.hasNext()) {
                    String obj = serializer.deserialize(iter.next());
                    keys.add(obj);
                }
                return keys;
            }
        });
        return result;
    }

    protected boolean hdel(final String key, final String field) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteField = serializer.serialize(field);
                connection.hDel(byteKey, byteField);
                return true;
            }
        });
        return result;
    }

    /**
     * 设置redis键过期时间
     *
     * @param key
     * @param seconds
     */
    protected boolean expire(final String key, final Long seconds) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                connection.expire(byteKey, seconds);// 设置过期时间
                return true;
            }
        });
        return result;
    }

    /**
     * @param keys
     */
    public void delete(List keys) {
        transRedisTemplate.delete(keys);
    }

    /**
     * 根据条件删除分页查询结果。
     */
    protected void deleteHashSetByPage(K hsetKey) {
        List listKeys = new ArrayList(1);
        listKeys.add(hsetKey);
        delete(listKeys);
    }

    /**
     * @param key
     * @param suppressTran 是否压制事务，true，表示在立即执行到redis（不需要等事务提交，同时也不会因事务失败而回滚）
     */
    public void delete(K key, final boolean suppressTran) {
        RedisTemplate realTemp = suppressTran ? redisTemplate : transRedisTemplate;
        realTemp.delete(key);
    }

    /**
     * 将 key 的值设为 value ，当且仅当 key 不存在, 若给定的 key 已经存在，则 SETNX 不做任何动作。
     *
     * @param key
     * @param value
     * @param seconds
     * @param suppressTran 是否压制事务，true，表示在立即执行到redis（不需要等事务提交，同时也不会因事务失败而回滚）
     * @return
     */
    protected Boolean setNx(final String key, final Serializable value, final long seconds, final boolean suppressTran) {
        RedisTemplate realTemp = suppressTran ? redisTemplate : transRedisTemplate;
        boolean result = realTemp.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteValue = CommonUtil.transObj2ByteArray(value);
                Boolean result = connection.setNX(byteKey, byteValue);
                if (seconds > 0 && (null == result && !suppressTran) || (result && suppressTran)) {
                    connection.expire(byteKey, seconds);
                }
                return result;
            }
        });
        return result;
    }

    /**
     * @param keys
     */
    public Long dbSize() {
        Long result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.dbSize();
            }
        });
        return result;
    }

    // public Set keys(K pattern) {
    // return redisTemplate.keys(pattern);
    // }

    public void clean(K pattern) {
        Set keySet = transRedisTemplate.keys(pattern);
        if (keySet != null && keySet.size() > 0) {
            List keyList = new ArrayList(keySet);
            delete(keyList);
        }
    }

    /**
     * pipeline方式获取数据
     *
     * @param keys
     * @return
     */
    protected List pipelineGet(final List keys) {
        return redisTemplate.executePipelined(new RedisCallback() {

            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                // 直接执行所有需要执行的命令，返回值由jedis通过底层connection.closePipeline()实现
                RedisSerializer serializer = getRedisSerializer();
                for (String key : keys) {
                    byte[] byteKey = serializer.serialize(key);
                    connection.get(byteKey);
                }
                // jedis api限制 只能返回null 否则会抛异常
                return null;
            }

        }, getRedisSerializer());

    }

    protected  List pipelineGet(final Collection keys, final Class clazz) {
        List tmps = redisTemplate.executePipelined(new RedisCallback() {

            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                // 直接执行所有需要执行的命令，返回值由jedis通过底层connection.closePipeline()实现
                RedisSerializer serializer = getRedisSerializer();
                for (String key : keys) {
                    byte[] byteKey = serializer.serialize(key);
                    connection.get(byteKey);
                }
                // jedis api限制 只能返回null 否则会抛异常
                return null;
            }

        }, getPojoSerializer(clazz));
        List result = new ArrayList(tmps.size());
        for (Object obj : tmps) {
            result.add(clazz.cast(obj));
        }
        return result;
    }

    /////////////////////////////////////////////////////////////////
    /////////////////////////// List 操作接口//////////////////////////
    /////////////////////////////////////////////////////////////////

    /**
     * 使用redis自身事物，向一个定长的列表加入元素，每次都要传入list的长度。即外部可以不用放入事务中。
     *
     * @param key
     * @param length
     * @param value
     * @param seconds
     * @return
     */
    protected boolean lpushWithTrim(final String key, final long length, final Serializable value, final Long seconds) {
        boolean result = redisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteValue = CommonUtil.transObj2ByteArray(value);
                if (length > 0L) {
                    connection.multi();
                    connection.lPush(byteKey, byteValue);
                    connection.lTrim(byteKey, 0, length - 1);
                    connection.exec();
                } else {
                    connection.lPush(byteKey, byteValue);
                }
                if (seconds.equals(0L)) {
                    connection.persist(byteKey);
                } else {
                    connection.expire(byteKey, seconds);// 设置过期时间
                }
                return true;
            }
        });
        return result;
    }

    /**
     * @param key
     * @param value
     * @param seconds
     * @return
     */
    protected boolean lpush(final String key, final Serializable value, final Long seconds) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteValue = CommonUtil.transObj2ByteArray(value);
                connection.lPush(byteKey, byteValue);
                if (seconds.equals(0L)) {
                    connection.persist(byteKey);
                } else {
                    connection.expire(byteKey, seconds);// 设置过期时间
                }
                return true;
            }
        });
        return result;
    }

    /**
     * @param key
     * @param begin
     * @param end
     * @return
     */
    protected boolean ltrim(final String key, long begin, long end) {
        boolean result = transRedisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                connection.multi();
                connection.lTrim(byteKey, begin, end);
                connection.exec();
                return true;
            }
        });
        return result;
    }

    /**
     * @param key
     * @param begin
     * @param end
     * @return
     */
    protected  List lrange(final String key, long begin, long end, final Class clazz) {
        List result = redisTemplate.execute(new RedisCallback>() {
            @Override
            public List doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                List listByteValues = connection.lRange(byteKey, begin, end);
                List listValue = new ArrayList(listByteValues.size());
                for (byte[] value : listByteValues) {
                    listValue.add(CommonUtil.transByteArray2Obj(value, clazz));
                }
                return listValue;
            }
        });
        return result;
    }

    /////////////////////////////////////////////////////////////
    /////////////////////// Pipeline 方式 /////////////////////////
    /////////////////////////////////////////////////////////////
    // 用pipeline的方式实现get多个数据
    protected List pget(final List keys) {

        @SuppressWarnings("unchecked")
        List result = (List) redisTemplate.execute(new RedisCallback() {
            @Override
            public List doInRedis(RedisConnection connection) throws DataAccessException {
                connection.openPipeline();

                RedisSerializer serializer = getRedisSerializer();
                for (String key : keys) {
                    byte[] byteKey = serializer.serialize(key);
                    connection.get(byteKey);
                }
                List pipeResult = connection.closePipeline();
                List strObjs = new ArrayList();
                for (Object tmp : pipeResult) {
                    byte[] bytes = (byte[]) tmp;
                    String tmpObj = serializer.deserialize(bytes);
                    strObjs.add(tmpObj);
                }
                return strObjs;
            }
        });

        return result;
    }

    /**
     * 判断 value 元素是否集合(set) key 的成员
     *
     * @param key
     * @param value
     * @return
     */
    protected boolean sIsMember(final String key, final String value) {
        boolean result = redisTemplate.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer serializer = getRedisSerializer();
                byte[] byteKey = serializer.serialize(key);
                byte[] byteVal = serializer.serialize(value);
                return connection.sIsMember(byteKey, byteVal);
            }
        });
        return result;
    }

    /**
     * 设置RedisTemplate 可以注入，不需要显示调用
     *
     * @return
     */
    protected RedisTemplate getRedisTemplate() {
        return transRedisTemplate;
    }

    /**
     * @param redisTemplate
     */
    public void setRedisTemplate(RedisTemplate redisTemplate) {
        this.transRedisTemplate = redisTemplate;
    }

    /**
     * @return
     */
    protected RedisSerializer getRedisSerializer() {

        return transRedisTemplate.getStringSerializer();
    }

    protected  RedisSerializer getPojoSerializer(Class clazz) {
        return new PojoSerializable(clazz);
    }

    public void closeConn() {
        RedisConnection conn = RedisConnectionUtils.getConnection(transRedisTemplate.getConnectionFactory());
        conn.close();
    }

}

























你可能感兴趣的:(BaseRedis)






    

  • redis学习（一）——初识redis
张宜强
笔记javaredisredis学习数据库

    redis学习（一）——初识redis非关系型数据库redis是非关系型数据库，和mysql不同，redis中的所有数据都是以key：value形式存在的两者区别SQL|NoSQL结构化|非结构化关联的|无关联sql查询|非sqlACID|BASEredis安装下载redis压缩包将redis压缩包放到任意目录下运行tar-xzfredis-6.2.6.tar.gz命令解压解压后进入目录运行mak
    

    • 

  • BaseRedis
liuyiyou

    importcom.iba.frame.redis.PojoSerializable;importcom.iba.frame.util.CommonUtil;importorg.apache.log4j.Logger;importorg.springframework.beans.factory.annotation.Autowired;importorg.springframework.dao.
    

    • 

  • Redis知识笔记及命令全
dustdawn
笔记复习面试

    文章目录NoSQL特性大数据的3V和3高四大分类分布式数据库中的CAP原理CAP+BASERedis特点应用场景Redis详解Redis数据类型Redis命令key关键字String字符串List列表Set集合Hash哈希Zset有序集合Redis配置Redis持久化RDB应用场景触发机制总结AOF配置之Appendfsync重写机制（Rewrite）总结对比使用Redis的事务事务命令正常执行放
    

    • 

  • Java实现的简单双向Map，支持重复Value
superlxw1234
java双向map

    关键字：Java双向Map、DualHashBidiMap
 
 
有个需求，需要根据即时修改Map结构中的Value值，比如，将Map中所有value=V1的记录改成value=V2，key保持不变。
 
数据量比较大，遍历Map性能太差，这就需要根据Value先找到Key，然后去修改。
 
即：既要根据Key找Value，又要根据Value
    

    • 

  • PL/SQL触发器基础及例子
百合不是茶
oracle数据库触发器PL/SQL编程

     
触发器的简介;
触发器的定义就是说某个条件成立的时候，触发器里面所定义的语句就会被自动的执行。因此触发器不需要人为的去调用，也不能调用。触发器和过程函数类似 过程函数必须要调用,
 
一个表中最多只能有12个触发器类型的,触发器和过程函数相似 触发器不需要调用直接执行,
触发时间：指明触发器何时执行，该值可取：
before：表示在数据库动作之前触发
    

    • 

  • [时空与探索]穿越时空的一些问题
comsci
问题

    
      我们还没有进行过任何数学形式上的证明,仅仅是一个猜想.....
      这个猜想就是; 任何有质量的物体(哪怕只有一微克)都不可能穿越时空,该物体强行穿越时空的时候,物体的质量会与时空粒子产生反应,物体会变成暗物质,也就是说,任何物体穿越时空会变成暗物质..(暗物质就我的理
    

    • 

  • easy ui datagrid上移下移一行
商人shang
js上移下移easyuidatagrid

    /**
* 向上移动一行
*
* @param dg
* @param row
*/
function moveupRow(dg, row) {
var datagrid = $(dg);
var index = datagrid.datagrid("getRowIndex", row);
if (isFirstRow(dg, row)) {
    

    • 

  • Java反射
oloz
反射

    本人菜鸟，今天恰好有时间，写写博客，总结复习一下java反射方面的知识，欢迎大家探讨交流学习指教
首先看看java中的Class
package demo;
public class ClassTest {
/*先了解java中的Class*/
public static void main(String[] args) {
//任何一个类都
    

    • 

  • springMVC 使用JSR-303 Validation验证
杨白白
springmvc

    JSR-303是一个数据验证的规范，但是spring并没有对其进行实现，Hibernate Validator是实现了这一规范的，通过此这个实现来讲SpringMVC对JSR-303的支持。
JSR-303的校验是基于注解的，首先要把这些注解标记在需要验证的实体类的属性上或是其对应的get方法上。
登录需要验证类
public class Login {
@NotEmpty
    

    • 

  • log4j
香水浓
log4j

    
log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, HTML, DATABASE
#log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, ROLLINGFILE, HTML
#console
log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender
log4
    

    • 

  • 使用ajax和history.pushState无刷新改变页面URL
agevs
jquery框架Ajaxhtml5chrome

    表现
如果你使用chrome或者firefox等浏览器访问本博客、github.com、plus.google.com等网站时，细心的你会发现页面之间的点击是通过ajax异步请求的，同时页面的URL发生了了改变。并且能够很好的支持浏览器前进和后退。
是什么有这么强大的功能呢？
HTML5里引用了新的API，history.pushState和history.replaceState，就是通过
    

    • 

  • centos中文乱码
AILIKES
centosOSssh

    一、CentOS系统访问 g.cn ，发现中文乱码。
于是用以前的方式：yum -y install fonts-chinese
CentOS系统安装后，还是不能显示中文字体。我使用 gedit 编辑源码，其中文注释也为乱码。
 
 
 
后来，终于找到以下方法可以解决，需要两个中文支持的包：
fonts-chinese-3.02-12.
    

    • 

  • 触发器
baalwolf
触发器

    触发器(trigger)：监视某种情况，并触发某种操作。
触发器创建语法四要素：1.监视地点(table) 2.监视事件(insert/update/delete) 3.触发时间(after/before) 4.触发事件(insert/update/delete)
语法：
create trigger triggerName
after/before 
    

    • 

  • JS正则表达式的i m g
bijian1013
JavaScript正则表达式

            g:表示全局（global)模式，即模式将被应用于所有字符串，而非在发现第一个匹配项时立即停止。         i:表示不区分大小写（case-insensitive）模式，即在确定匹配项时忽略模式与字符串的大小写。         m:表示
    

    • 

  • HTML5模式和Hashbang模式
bijian1013
JavaScriptAngularJSHashbang模式HTML5模式

            我们可以用$locationProvider来配置$location服务（可以采用注入的方式，就像AngularJS中其他所有东西一样）。这里provider的两个参数很有意思，介绍如下。
html5Mode
        一个布尔值，标识$location服务是否运行在HTML5模式下。
ha
    

    • 

  • [Maven学习笔记六]Maven生命周期
bit1129
maven

    从mvn test的输出开始说起
 
当我们在user-core中执行mvn test时，执行的输出如下：
 
/software/devsoftware/jdk1.7.0_55/bin/java -Dmaven.home=/software/devsoftware/apache-maven-3.2.1 -Dclassworlds.conf=/software/devs
    

    • 

  • 【Hadoop七】基于Yarn的Hadoop Map Reduce容错
bit1129
hadoop

    运行于Yarn的Map Reduce作业，可能发生失败的点包括
Task Failure
Application Master Failure
Node Manager Failure
Resource Manager Failure
1. Task Failure
任务执行过程中产生的异常和JVM的意外终止会汇报给Application Master。僵死的任务也会被A
    

    • 

  • 记一次数据推送的异常解决端口解决
ronin47
记一次数据推送的异常解决

    　　 需求：从db获取数据然后推送到B
        程序开发完成，上jboss,刚开始报了很多错，逐一解决，可最后显示连接不到数据库。机房的同事说可以ping 通。
　　  自已画了个图，逐一排除，把linux 防火墙　和　setenforce　设置最低。
　　　service iptables stop

    

    • 

  • 巧用视错觉-UI更有趣
brotherlamp
UIui视频ui教程ui自学ui资料

    我们每个人在生活中都曾感受过视错觉（optical illusion）的魅力。
视错觉现象是双眼跟我们开的一个玩笑，而我们往往还心甘情愿地接受我们看到的假象。其实不止如此，视觉错现象的背后还有一个重要的科学原理——格式塔原理。
格式塔原理解释了人们如何以视觉方式感觉物体，以及图像的结构，视角，大小等要素是如何影响我们的视觉的。
在下面这篇文章中，我们首先会简单介绍一下格式塔原理中的基本概念，
    

    • 

  • 线段树-poj1177-N个矩形求边长（离散化+扫描线）
bylijinnan
数据结构算法线段树

    package com.ljn.base;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
/**
* POJ 1177 (线段树+离散化+扫描线)，题目链接为http://poj.org/problem?id=1177 
    

    • 

  • HTTP协议详解
chicony
http协议

    引言                                 
    

    • 

  • Scala设计模式
chenchao051
设计模式scala

    Scala设计模式
       
       我的话： 在国外网站上看到一篇文章，里面详细描述了很多设计模式，并且用Java及Scala两种语言描述，清晰的让我们看到各种常规的设计模式，在Scala中是如何在语言特性层面直接支持的。基于文章很nice，我利用今天的空闲时间将其翻译，希望大家能一起学习，讨论。翻译
    

    • 

  • 安装mysql
daizj
mysql安装

    安装mysql
  (1)删除linux上已经安装的mysql相关库信息。rpm  -e  xxxxxxx   --nodeps (强制删除)
     执行命令rpm -qa |grep mysql 检查是否删除干净
  (2)执行命令  rpm -i MySQL-server-5.5.31-2.el
    

    • 

  • HTTP状态码大全
dcj3sjt126com
http状态码

    完整的 HTTP 1.1规范说明书来自于RFC 2616，你可以在http://www.talentdigger.cn/home/link.php?url=d3d3LnJmYy1lZGl0b3Iub3JnLw%3D%3D在线查阅。HTTP 1.1的状态码被标记为新特性，因为许多浏览器只支持 HTTP 1.0。你应只把状态码发送给支持 HTTP 1.1的客户端，支持协议版本可以通过调用request
    

    • 

  • asihttprequest上传图片
dcj3sjt126com
ASIHTTPRequest

    NSURL *url =@"yourURL";
ASIFormDataRequest*currentRequest =[ASIFormDataRequest requestWithURL:url];
[currentRequest setPostFormat:ASIMultipartFormDataPostFormat];[currentRequest se
    

    • 

  • C语言中，关键字static的作用
e200702084
C++cC#

    在C语言中，关键字static有三个明显的作用：
1)在函数体，局部的static变量。生存期为程序的整个生命周期，（它存活多长时间）；作用域却在函数体内（它在什么地方能被访问（空间））。
一个被声明为静态的变量在这一函数被调用过程中维持其值不变。因为它分配在静态存储区，函数调用结束后并不释放单元，但是在其它的作用域的无法访问。当再次调用这个函数时，这个局部的静态变量还存活，而且用在它的访
    

    • 

  • win7/8使用curl
geeksun
win7

    1.  WIN7/8下要使用curl，需要下载curl-7.20.0-win64-ssl-sspi.zip和Win64OpenSSL_Light-1_0_2d.exe。 下载地址： 
http://curl.haxx.se/download.html 请选择不带SSL的版本，否则还需要安装SSL的支持包   2.  可以给Windows增加c
    

    • 

  • Creating a Shared Repository; Users Sharing The Repository
hongtoushizi
git

    转载自：  
http://www.gitguys.com/topics/creating-a-shared-repository-users-sharing-the-repository/ Commands discussed in this section:
git init –bare
git clone
git remote
git pull
git p
    

    • 

  • Java实现字符串反转的8种或9种方法
Josh_Persistence
异或反转递归反转二分交换反转java字符串反转栈反转

    注：对于第7种使用异或的方式来实现字符串的反转，如果不太看得明白的，可以参照另一篇博客：
http://josh-persistence.iteye.com/blog/2205768
 
/**
*
*/
package com.wsheng.aggregator.algorithm.string;
import java.util.Stack;
/**

    

    • 

  • 代码实现任意容量倒水问题
home198979
PHP算法倒水

    形象化设计模式实战             HELLO!架构                     redis命令源码解析
 
倒水问题：有两个杯子，一个A升，一个B升，水有无限多，现要求利用这两杯子装C
    

    • 

  • Druid datasource
zhb8015
druid

    推荐大家使用数据库连接池 DruidDataSource. http://code.alibabatech.com/wiki/display/Druid/DruidDataSource DruidDataSource经过阿里巴巴数百个应用一年多生产环境运行验证，稳定可靠。 它最重要的特点是：监控、扩展和性能。 下载和Maven配置看这里： http
    

    • 

  • 两种启动监听器ApplicationListener和ServletContextListener
spjich
javaspring框架

    引言:有时候需要在项目初始化的时候进行一系列工作，比如初始化一个线程池，初始化配置文件，初始化缓存等等，这时候就需要用到启动监听器，下面分别介绍一下两种常用的项目启动监听器
 
ServletContextListener 
特点: 依赖于sevlet容器，需要配置web.xml
使用方法:
public class StartListener implements 
    

    • 

  • JavaScript Rounding Methods of the Math object
何不笑
JavaScriptMath

        The next group of methods has to do with rounding decimal values into integers. Three methods — Math.ceil(),  Math.floor(), and  Math.round() — handle rounding in differen
    

    •