Redis定时任务操作相关

import com.alibaba.fastjson.JSONObject;
import com.hotent.base.core.util.AppUtil;
import com.hotent.base.db.mybatis.CommonDao;
import com.hotent.mini.util.RedisDSGDBUtil;
import com.hotent.sys.api.job.BaseJob;
import org.apache.commons.collections.CollectionUtils;
import org.quartz.JobExecutionContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;

import java.text.SimpleDateFormat;
import java.util.List;
import java.util.Map;

/**
* 定时任务
* 获取当前时间在 F_impact_start_date-1小时 和 F_impact_end_date+1小时 之间，且 F_suppress_ticket 为 YES，ManagerAssignStaff 之后 还没结束的 PM 流程任务
* 写入到 Redis 中的 RestrainJob
*/
@Repository
public class RestrainJob extends BaseJob {
protected Logger logger = LoggerFactory.getLogger(RestrainJob.class);
CommonDao<?> commonDao = AppUtil.getBean(CommonDao.class);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
static public Integer defIndexDB = 2; // 指定写入的数据库位置
@Override
public void executeJob(JobExecutionContext context) throws Exception {
String sql = "SELECT * from v_restrain r";
// 获取redis
Object object = RedisDSGDBUtil.getHashByKey(mainKey,"test001", defIndexDB);
Object objects = RedisDSGDBUtil.getHashByKey(mainKey,null, defIndexDB);
for(String t: ((Map<String, Object>)objects).keySet()) {
System.out.println( ((Map<String, Object>)objects).get(t) );
}

List<Map<String,Object>> list = commonDao.query(sql);
int c = 0;
// 删除所有
RedisDSGDBUtil.delHashByKey("RestrainJob",null, defIndexDB);
for (Map<String,Object> map: list) {

String key = map.get("ID_").toString();
String neType = map.get("F_ne_type").toString();
String neName = map.get("F_ne_name")==null?"":map.get("F_ne_name").toString();

String[] neTypes = neType.split(",");
String[] neNames = neName.split(",");

int i = 0;
for (String type: neTypes) {
for (String name: neNames) {
// System.out.println(key + "_" + i + "," + type + "," + name + ": " +list.size() + "," + c);
// 最后更新时间
JSONObject jobj = new JSONObject(true);
jobj.put("neType", type);
jobj.put("neName", name);
jobj.put("instId", key);
jobj.put("impactStartDate", map.get("F_impact_start_date")==null?"":sdf.format(map.get("F_impact_start_date")));
jobj.put("impactEndDate", map.get("F_impact_end_date")==null?"":sdf.format(map.get("F_impact_end_date")));

// 写入 redis 中
RedisDSGDBUtil.addHash("RestrainJob", key+"_"+i, jobj.toString(), 0, defIndexDB);
i++;
c++;
}
}
}
logger.debug("数据共：{}条，插入共：{}条", CollectionUtils.isNotEmpty(list)?list.size():0, c);
}

}

---------------------------- Redis 工具类 -------------------------------
import com.hotent.base.core.util.FileUtil;
import com.hotent.base.core.util.SerializeUtil;
import com.hotent.base.core.util.string.StringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Protocol;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.*;

