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