redis 存储，java实现类

redis 存储实现类

package receiver;

import com.alibaba.fastjson.JSONObject;
import entity.CFFEBaseData;
import entity.HKBaseData;
import entity.StockMDSRInfo;
import entity.USSBaseData;
import redis.clients.jedis.*;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * Created by chen on 2016/10/13.
 */
public class RedisClient {
    public static String STOCK_BASE_KEY = "STOCK_BASE_INFO";
    public static String STOCK_TRADE_KEY = "STOCK_TRADE_INFO";
    private Jedis jedis;//非切片额客户端连接
    private JedisPool jedisPool;//非切片连接池
//    private ShardedJedis shardedJedis;//切片的客户端连接
//    private ShardedJedisPool shardedJedisPool;//切片连接池

    public RedisClient() {
        initialPool();
        initialShardedPool();
//        shardedJedis = shardedJedisPool.getResource();
        jedis = jedisPool.getResource();
        Long db = jedis.getDB();
        System.out.println("db==="+db);
    }

    /**
     * 初始化非切片池
     */
    private synchronized void initialPool() {
        // 池基本配置
        if(null == jedisPool){
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(20);
            config.setMaxIdle(5);
            config.setMaxWaitMillis(1000l);
            config.setTestOnBorrow(false);
            jedisPool = new JedisPool(config,"127.0.0.1",6379, 3000, null, 1);
        }
    }

    /**
     * 初始化切片池
     */
    private void initialShardedPool() {
        // 池基本配置
//        JedisPoolConfig config = new JedisPoolConfig();
//        config.setMaxTotal(20);
//        config.setMaxIdle(5);
//        config.setMaxWaitMillis(1000l);
//        config.setTestOnBorrow(false);
//        // slave链接
//        List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
//        shards.add(new JedisShardInfo("127.0.0.1", 6379, "master"));
//        // 构造池
//        shardedJedisPool = new ShardedJedisPool(config, shards);
    }

    public void show() {
//        KeyOperate();
//        jedisPool.returnResource(jedis);
//        shardedJedisPool.returnResource(shardedJedis);
    }

    public void zadd(String key, Double score, String val){
        jedis.zadd(key, score, val);
    }


    public List<String> zrange(String key, long startScore, long endScore){
        List<String> list = new ArrayList<>();
        Set<Tuple> datas = jedis.zrangeWithScores(key, startScore, endScore);
        if(null!=datas && !datas.isEmpty()){
            for(Tuple tuple : datas){
                list.add(tuple.getElement());
            }
        }
        return list;
    }

    /**
     * 保存StockEntity数据
     * @param key
     * @param stockInfo
     */
    public void saveBaseInfo(String key, Stock stockInfo){
        String json = JSONObject.toJSONString(stockInfo);
        jedis.lpush(key, json);
    }

    /**
     * 保存StockEntity数据
     * @param key
     * @param stockInfo
     */
    public void saveBaseInfo2(String key, StockMDSRInfo stockInfo){
        String json = JSONObject.toJSONString(stockInfo);
        jedis.lpush(key, json);
    }

    public void saveBaseInfo4001(String key, CFFEBaseData stockInfo){
        String json = JSONObject.toJSONString(stockInfo);
        jedis.lpush(key, json);
    }
    public void saveBaseInfo101(String key, USSBaseData stockInfo){
        String json = JSONObject.toJSONString(stockInfo);
        jedis.lpush(key, json);
    }
    public void saveBaseInfo801(String key, HKBaseData stockInfo){
        String json = JSONObject.toJSONString(stockInfo);
        jedis.lpush(key, json);
    }

    /**
     * 根据key获取股票列表
     * @param key
     * @return
     */
    public List<Stock> fetchBaseInfo(String key, int startIndex, int endIndex){
        List<Stock> result = new ArrayList<>();
        List<String> list = jedis.lrange(key, startIndex, endIndex);
        if(null!=list && !list.isEmpty()){
            for (String str : list) {
                Stock stock = JSONObject.parseObject(str, Stock.class);
                result.add(stock);
            }
        }
        return result;
    }

    /**
     * 保存StockDate数据
     * @param key
     * @param dateStr
     */
    public void saveStockDateInfo(String key, String dateStr){
        jedis.lpush(key, dateStr);
    }


    public boolean existsStockDateInfo(String key, String dateStr){
        key = "";
        return jedis.exists(key);
    }

    /**
     * 根据key获取StockDate数据
     * @param key
     * @return
     */
    public List<String> fetchStockDateInfo(String key, int startIndex, int endIndex){
        return jedis.lrange(key, startIndex, endIndex-1);
    }

    public void saveStockTradeInfo(String key, Date dateTime, StockMDSRInfo stock){
        String json = JSONObject.toJSONString(stock);
        jedis.zadd(key, genScoreByFactTime(stock.getDateTime()), json);
    }