/**
* Redis 指定到某个 DB节点
*/
public class RedisDSGDBUtil {
static String path= FileUtil.getClassesPath() +"/conf/x5-base-db.properties".replace("/", File.separator);
static String jedisPoolUrl = FileUtil.readFromProperties(path, "redis.jedisPoolUrl");
static String redisPort = FileUtil.readFromProperties(path, "redis.port");
static String redisPWD = FileUtil.readFromProperties(path, "redis.password");
static SimpleDateFormat sdfDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
protected Logger logger = LoggerFactory.getLogger(RedisDSGDBUtil.class);
static int defIndexDB = 0; // 默认0节点
/**
* 单个连接
*
* @param host
* @param port
* @return
*/
public static Jedis cli_single(String host, int port, Integer indexDB) {
Jedis jedis = null;
try {
jedis = new Jedis(host,port);
jedis.select(indexDB == null? defIndexDB: indexDB);
if (StringUtil.isNotEmpty(redisPWD))
jedis.auth(redisPWD);
return jedis;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}

/**
* 连接池
*
* @param host
* @param port
* @return
*/
public static Jedis cli_pool(String host, int port) {
JedisPoolConfig config = new JedisPoolConfig();
// 最大连接数
config.setMaxTotal(10);
// 最大连接空闲数
config.setMaxIdle(2);
JedisPool jedisPool = null;

try {
if (StringUtil.isEmpty(redisPWD)) {
jedisPool = new JedisPool(config, host, port);
} else {
jedisPool = new JedisPool(config, host, port, Protocol.DEFAULT_TIMEOUT, redisPWD);
}

return jedisPool.getResource();
} catch(Exception e) {
e.printStackTrace();
return null;
}

}

/**
* 删除
* @param key
*/
public static void delByKey(String key, Integer indexDB) {
if (StringUtil.isEmpty(key)) return;
JdkSerializationRedisSerializer sr = new JdkSerializationRedisSerializer();

Jedis jedis = cli_pool(jedisPoolUrl, Integer.valueOf(redisPort));
jedis.select(indexDB == null? defIndexDB: indexDB);
try {
if (jedis.exists(sr.serialize(key))) {
jedis.del(sr.serialize(key));
}
}
catch (Exception ex) {
throw ex;
}
finally {
jedis.close();
}
}

/**
* 删除Hash
* @param mainkey
* @param key
* @param indexDB
*/
public static void delHashByKey(String mainkey, String key, Integer indexDB) {
if (StringUtil.isEmpty(mainkey)) return;
Jedis jedis = cli_pool(jedisPoolUrl, Integer.valueOf(redisPort));
jedis.select(indexDB == null? defIndexDB: indexDB);
try {
JdkSerializationRedisSerializer sr = new JdkSerializationRedisSerializer();
if (jedis.exists(sr.serialize(mainkey))) {
if (StringUtil.isNotEmpty(key))
jedis.hdel(sr.serialize(mainkey), sr.serialize(key));
else
jedis.del(sr.serialize(mainkey));
}
}
catch (Exception ex){
throw ex;
}
finally {
jedis.close();
}
}

public static Object getByKey(String key, Integer indexDB) {
if(StringUtil.isEmpty(key)) return null;
Jedis jedis = cli_pool(jedisPoolUrl, Integer.valueOf(redisPort));
jedis.select(indexDB == null? defIndexDB: indexDB);
try {
JdkSerializationRedisSerializer sr = new JdkSerializationRedisSerializer();
if (jedis.exists(sr.serialize(key))) {
byte[] byt = jedis.get(sr.serialize(key));
return SerializeUtil.unserizlize(byt);
}
else {
return null;
}
}
catch (Exception ex){
throw ex;
}
finally {
jedis.close();
}
}

/**
* 获取 HASH
* @param mainkey
* @param key 为空则查mainKey所有内容
* @param indexDB 指定数据库，默认 0
* @return
*/
public static Object getHashByKey(String mainkey, String key, Integer indexDB) {
if(StringUtil.isEmpty(mainkey)) return null;
Jedis jedis = cli_pool(jedisPoolUrl, Integer.valueOf(redisPort));
jedis.select(indexDB == null? defIndexDB: indexDB);
try {
JdkSerializationRedisSerializer sr = new JdkSerializationRedisSerializer();
if (jedis.exists(sr.serialize(mainkey))){
if (key==null) {
Map<byte[], byte[]> maps= jedis.hgetAll(sr.serialize(mainkey));
Map<String, Object> result = null;
if (maps != null) {
result = new HashMap<>();
for (Map.Entry<byte[], byte[]> entry : maps.entrySet()) {
result.put(SerializeUtil.unserizlize(entry.getKey()).toString(),
SerializeUtil.unserizlize(entry.getValue()));
}
}
return result;
} else {
byte[] byt = jedis.hget(sr.serialize(mainkey), sr.serialize(key));
Map<String, Object> result = new HashMap<>();
result.put(SerializeUtil.unserizlize(sr.serialize(key)).toString(), SerializeUtil.unserizlize(byt));
return result;
}

}
else {
return null;
}
}
catch (Exception ex){
throw ex;
}
finally {
jedis.close();
}
}

/**
* 获取 ZSet
* @param key
* @param start 开始位置
* @param end 结束位置 -1 所有
* @param indexDB 指定数据库，默认 0
* @return
*/
public static Object getZSetByKey(String key, Integer start, Integer end, Integer indexDB) {
if(StringUtil.isEmpty(key)) return null;
Set<Object> result = new TreeSet<>();
Jedis jedis = cli_pool(jedisPoolUrl, Integer.valueOf(redisPort));
jedis.select(indexDB == null? defIndexDB: indexDB);
try {
JdkSerializationRedisSerializer sr = new JdkSerializationRedisSerializer();
if (jedis.exists(sr.serialize(key))) {
Set<byte[]> zSet = null;
if(start==null)
start = 0;
if(end==null)
end = -1;

zSet = jedis.zrange(sr.serialize(key), start, end);

for(byte[] b: zSet) {
result.add(SerializeUtil.unserizlize(b));
}
return result;
}
else {
return null;
}
}
catch (Exception ex){
throw ex;
}
finally {
jedis.close();
}
}

public static void add(String key, Object obj, int timeout, Integer indexDB) {
if(StringUtil.isEmpty(key) /*|| BeanUtils.isEmpty(obj)*/) return;
Jedis jedis = cli_pool(jedisPoolUrl, Integer.valueOf(redisPort));
jedis.select(indexDB == null? defIndexDB: indexDB);
try {
JdkSerializationRedisSerializer sr = new JdkSerializationRedisSerializer();
jedis.set(sr.serialize(key), sr.serialize(obj));
if(timeout > 0) {
jedis.expire(sr.serialize(key), timeout);
}
}
catch (Exception ex) {
throw ex;
}
finally {
jedis.close();
}
}

/**
* 添加 Hash
* @param mainkey
* @param key
* @param value
* @param timeout
* @param indexDB
*/
public static void addHash(String mainkey,String key, String value, int timeout, Integer indexDB) {
if (StringUtil.isEmpty(mainkey) /*|| BeanUtils.isEmpty(obj)*/) return;
Jedis jedis = cli_pool(jedisPoolUrl, Integer.valueOf(redisPort));
jedis.select(indexDB == null? defIndexDB: indexDB);
try {
JdkSerializationRedisSerializer sr = new JdkSerializationRedisSerializer();
// PMRedisJob.add(mainkey, value, 0);
// jedis.hset(mainkey, key, value);
jedis.hset(sr.serialize(mainkey), sr.serialize(key), sr.serialize(value));
if (timeout > 0) {
jedis.expire(sr.serialize(mainkey), timeout);
}
}
catch (Exception ex){
throw ex;
}
finally {
jedis.close();
}
}

/**
* 添加 ZSet
* @param key
* @param value
* @param timeout
* @param indexDB
* Map<byte[], Double> scoreMembers = new HashMap<byte[], Double>();
* JdkSerializationRedisSerializer sr = new JdkSerializationRedisSerializer();
* scoreMembers.put(sr.serialize("aaa"), 1011.0);
* RedisDSGDBUtil.addZSet("zset", scoreMembers,0, defIndexDB);
*/
public static void addZSet(String key, Map<byte[], Double> value, int timeout, Integer indexDB) {
if (StringUtil.isEmpty(key) /*|| BeanUtils.isEmpty(obj)*/) return;
Jedis jedis = cli_pool(jedisPoolUrl, Integer.valueOf(redisPort));
jedis.select(indexDB == null? defIndexDB: indexDB);
try {
JdkSerializationRedisSerializer sr = new JdkSerializationRedisSerializer();
jedis.zadd(sr.serialize(key), value);
if (timeout > 0) {
jedis.expire(sr.serialize(key), timeout);
}
}
catch (Exception ex){
throw ex;
}
finally {
jedis.close();
}
}

}