    public List<StockMDSRInfo> fetchAll(String key) {
        List<StockMDSRInfo> list = new ArrayList<StockMDSRInfo>();
        //通过数组下标来取缓存的值
        Set<Tuple> datas = jedis.zrangeWithScores(key, 0, Integer.MAX_VALUE);
        for (Tuple tuple : datas) {
            StockMDSRInfo stock = JSONObject.parseObject(tuple.getElement(), StockMDSRInfo.class);
            list.add(stock);
        }
        return list;
    }


    public List<StockMDSRInfo> fetchByPage(String key, int page, int pageSize) {
        List<StockMDSRInfo> list = new ArrayList<StockMDSRInfo>();
        int index = pageSize*(page-1);
        System.out.println("page======="+page+"pageSize======="+pageSize+"index======="+index);
        //通过数组下标来取缓存的值
        Set<Tuple> datas = jedis.zrangeWithScores(key, index, index+pageSize-1);
        for (Tuple tuple : datas) {
            StockMDSRInfo stock = JSONObject.parseObject(tuple.getElement(), StockMDSRInfo.class);
            list.add(stock);
        }
        return list;
    }



    public List<StockMDSRInfo> fetchAllByConditions(String key,String code) {
        List<StockMDSRInfo> list = new ArrayList<StockMDSRInfo>();
        //通过数组下标来取缓存的值
        Set<Tuple> datas = jedis.zrangeWithScores(key, 0, Integer.MAX_VALUE);
        for (Tuple tuple : datas) {
            StockMDSRInfo stock = JSONObject.parseObject(tuple.getElement(), StockMDSRInfo.class);
            if(null!=tuple.getElement() && code.equals(stock.getEmCode())){
                list.add(stock);
            }
        }
        return list;
    }


    /**
     * 根据发布时间生成Score
     * @param factTime 发布时间
     * @return
     */
    private long genScoreByFactTime(Date factTime){
        long timeIndex = factTime.getTime();
        timeIndex = timeIndex - 2*timeIndex;
        return timeIndex;
    }



    /**
     * 回收资源
     */
    public void returnResource(){
        jedisPool.returnResource(jedis);
    }

    private void KeyOperate() {
        System.out.println("======================key==========================");
        // 清空数据
        System.out.println("清空库中所有数据："+jedis.flushDB());
        System.out.println("系统中所有键如下：");
        Set<String> keys = jedis.keys("*");
        Iterator<String> it=keys.iterator() ;
        while(it.hasNext()){
            String key = it.next();
            System.out.println(key);
        }
        // 删除某个key,若key不存在，则忽略该命令。
        System.out.println("系统中删除key002: "+jedis.del("key002"));
        // 设置 key001的过期时间
        System.out.println("设置 key001的过期时间为5秒:"+jedis.expire("key001", 5));
    }

    public static void main(String[] args) throws ParseException {
        RedisClient redisClient = new RedisClient();
        redisClient.show();
        Stock stock = new Stock();
        stock.setCode("00015");
        redisClient.saveBaseInfo(RedisClient.STOCK_BASE_KEY, stock);
        Stock stock2 = new Stock();
        stock2.setCode("00016");
        redisClient.saveBaseInfo(RedisClient.STOCK_BASE_KEY, stock2);

        List<Stock> list = redisClient.fetchBaseInfo(RedisClient.STOCK_BASE_KEY, 0, Integer.MAX_VALUE);
        for (Stock mo : list) {
            System.out.println(JSONObject.toJSONString(mo));
        }
//
        String key = RedisClient.STOCK_BASE_KEY+"_008";
        redisClient.saveStockDateInfo(key, "2016-10-19");
        redisClient.saveStockDateInfo(key, "2016-10-20");
        List<String> datas = redisClient.fetchStockDateInfo(key, 0, 5);
        for (String str : datas) {
            System.out.println(str);
        }

        StockMDSRInfo sm = new StockMDSRInfo();
        sm.setEmCode("000266");
        sm.setDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2016-10-15 16:48:15"));
        redisClient.saveStockTradeInfo(RedisClient.STOCK_TRADE_KEY+"===", new Date(), sm);
        StockMDSRInfo sm2 = new StockMDSRInfo();
        sm2.setEmCode("000256");
        sm2.setDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2016-10-16 16:39:15"));
        redisClient.saveStockTradeInfo(RedisClient.STOCK_TRADE_KEY+"_2016-10-15", new Date(), sm2);

        List<StockMDSRInfo> sms = redisClient.fetchAll(RedisClient.STOCK_TRADE_KEY);
        for (StockMDSRInfo mo : sms) {
            System.out.println(JSONObject.toJSONString(mo)+"-------------"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(mo.getDateTime()));
        }

        sms = redisClient.fetchByPage(RedisClient.STOCK_TRADE_KEY+"===", 3, 2);
        for (StockMDSRInfo mo : sms) {
            System.out.println(JSONObject.toJSONString(mo)+"-------------"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(mo.getDateTime()));
        }
    }

    /**
     * redis中String类型操作：字符串+数字+bit
     */
    public void stringCmdTest(){
        System.out.println("----------------redis-String-----------------");
        //set:返回操作结果
        System.out.println("name=>wsy:"+jedis.set("name","wsy"));

        //get:value
        System.out.println("name:"+jedis.get("name"));

        //append:字符串长度
        System.out.println("append:"+jedis.append("name","_ss"));

        //strlen:字符串长度
        System.out.println("strlen:"+jedis.strlen("name"));

        //getrange:返回不包括起始坐标的值
        System.out.println("getrange:"+jedis.getrange("name", 10, 13));

        //setrange:从起始坐标考试替换，未替换的保持
        System.out.println("setrange:"+jedis.setrange("name", 10, "#"));

        //mset:批量设置，返回批量设置结果
        System.out.println("mset:"+jedis.mset("name","wsy","age", "29"));

        //mget:返回数组
        System.out.println("mget:"+jedis.mget("name","age"));

        //incr:value自增1后，返回value
        System.out.println("incr:"+jedis.incr("age"));

        //incr:value自增传参值后，返回value
        System.out.println("incrBy:"+jedis.incrBy("age",3));

        //decr:value自减1，返回value
        System.out.println("decr:"+jedis.decr("age"));

        //decrBy:value自减入参值，返回value
        System.out.println("decrBy:"+jedis.decrBy("age",3));

        //setex:设置key值+有效时间，如果key存在则覆盖value
        System.out.println("setex:"+jedis.setex("phone",10,"13600000001"));

        //setnx:当key不存在时，设置才成功
        System.out.println("setnx:"+jedis.setnx("address","china"));

        //del:删除对应key
        System.out.println("del:"+jedis.del("address1"));

        System.out.println("----------------redis-String-----------------\n");

    }

    /**
     * redis中hash类型常用操作
     * @param
     */
    public void hashMapCmdTest(){
        System.out.println("----------------redis-HashMap-----------------");
        //hset:返回值为key为新返回1，为旧覆盖旧值返回0
        System.out.println("hset:"+jedis.hset("user","name","wangshaoyi"));

        Map map = new HashMap();
        map.put("name","wsy");
        map.put("age","29");
        //hmset:map对象
        System.out.println("hmset:" + jedis.hmset("user", map));

        //hexists:判断hashmap中key是否存在
        System.out.println("hexists:"+jedis.hexists("user","age"));

        //hget:获取map中key对应的value
        System.out.println("hget:"+jedis.hget("user","name"));

        //hgetAll:获取map中所有对象
        System.out.println("hgetAll:"+jedis.hgetAll("user"));

        //hkeys:获取map中所有key
        System.out.println("hkeys:"+jedis.hkeys("user"));

        //hvals:获取map中所有value
        System.out.println("hvals:"+jedis.hvals("user"));


        //hmget:批量获取keys的对象，返回List
        System.out.println("hmget:"+jedis.hmget("user","age","name"));

        //hlen:map的大小
        System.out.println("hlen:"+jedis.hlen("user"));

        //hdel:删除map中对应key,正确删除返回1
        System.out.println("hdel:"+jedis.hdel("user","age0"));

        System.out.println("----------------redis-HashMap-----------------\n");

    }

    public void listCmdTest(){
        System.out.println("----------------redis-List-----------------");
        //
        jedis.del("contacts");
        jedis.del("contacts_old");


        //lpush:批量头部插入，返回List的size
        System.out.println("lpush:"+jedis.lpush("contacts","xx","yy","zz"));

        //lpushx:单个头部插入，返回List的size
        System.out.println("lpushx:"+jedis.lpushx("contacts","aa"));

        //linsert:指定对象位置(前or后)插入
        System.out.println("linsert:"+jedis.linsert("contacts", BinaryClient.LIST_POSITION.BEFORE,"zz","bb"));

        //lset:将指定的位置设置值（替换旧值）
        System.out.println("lset:"+jedis.lset("contacts",2,"cc"));

        //lpop:链表头的对象
        System.out.println("lpop:"+jedis.lpop("contacts"));

        //lrange:获取list指定start、end位置value
        System.out.println("lrange:"+jedis.lrange("contacts",1,3));

        //ltrim:只剩start\end中list值，其余删除
        System.out.println("ltrim:"+jedis.ltrim("contacts",1,3));

        //lrem:删除list指定值（次数指定），返回删除个数
        System.out.println("lrem:"+jedis.lrem("contacts",2,"yy"));

        //rpoplpush:将源list尾部对象移到目标list对象头部
        System.out.println("rpoplpush:"+jedis.rpoplpush("contacts","contacts_old"));

        //rpush:在list尾部对象添加值
        System.out.println("rpush:"+jedis.rpush("contacts","aa","bb"));

        //rpop:移除在list尾部值，返回移除的对象
        System.out.println("rpop:"+jedis.rpop("contacts"));

        //brpop:阻塞尾部对象抛出，指定超时时间，返回抛出值
        System.out.println("brpop:"+jedis.brpop(1,"contacts"));

        System.out.println("blpop:"+jedis.blpop(1, "contacts"));

        System.out.println("blpop（阻塞1秒返回）:"+jedis.blpop(1, "contacts"));

        System.out.println("----------------redis-List-----------------\n");


    }

    public void setCmdTest(){
        System.out.println("----------------redis-Set-----------------");
        jedis.del("phones");
        jedis.del("phones_old");
        jedis.del("phones_old_1");
        jedis.del("phones_new");


        //sadd:集合添加元素,返回添加成功后数据
        System.out.println("sadd:"+jedis.sadd("phones","13600000001","13300000001"));
        System.out.println("sadd:"+jedis.sadd("phones","13600000002","13300000002"));

        //scard:返回集合中元素数
        System.out.println("scard:"+jedis.scard("phones"));

        jedis.sadd("phones_old","13600000002");
        jedis.sadd("phones_old_1","13300000001");

        //sdiff:首set与其他set之间的差集，返回差集值
        System.out.println("sdiff:"+jedis.sdiff("phones","phones_old","phones_old_1"));

        //sdiffstore:首set与其他set之间的差集保存至新set，返回差集数
        System.out.println("sdiffstore:"+jedis.sdiffstore("phones_new","phones","phones_old"));

        //sinter:返回集合的交集
        System.out.println("sinter:"+jedis.sinter("phones","phones_new"));

        //sismember:判断value是否为set的值
        System.out.println("sismember:"+jedis.sismember("phones","13600000001"));

        //smembers:返回集合中成员
        System.out.println("smembers:"+jedis.smembers("phones"));

        //smove:将首源set中元素移动目标set，返回移动数
        System.out.println("smove:"+jedis.smove("phones","phones_new","13600000002"));

        //spop:随机移除set的一元素，返回移除元素
        System.out.println("spop:"+jedis.spop("phones"));

        //srandmember:随机取出集合中一个元素
        System.out.println("srandmember:"+jedis.srandmember("phones_new"));

        //srem:删除集合中指定元素
        System.out.println("srem:"+jedis.srem("phones_new","13600000002"));

        //sunion:集合中并集
        System.out.println("sunion:"+jedis.sunion("phones","phones_new","phones_old"));

        System.out.println("----------------redis-Set-----------------\n");

    }

    public void sortedSetTest(){

        System.out.println("----------------redis-SortedSet-----------------");
        jedis.del("scores");
        jedis.del("scores_1");
        jedis.del("scores_total");
        jedis.del("score_inter");
        jedis.del("score_max");



        //zadd:sortedSet添加元素
        System.out.println("zadd:"+jedis.zadd("scores", 610.5, "xx"));
        jedis.zadd("scores", 630, "yy");

        //zcard:返回sortedset中元素数
        System.out.println("zcard:"+jedis.zcard("scores"));

        //zcount:返回指定分值（包括）的元素数
        System.out.println("zcount:"+jedis.zcount("scores",610,620));

        //zincrby:将指定值分数加分，返回加后的分数
        System.out.println("zincrby:"+jedis.zincrby("scores",10,"xx"));

        //zrange:返回指定坐标的值
        System.out.println("zrange:"+jedis.zrange("scores",0,1));

        //zrangeByScore:返回指定分数范围内的对象
        System.out.println("zrangeByScore:"+jedis.zrangeByScore("scores",600,700));

        //zrank:返回指定值的位置（分数低->高，0开始）
        System.out.println("zrank:"+jedis.zrank("scores","yy"));

        //zrevrank:返回指定值的位置（分数高->低，0开始）
        System.out.println("zrevrank:"+jedis.zrevrank("scores", "yy"));


        //zrem:删除，其中还有zremrangeByRank\zremrangeByScore
        System.out.println("zrem:"+jedis.zrem("scores", "yy"));

        jedis.zadd("scores", 630, "yy");
        jedis.zadd("scores", 640, "zz");
        //zrevrange：获取指定位置数据（分数从高->低）
        System.out.println(":"+jedis.zrevrange("scores",0,1));


        System.out.println("zrangeByScoreWithScores:"+jedis.zrangeByScoreWithScores("scores",600,700));

        //zscore:获取指定分数
        System.out.println("zscore:"+jedis.zscore("scores", "xx"));
        jedis.zadd("scores_1", 630.5, "xx");
        jedis.zadd("scores_1",610.5,"bb");
        jedis.zadd("scores_1",622.5,"cc");

        //zunionstore:sortedset集合的并集并保存,如果集合中元素相同，则分数相加
        System.out.println("zunionstore:"+jedis.zunionstore("score_total","scores","scores_1"));


        ZParams zParams = new ZParams();
        zParams.aggregate(ZParams.Aggregate.MAX);//指定分数操作：+，最小，最大
        zParams.weightsByDouble(1,0.1);//分数中的乘法因子
        System.out.println("zunionstore:"+jedis.zunionstore("score_max",zParams,"scores","scores_1"));

        //zinterstore:集合元素取交集，相同元素值相加(默认)
        System.out.println("zinterstore:"+jedis.zinterstore("score_inter","scores","scores_1"));


        System.out.println("----------------redis-SortedSet-----------------\n");

    }
}

redis项目应用代码

package com.wamei.dao.impl;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SimplePropertyPreFilter;
import com.wamei.controller.MobileController;
import com.wamei.controller.MobileVersion2Controller;
import com.wamei.dao.ArticleRedisCacheDao;
import com.wamei.entity.*;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 操作redis类
 * @author Soul.Rain
 *
 */
@Service("articleRedisCacheDao")
public class ArticleRedisCacheDaoImpl implements ArticleRedisCacheDao {
	@Resource(name="redisTemplate")
	private ZSetOperations<String,String> zsetOps;
	@Resource(name="redisTemplate")
	private RedisTemplate<String, Object> redisTemplate;

	private final static Logger logger = Logger.getLogger(ArticleRedisCacheDaoImpl.class);


	@Override
	public void saveObject(String key, Object object) {
		redisTemplate.opsForHash().put(key.hashCode()+"", key, object);
	}

	@Override
	public Object fetchObject(String key) {
		return redisTemplate.opsForHash().get(key.hashCode()+"", key);
	}

	@Override
	public void deleteObject(String key) {
		redisTemplate.opsForHash().delete(key.hashCode()+"", key);
	}

	@Override
	public void deleteViewCache(String key) {
		List<Object> list = redisTemplate.opsForList().range(key, 0, -1);
		if(null!=list && !list.isEmpty()){
			for(int i=0;i<list.size();i++){
				redisTemplate.opsForList().remove(key, i, list.get(i));
			}
		}
	}

	@Override
	public void saveCount(String key, int count) {
		redisTemplate.opsForValue().set(key, count);
	}

	@Override
	public int fetchCount(String key) {
		int count = 0;
		try{
			String keyv = String.valueOf(redisTemplate.opsForValue().get(key));
			if(StringUtils.isNotEmpty(keyv)){
				count = Integer.valueOf(keyv);
			}
		}catch (Exception e){
			count = 0;
		}
		return count;
	}

	@Override
	public void saveArticleViewRecord(String key, String articleId, String token) {
		ArticleViewRecord avr = new ArticleViewRecord();
		avr.setArticle(articleId);
		avr.setCreator(token);
		avr.setCreateTime(new Date());
		redisTemplate.opsForList().leftPush(key, avr);
	}

	@Override
	public List<ArticleViewRecord> fetchArticleViewRecord(String key) {
		List<ArticleViewRecord> result = new ArrayList<>();
		List<Object> list = redisTemplate.opsForList().range(key, 0, -1);
		for (Object obj : list){
			ArticleViewRecord avr = (ArticleViewRecord)obj;
			result.add(avr);
		}
		return result;
	}

	@Override
	public void saveAdvertiseClickRecord(String key, String advertiseId, String ipAddress, String token) {
		AdvertiseClickRecord acr = new AdvertiseClickRecord();
		acr.setAdvertise(advertiseId);
		acr.setCreator(token);
		acr.setCreateTime(new Date());
		acr.setIpAddress(ipAddress);
		redisTemplate.opsForList().leftPush(key, acr);
	}

	@Override
	public List<AdvertiseClickRecord> fetchAdvertiseClickRecord(String key) {
		List<AdvertiseClickRecord> result = new ArrayList<>();
		List<Object> list = redisTemplate.opsForList().range(key, 0, -1);
		for (Object obj : list){
			AdvertiseClickRecord acr = (AdvertiseClickRecord)obj;
			result.add(acr);
		}
		return result;
	}

	@Override
	public void saveAdvertiseViewRecord(String key, String advertiseId, String token) {
		AdvertiseViewRecord avr = new AdvertiseViewRecord();
		avr.setAdvertise(advertiseId);
		avr.setCreator(token);
		avr.setCreateTime(new Date());
		redisTemplate.opsForList().leftPush(key, avr);
	}

	@Override
	public List<AdvertiseViewRecord> fetchAdvertiseViewRecord(String key) {
		List<AdvertiseViewRecord> result = new ArrayList<>();
		List<Object> list = redisTemplate.opsForList().range(key, 0, -1);
		for (Object obj : list){
			AdvertiseViewRecord avr = (AdvertiseViewRecord)obj;
			result.add(avr);
		}
		return result;
	}

	/**
	 * 设置超时时间
	 * @param key
	 * @param seconds
     */
	@Override
	public void expire(String key, int seconds){
//		zsetOps.getOperations().expire(key, seconds, null);
		zsetOps.getOperations().expire(key, seconds, null);
	}

	/**
	 * 更新缓存
	 * @param key 缓存Key
	 * @param obj 缓存对象
     */
	@Override
	public void update(String key, Article obj){
		try {
			this.delete(key, obj);
			this.save(key, obj);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 根据发布时间生成Score
	 * @param factTime 发布时间
	 * @return
     */
	private long genScoreByFactTime(Date factTime){
		long timeIndex = factTime.getTime();
//		timeIndex = timeIndex - (2 * timeIndex);
//		return timeIndex;
		return -timeIndex;
	}



	@Override
	public void save(String key, Article obj) {
		logger.info("开始保存Redis文章，"+obj.getTitle()+"==="+obj.getFactTimeStr());
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		//放到redis
		Random rand = new Random();
		long likesCount = rand.nextInt(100)+120;
		obj.setLikesCount(likesCount);
		SimplePropertyPreFilter filter = new SimplePropertyPreFilter();
		filter.getExcludes().add("creator");
		String json = JSONObject.toJSONString(obj, filter);
		Date factTime;
		try{
			factTime = sdf.parse(obj.getFactTimeStr());
		}catch (Exception e){
			factTime = obj.getFactTime();
		}
		long score = genScoreByFactTime(factTime);
		zsetOps.add(key, json, score);
		logger.info("保存Redis文章结束，"+obj.getTitle()+"==="+obj.getFactTimeStr()+"==="+score);
	}

	@Override
	public void saveAll(String key, List<Article> datas) {
		Iterator<Article> data = datas.iterator();
		while(data.hasNext()) {
			save(key, data.next());
		}
		
	}

	@Override
	public void saveListSort(String key, List<Article> datas) {
		Iterator<Article> data = datas.iterator();
		Integer n=0;
		while(data.hasNext()) {
//			zsetOps.add(key, data.next(), n);
			String jsonStr = JSONObject.toJSONString(data.next());
			zsetOps.add(key, jsonStr, n);
			n++;
		}

	}

	@Override
	public void delete(String key, Article obj) {
		try {
			List<String> list = new ArrayList<>();
			long factTimeScore = genScoreByFactTime(obj.getFactTime());
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(obj.getFactTime());
			calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) -1);
			Set<String> datas = zsetOps.rangeByScore(key, factTimeScore, genScoreByFactTime(calendar.getTime()), 0, 10);
			for (String str : datas) {
				Article article = JSONObject.parseObject(str, Article.class);
				if(article.getId().equals(obj.getId())){
					list.add(str);
				}
			}
			if(list.isEmpty()){
				Set<TypedTuple<String>> articleList = zsetOps.rangeWithScores(key, 0, 10);
				for (TypedTuple<String> typedTuple : articleList) {
					Article article = JSONObject.parseObject(typedTuple.getValue(), Article.class);
					if(article.getId().equals(obj.getId())){
						list.add(typedTuple.getValue());
					}
				}
			}
			if(!list.isEmpty()){
				for(int i=list.size()-1;i>=0;i--){
//					zsetOps.removeRangeByScore(key, scoreList.get(i), scoreList.get(i));
					zsetOps.remove(key, list.get(i));
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@Override
	public void deleteSort(String key, Article obj) {
		try {
			List<String> list = new ArrayList<>();
//			List<Article> list = new ArrayList<>();
			Set<TypedTuple<String>> datas = zsetOps.rangeWithScores(key, 0, -1);
			for (TypedTuple<String> typedTuple : datas) {
				Article article = JSONObject.parseObject(typedTuple.getValue(), Article.class);
				if(null!=typedTuple.getValue() && article.getId().equals(obj.getId())){
//					zsetOps.removeRangeByScore(key, typedTuple.getScore(),typedTuple.getScore());
					list.add(typedTuple.getValue());
				}
			}
			if(!list.isEmpty()){
				for(int i=list.size()-1;i>=0;i--){
					zsetOps.remove(key, list.get(i));
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	@Override
	public void deleteCache(String key) {
		try{
			zsetOps.removeRange(key, 0, Integer.MAX_VALUE);
		}catch (Exception e){
			System.err.println("Clear Ops Redis Cache."+e.getMessage());
		}
	}

	@Override
	public Long count(String key) {
		return zsetOps.size(key);
	}


	@Override
	public List<Article> fetchAll(String key) {
//		List<Article> list = new ArrayList<Article>();
		//通过数组下标来取缓存的值
//		Set<TypedTuple<Article>> datas = zsetOps.rangeWithScores(key, 0, zsetOps.size(key)-1);
//		for (TypedTuple<Article> typedTuple : datas) {
//			list.add(typedTuple.getValue());
//		}
		List<Article> list = new ArrayList<Article>();
		//通过数组下标来取缓存的值
		Set<TypedTuple<String>> datas = zsetOps.rangeWithScores(key, 0, zsetOps.size(key)-1);
		for (TypedTuple<String> typedTuple : datas) {
			Article article = JSONObject.parseObject(typedTuple.getValue(), Article.class);
			list.add(article);
		}
		return list;
	}

	@Override
	public List<Article> fetchByPage(String key, long start, long step) {
		List<Article> list = new ArrayList<Article>();
		//通过数组下标来取缓存的值
		Set<TypedTuple<String>> datas = zsetOps.rangeWithScores(key, start, start+step-1);
		for (TypedTuple<String> typedTuple : datas) {
			Article article = JSONObject.parseObject(typedTuple.getValue(), Article.class);
			list.add(article);
		}
//		List<Article> list = new ArrayList<Article>();
//		//通过数组下标来取缓存的值
//		Set<TypedTuple<Article>> datas = zsetOps.rangeWithScores(key, start, start+step-1);
//		for (TypedTuple<Article> typedTuple : datas) {
//			if(StringUtils.isEmpty(typedTuple.getValue().getCommercialMediaId())){
//				list.add(typedTuple.getValue());
//			}
//		}
		return list;
	}


	@Override
	public List<Article> fetchAllByChannelId(String key,String channelId) {
		List<Article> list = new ArrayList<Article>();
		//通过数组下标来取缓存的值
		Set<TypedTuple<String>> datas = zsetOps.rangeWithScores(key, 0, zsetOps.size(key)-1);
		for (TypedTuple<String> typedTuple : datas) {
			Article article = JSONObject.parseObject(typedTuple.getValue(), Article.class);
			if(null!=typedTuple.getValue() && channelId.equals(article.getSpecialId())){
				list.add(article);
			}
		}
		return list;
	}

	@Override
	public List<Article> fetchByPage(String key, long start, long step,String columnId) {
//		List<Article> list = new ArrayList<Article>();
//		//通过数组下标来取缓存的值
//		Set<TypedTuple<Article>> datas = zsetOps.rangeWithScores(key, start, start+step-1);
//		for (TypedTuple<Article> typedTuple : datas) {
//			if(typedTuple.getValue().getTopicColumnId().equals(columnId)){
//				list.add(typedTuple.getValue());
//			}
//		}
		List<Article> list = new ArrayList<Article>();
		//通过数组下标来取缓存的值
		Set<TypedTuple<String>> datas = zsetOps.rangeWithScores(key, start, start+step-1);
		for (TypedTuple<String> typedTuple : datas) {
			if(StringUtils.isNotEmpty(typedTuple.getValue())){
				Article article = JSONObject.parseObject(typedTuple.getValue(), Article.class);
				if(article.getTopicColumnId().equals(columnId)){
					list.add(article);
				}
			}

		}
		return list;
	}


	@Override
	public List<Article> fetchByPage(String key, String objId, int type, Date factTime, int pageSize) {
		List<Article> result = new ArrayList<>();
		List<Article> list = this.fetchAll(key);
		List<String> articleIds = new ArrayList<>();
		if(null!=list && !list.isEmpty()){
			boolean startFlag = false;
			if(type == 0 || type==1){
				startFlag = null!=factTime?false:true;
			}
			int total = 0;
			for(Article at : list){
				if(type == 0 && objId.equals(at.getSpecialId())){	//专题数据
					if(startFlag && total<pageSize){
						if(!articleIds.contains(at.getId())){
							result.add(at);
							articleIds.add(at.getId());
							total++;
						}
					}
					if(total == pageSize){
						break;
					}
					if(null!=factTime && genScoreByFactTime(factTime) == genScoreByFactTime(at.getFactTime())){
						startFlag = true;
					}
				}else if(type == 1 && null!=at.getAuthor() && objId.equals(at.getAuthor().getId())){	//作者数据
					if(startFlag && total<pageSize){
						if(!articleIds.contains(at.getId())){
							result.add(at);
							articleIds.add(at.getId());
							total++;
						}
					}
					if(total == pageSize){
						break;
					}
					if(null!=factTime && genScoreByFactTime(factTime) == genScoreByFactTime(at.getFactTime())){
						startFlag = true;
					}
				}
			}
		}
		return result;
	}

	@Override
	public long count(String key, String objId, int type) {
		long total = 0;
		List<String> articleIds = new ArrayList<>();
		List<Article> list = this.fetchAll(key);
		if(null!=list && !list.isEmpty()){
			for(Article at : list){
				if(type == 0 && objId.equals(at.getSpecialId()) && !articleIds.contains(at.getId())){	//专题数据
					total ++ ;
					articleIds.add(at.getId());
				}else if(type == 1 && null!=at.getAuthor() && objId.equals(at.getAuthor().getId())
						&& !articleIds.contains(at.getId())){	//作者数据
					total ++ ;
					articleIds.add(at.getId());
				}
			}
		}
		return total;
	}

	@Override
	public List<Article> fetchByAuthorId(String key, String authorId) {
		List<Article> result = new ArrayList<>();
		List<Article> list = this.fetchAll(key);
		if(null!=list && !list.isEmpty()){
			for(Article at : list){
				if(null!=at.getAuthor() && authorId.equals(at.getAuthor().getId())){
					result.add(at);
				}
			}
		}
		return result;
	}

	@Override
	public List<Article> fetchByPage(String key, Date factTime, int pageSize) {
		List<Article> list = new ArrayList<Article>();
		//通过数组下标来取缓存的值
		long factTimeScore = genScoreByFactTime(factTime);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(factTime);
		calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) - 3);
		Set<String> datas = zsetOps.rangeByScore(key, factTimeScore, genScoreByFactTime(calendar.getTime()), 1, pageSize);
		for (String str : datas) {
			Article article = JSONObject.parseObject(str, Article.class);
			list.add(article);
		}
//		Set<TypedTuple<String>> datas = zsetOps.rangeWithScores(key, 0, -1);
//		boolean startFlag = false;
//		int total = 0;
//		Iterator<TypedTuple<String>> it = datas.iterator();
//		while(it.hasNext()){
//			TypedTuple<String> typedTuple = it.next();
//			Article article = JSONObject.parseObject(typedTuple.getValue(), Article.class);
//			long score = genScoreByFactTime(article.getFactTime());
//			if(startFlag && total<pageSize && StringUtils.isEmpty(article.getCommercialMediaId())){
//				list.add(article);
//				total++;
//			}
//			if(total == pageSize){
//				break;
//			}
//			if(score == factTimeScore){
//				startFlag = true;
//			}
//		}
		return list;
	}

	@Override
	public List<Article> fetchByPage(String key, Date factTime, int pageSize,String columnId) {
		List<Article> list = new ArrayList<Article>();
		//通过数组下标来取缓存的值
		long factTimeScore = genScoreByFactTime(factTime);
		Set<TypedTuple<String>> datas = zsetOps.rangeWithScores(key, 1, -1);
		boolean startFlag = false;
		int total = 0;
		Iterator<TypedTuple<String>> it = datas.iterator();
		while(it.hasNext()){
			TypedTuple<String> typedTuple = it.next();
			Article article = JSONObject.parseObject(typedTuple.getValue(), Article.class);
			long score = genScoreByFactTime(article.getFactTime());
			if(startFlag && total<pageSize && article.getTopicColumnId().equals(columnId)){
				list.add(article);
				total++;
			}
			if(total == pageSize){
				break;
			}
			if(score == factTimeScore){
				startFlag = true;
			}
		}
		return list;
	}

	@Override
	public void saveProgramme(String key, Programme obj) {
		//放到redis
//		SimplePropertyPreFilter filter = new SimplePropertyPreFilter();
//		filter.getExcludes().add("creator");
//		String json = JSONObject.toJSONString(obj, filter);
		zsetOps.add(key, JSONObject.toJSONString(obj), genScoreByFactTime(obj.getCreateTime()));
	}

	@Override
	public List<Programme> fetchByPage(String key, Date factTime, int page, int pageSize) {
		List<Programme> list = new ArrayList<>();
		//通过数组下标来取缓存的值
		if(null!=factTime){
			long factTimeScore = genScoreByFactTime(factTime);
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(factTime);
			calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) -3);
			Set<String> datas = zsetOps.rangeByScore(key, factTimeScore, genScoreByFactTime(calendar.getTime()), 0, pageSize);
			for (String str : datas) {
				Programme mo = JSONObject.parseObject(str, Programme.class);
				list.add(mo);
			}
		}else{
			Set<TypedTuple<String>> datas = zsetOps.rangeWithScores(key, page, page+pageSize-1);
			for (TypedTuple<String> typedTuple : datas) {
				Programme mo = JSONObject.parseObject(typedTuple.getValue(), Programme.class);
				list.add(mo);
			}
		}
		return list;
	}
}