~chenjiahe/hx_common.git

chenjiahe

2022-06-28 4484acb56810d06ef5c2f78190a93688a61f83a7

提交 \| 用户 \| age
4484ac	1	package com.hx.redisson.templates.config;
a0ad14	2
4484ac	3	import com.hx.redisson.templates.manager.RedisManager;
a0ad14	4	import org.slf4j.Logger;
C	5	import org.slf4j.LoggerFactory;
	6	import org.springframework.beans.factory.annotation.Autowired;
	7	import org.springframework.data.redis.core.RedisTemplate;
	8	import org.springframework.data.redis.core.ZSetOperations;
	9	import org.springframework.stereotype.Component;
	10	import org.springframework.util.CollectionUtils;
	11
	12	import java.util.List;
	13	import java.util.Map;
	14	import java.util.Set;
	15	import java.util.concurrent.TimeUnit;
	16
	17	/**
	18	* <h1>RedisUtil 操作工具类</h1>
	19	* @author CJH
	20	*/
	21	@Component
	22	public class RedisTempsUtil {
	23
	24	private Logger logger = LoggerFactory.getLogger(RedisTempsUtil.class);
	25
	26	@Autowired
	27	private RedisManager redisManager;
	28
	29	@Autowired
	30	private RedisTemplate redisTemplate;
	31
	32	/**
	33	* 指定缓存失效时间
	34	* @param key 键
	35	* @param time 时间(秒)
	36	* @return
	37	*/
	38	public boolean expire(String key, long time) {
	39	try {
72f2f5	40	if (time < 0) {
C	41	throw new RuntimeException("设置时间不能为负数："+time);
a0ad14	42	}
C	43	return true;
72f2f5	44	} catch (Exception e) {
C	45	e.printStackTrace();
	46	return false;
	47	}
	48	}
	49
	50	/**
	51	* 指定缓存失效时间
	52	*
	53	* @param key 键
	54	* @param time 时间(秒)
	55	* @return
	56	*/
	57	public boolean expire(String key, long time,int db) {
	58	try {
	59	if (time < 0) {
	60	throw new RuntimeException("设置时间不能为负数："+time);
	61	}
	62	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	63	return redisTemplate.expire(key, time, TimeUnit.SECONDS);
a0ad14	64	} catch (Exception e) {
C	65	e.printStackTrace();
	66	return false;
	67	}
	68	}
	69
	70
	71	/**
	72	* 指定缓存失效时间
	73	*
	74	* @param key 键
	75	* @param time 时间
	76	* @param timeUnit 时间类型
	77	* @return
	78	*/
	79	public boolean expire(String key, long time, TimeUnit timeUnit) {
	80	try {
72f2f5	81	if (time < 0) {
C	82	throw new RuntimeException("设置时间不能为负数："+time);
a0ad14	83	}
C	84	return true;
72f2f5	85	} catch (Exception e) {
C	86	e.printStackTrace();
	87	return false;
	88	}
	89	}
	90
	91	/**
	92	* 指定缓存失效时间
	93	*
	94	* @param key 键
	95	* @param time 时间
	96	* @param timeUnit 时间类型
	97	* @return
	98	*/
	99	public boolean expire(String key, long time, TimeUnit timeUnit,int db) {
	100	try {
	101	if (time < 0) {
	102	throw new RuntimeException("设置时间不能为负数："+time);
	103	}
	104	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	105	return redisTemplate.expire(key, time, timeUnit);
a0ad14	106	} catch (Exception e) {
C	107	e.printStackTrace();
	108	return false;
	109	}
	110	}
	111
	112	/**
	113	* 根据key 获取过期时间
	114	*
	115	* @param key 键不能为null
	116	* @return 时间(秒) 返回0代表为永久有效
	117	*/
	118	public long getExpire(String key) {
	119	return redisTemplate.getExpire(key, TimeUnit.SECONDS);
	120	}
	121
72f2f5	122
C	123	/**
	124	* 根据key 获取过期时间
	125	*
	126	* @param key 键不能为null
	127	* @return 时间(秒) 返回0代表为永久有效
	128	*/
	129	public long getExpire(String key,int db) {
	130	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	131	return redisTemplate.getExpire(key, TimeUnit.SECONDS);
	132	}
	133
	134
a0ad14	135	/**
C	136	* 判断key是否存在
	137	*
	138	* @param key 键
	139	* @return true 存在 false不存在
	140	*/
	141	public boolean hasKey(String key) {
	142	try {
72f2f5	143	return redisTemplate.hasKey(key);
C	144	} catch (Exception e) {
	145	e.printStackTrace();
	146	return false;
	147	}
	148	}
	149
	150	/**
	151	* 判断key是否存在
	152	*
	153	* @param key 键
	154	* @return true 存在 false不存在
	155	*/
	156	public boolean hasKey(String key,int db) {
	157	try {
	158	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	159	return redisTemplate.hasKey(key);
C	160	} catch (Exception e) {
	161	e.printStackTrace();
	162	return false;
	163	}
	164	}
	165
	166	/**
	167	* 删除缓存
	168	*
	169	* @param key 可以传一个值或多个
	170	*/
	171	@SuppressWarnings("unchecked")
	172	public void del(String... key) {
	173	if (key != null && key.length > 0) {
	174	if (key.length == 1) {
	175	redisTemplate.delete(key[0]);
	176	} else {
	177	redisTemplate.delete(CollectionUtils.arrayToList(key));
	178	}
	179	}
	180	}
	181
72f2f5	182	/**
C	183	* 删除缓存
	184	*
	185	* @param key 可以传一个值或多个
	186	*/
	187	@SuppressWarnings("unchecked")
	188	public void del(int db,String... key) {
	189	if (key != null && key.length > 0) {
	190	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	191	if (key.length == 1) {
	192	redisTemplate.delete(key[0]);
	193	} else {
	194	redisTemplate.delete(CollectionUtils.arrayToList(key));
	195	}
	196	}
	197	}
	198
a0ad14	199	// ============================String=============================
C	200
	201	/**
	202	* 普通缓存获取
	203	*
	204	* @param key 键
	205	* @return 值
	206	*/
	207	public Object get(String key) {
72f2f5	208	return key == null ? null : redisTemplate.opsForValue().get(key);
C	209	}
	210
	211	/**
	212	* 普通缓存获取
	213	*
	214	* @param key 键
	215	* @return 值
	216	*/
	217	public Object get(String key,int db) {
	218	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	219	return key == null ? null : redisTemplate.opsForValue().get(key);
C	220	}
	221
	222	/**
	223	* 普通缓存放入
	224	*
	225	* @param key 键
	226	* @param value 值
	227	* @return true成功 false失败
	228	*/
	229	public boolean set(String key, Object value) {
	230	try {
	231	redisTemplate.opsForValue().set(key, value);
	232	return true;
	233	} catch (Exception e) {
	234	e.printStackTrace();
	235	return false;
	236	}
	237
	238	}
	239
	240	/**
	241	* 普通缓存放入
	242	*
	243	* @param key 键
	244	* @param value 值
	245	* @return true成功 false失败
	246	*/
	247	public boolean set(String key, Object value,int db) {
	248	try {
	249	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	250	redisTemplate.opsForValue().set(key, value);
	251	return true;
	252	} catch (Exception e) {
	253	e.printStackTrace();
	254	return false;
	255	}
	256
	257	}
	258
	259
	260	/**
	261	* 普通缓存放入并设置时间
	262	*
	263	* @param key 键
	264	* @param value 值
	265	* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
	266	* @return true成功 false 失败
	267	*/
	268	public boolean set(String key, Object value, long time) {
	269	try {
	270	if (time > 0) {
	271	redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
	272	} else {
	273	set(key, value);
	274	}
	275	return true;
	276	} catch (Exception e) {
	277	e.printStackTrace();
	278	return false;
	279	}
	280	}
	281
	282	/**
72f2f5	283	* 普通缓存放入并设置时间
C	284	*
	285	* @param key 键
	286	* @param value 值
	287	* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
	288	* @return true成功 false 失败
	289	*/
	290	public boolean set(String key, Object value, long time,int db) {
	291	try {
	292	if (time > 0) {
	293	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	294	redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
	295	} else {
	296	set(key, value,db);
	297	}
	298	return true;
	299	} catch (Exception e) {
	300	e.printStackTrace();
	301	return false;
	302	}
	303	}
	304
	305	/**
a0ad14	306	* 普通缓存放入并设置时间，并增加时间类型选择
C	307	*
	308	* @param key 键
	309	* @param value 值
	310	* @param time 时间 time要大于0 如果time小于等于0 将设置无限期
	311	* @param timeUnit 时间类型
	312	* @return
	313	*/
	314	public boolean set(String key, Object value, long time, TimeUnit timeUnit) {
	315	try {
	316	if (time > 0) {
	317	redisTemplate.opsForValue().set(key, value, time, timeUnit);
	318	} else {
	319	set(key, value);
	320	}
	321	return true;
	322	} catch (Exception e) {
	323	e.printStackTrace();
	324	return false;
	325	}
	326	}
	327
	328	/**
72f2f5	329	* 普通缓存放入并设置时间，并增加时间类型选择
C	330	*
	331	* @param key 键
	332	* @param value 值
	333	* @param time 时间 time要大于0 如果time小于等于0 将设置无限期
	334	* @param timeUnit 时间类型
	335	* @return
	336	*/
	337	public boolean set(String key, Object value, long time, TimeUnit timeUnit,int db) {
	338	try {
	339	if (time > 0) {
	340	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	341	redisTemplate.opsForValue().set(key, value, time, timeUnit);
	342	} else {
	343	set(key, value,db);
	344	}
	345	return true;
	346	} catch (Exception e) {
	347	e.printStackTrace();
	348	return false;
	349	}
	350	}
	351
	352	/**
a0ad14	353	* 递增
C	354	*
	355	* @param key 键
	356	* @param delta 要增加几(大于0)
	357	* @return
	358	*/
	359	public long incr(String key, long delta) {
	360	if (delta < 0) {
	361	throw new RuntimeException("递增因子必须大于0");
	362	}
72f2f5	363	return redisTemplate.opsForValue().increment(key, delta);
C	364	}
	365
	366	/**
	367	* 递增
	368	*
	369	* @param key 键
	370	* @param delta 要增加几(大于0)
	371	* @return
	372	*/
	373	public long incr(String key, long delta,int db) {
	374	if (delta < 0) {
	375	throw new RuntimeException("递增因子必须大于0");
	376	}
	377	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	378	return redisTemplate.opsForValue().increment(key, delta);
C	379	}
	380
	381	/**
	382	* 递减
	383	*
	384	* @param key 键
	385	* @param delta 要减少几(小于0)
	386	* @return
	387	*/
	388	public long decr(String key, long delta) {
	389	if (delta < 0) {
	390	throw new RuntimeException("递减因子必须大于0");
	391	}
	392	return redisTemplate.opsForValue().increment(key, -delta);
	393	}
	394
72f2f5	395	/**
C	396	* 递减
	397	*
	398	* @param key 键
	399	* @param delta 要减少几(小于0)
	400	* @return
	401	*/
	402	public long decr(String key, long delta,int db) {
	403	if (delta < 0) {
	404	throw new RuntimeException("递减因子必须大于0");
	405	}
	406	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	407	return redisTemplate.opsForValue().increment(key, -delta);
	408	}
	409
a0ad14	410	// ================================Map=================================
C	411
	412	/**
	413	* HashGet
	414	*
	415	* @param key 键不能为null
	416	* @param item 项不能为null
	417	* @return 值
	418	*/
	419	public Object hget(String key, String item) {
	420	return redisTemplate.opsForHash().get(key, item);
	421	}
	422
	423	/**
72f2f5	424	* HashGet
C	425	*
	426	* @param key 键不能为null
	427	* @param item 项不能为null
	428	* @return 值
	429	*/
	430	public Object hget(String key, String item,int db) {
	431	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	432	return redisTemplate.opsForHash().get(key, item);
	433	}
	434
	435	/**
a0ad14	436	* 获取hashKey对应的所有键值
C	437	*
	438	* @param key 键
	439	* @return 对应的多个键值
	440	*/
	441	public Map<Object, Object> hmget(String key) {
	442	return redisTemplate.opsForHash().entries(key);
	443	}
	444
	445	/**
72f2f5	446	* 获取hashKey对应的所有键值
C	447	*
	448	* @param key 键
	449	* @return 对应的多个键值
	450	*/
	451	public Map<Object, Object> hmget(String key,int db) {
	452	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	453	return redisTemplate.opsForHash().entries(key);
	454	}
	455
	456
	457	/**
a0ad14	458	* HashSet
C	459	*
	460	* @param key 键
	461	* @param map 对应多个键值
	462	* @return true 成功 false 失败
	463	*/
	464	public boolean hmset(String key, Map<String, Object> map) {
	465	try {
72f2f5	466	redisTemplate.opsForHash().putAll(key, map);
C	467	return true;
	468	} catch (Exception e) {
	469	e.printStackTrace();
	470	return false;
	471	}
	472	}
	473
	474	/**
	475	* HashSet
	476	*
	477	* @param key 键
	478	* @param map 对应多个键值
	479	* @return true 成功 false 失败
	480	*/
	481	public boolean hmset(String key, Map<String, Object> map,int db) {
	482	try {
	483	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	484	redisTemplate.opsForHash().putAll(key, map);
C	485	return true;
	486	} catch (Exception e) {
	487	e.printStackTrace();
	488	return false;
	489	}
	490	}
	491
	492	/**
	493	* HashSet 并设置时间
	494	*
	495	* @param key 键
	496	* @param map 对应多个键值
	497	* @param time 时间(秒)
	498	* @return true成功 false失败
	499	*/
	500	public boolean hmset(String key, Map<String, Object> map, long time) {
	501	try {
	502	redisTemplate.opsForHash().putAll(key, map);
	503	if (time > 0) {
	504	expire(key, time);
72f2f5	505	}
C	506	return true;
	507	} catch (Exception e) {
	508	e.printStackTrace();
	509	return false;
	510	}
	511	}
	512
	513	/**
	514	* HashSet 并设置时间
	515	*
	516	* @param key 键
	517	* @param map 对应多个键值
	518	* @param time 时间(秒)
	519	* @return true成功 false失败
	520	*/
	521	public boolean hmset(String key, Map<String, Object> map, long time,int db) {
	522	try {
	523	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	524	redisTemplate.opsForHash().putAll(key, map);
	525	if (time > 0) {
	526	expire(key, time,db);
a0ad14	527	}
C	528	return true;
	529	} catch (Exception e) {
	530	e.printStackTrace();
	531	return false;
	532	}
	533	}
	534
	535	/**
	536	* 向一张hash表中放入数据,如果不存在将创建
	537	*
	538	* @param key 键
	539	* @param item 项
	540	* @param value 值
	541	* @return true 成功 false失败
	542	*/
	543	public boolean hset(String key, String item, Object value) {
	544	try {
	545	redisTemplate.opsForHash().put(key, item, value);
	546	return true;
	547	} catch (Exception e) {
	548	e.printStackTrace();
	549	return false;
	550	}
	551	}
	552
	553	/**
	554	* 向一张hash表中放入数据,如果不存在将创建
	555	*
	556	* @param key 键
	557	* @param item 项
	558	* @param value 值
72f2f5	559	* @return true 成功 false失败
C	560	*/
	561	public boolean hset(String key, String item, Object value,int db) {
	562	try {
	563	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	564	redisTemplate.opsForHash().put(key, item, value);
	565	return true;
	566	} catch (Exception e) {
	567	e.printStackTrace();
	568	return false;
	569	}
	570	}
	571
	572	/**
	573	* 向一张hash表中放入数据,如果不存在将创建
	574	*
	575	* @param key 键
	576	* @param item 项
	577	* @param value 值
a0ad14	578	* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
C	579	* @return true 成功 false失败
	580	*/
	581	public boolean hset(String key, String item, Object value, long time) {
	582	try {
	583	redisTemplate.opsForHash().put(key, item, value);
	584	if (time > 0) {
	585	expire(key, time);
72f2f5	586	}
C	587	return true;
	588	} catch (Exception e) {
	589	e.printStackTrace();
	590	return false;
	591	}
	592	}
	593
	594	/**
	595	* 向一张hash表中放入数据,如果不存在将创建
	596	*
	597	* @param key 键
	598	* @param item 项
	599	* @param value 值
	600	* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
	601	* @return true 成功 false失败
	602	*/
	603	public boolean hset(String key, String item, Object value, long time,int db) {
	604	try {
	605	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	606	redisTemplate.opsForHash().put(key, item, value);
	607	if (time > 0) {
	608	expire(key, time,db);
a0ad14	609	}
C	610	return true;
	611	} catch (Exception e) {
	612	e.printStackTrace();
	613	return false;
	614	}
	615	}
	616
	617	/**
	618	* 删除hash表中的值
	619	*
	620	* @param key 键不能为null
	621	* @param item 项可以使多个不能为null
	622	*/
	623	public void hdel(String key, Object... item) {
	624	redisTemplate.opsForHash().delete(key, item);
	625	}
	626
	627	/**
72f2f5	628	* 删除hash表中的值
C	629	*
	630	* @param key 键不能为null
	631	* @param item 项可以使多个不能为null
	632	*/
	633	public void hdel(int db,String key, Object... item) {
	634	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	635	redisTemplate.opsForHash().delete(key, item);
	636	}
	637
	638	/**
a0ad14	639	* 判断hash表中是否有该项的值
C	640	*
	641	* @param key 键不能为null
	642	* @param item 项不能为null
	643	* @return true 存在 false不存在
	644	*/
	645	public boolean hHasKey(String key, String item) {
	646	return redisTemplate.opsForHash().hasKey(key, item);
	647	}
	648
	649	/**
72f2f5	650	* 判断hash表中是否有该项的值
C	651	*
	652	* @param key 键不能为null
	653	* @param item 项不能为null
	654	* @return true 存在 false不存在
	655	*/
	656	public boolean hHasKey(String key, String item,int db) {
	657	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	658	return redisTemplate.opsForHash().hasKey(key, item);
	659	}
	660
	661
	662	/**
a0ad14	663	* hash递增如果不存在,就会创建一个并把新增后的值返回
C	664	*
	665	* @param key 键
	666	* @param item 项
	667	* @param by 要增加几(大于0)
	668	* @return
	669	*/
	670	public double hincr(String key, String item, double by) {
72f2f5	671	return redisTemplate.opsForHash().increment(key, item, by);
C	672	}
	673
	674	/**
	675	* hash递增如果不存在,就会创建一个并把新增后的值返回
	676	*
	677	* @param key 键
	678	* @param item 项
	679	* @param by 要增加几(大于0)
	680	* @return
	681	*/
	682	public double hincr(String key, String item, double by,int db) {
	683	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	684	return redisTemplate.opsForHash().increment(key, item, by);
C	685	}
	686
	687	/**
	688	* hash递减
	689	*
	690	* @param key 键
	691	* @param item 项
	692	* @param by 要减少记(小于0)
	693	* @return
	694	*/
	695	public double hdecr(String key, String item, double by) {
	696	return redisTemplate.opsForHash().increment(key, item, -by);
	697	}
	698
72f2f5	699	/**
C	700	* hash递减
	701	*
	702	* @param key 键
	703	* @param item 项
	704	* @param by 要减少记(小于0)
	705	* @return
	706	*/
	707	public double hdecr(String key, String item, double by,int db) {
	708	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	709	return redisTemplate.opsForHash().increment(key, item, -by);
	710	}
	711
a0ad14	712	// ============================set=============================
C	713
	714	/**
	715	* 根据key获取Set中的所有值
	716	*
	717	* @param key 键
	718	* @return
	719	*/
	720	public Set<Object> sGet(String key) {
	721	try {
72f2f5	722	return redisTemplate.opsForSet().members(key);
C	723	} catch (Exception e) {
	724	e.printStackTrace();
	725	return null;
	726	}
	727	}
	728
	729	/**
	730	* 根据key获取Set中的所有值
	731	*
	732	* @param key 键
	733	* @return
	734	*/
	735	public Set<Object> sGet(String key,int db) {
	736	try {
	737	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	738	return redisTemplate.opsForSet().members(key);
C	739	} catch (Exception e) {
	740	e.printStackTrace();
	741	return null;
	742	}
	743	}
	744
	745	/**
	746	* 根据key获取Set中的指定几个随机内容
	747	*
	748	* @param key 键
	749	* @param size 个数
	750	* @return
	751	*/
	752	public List sRandomGet(String key, Integer size) {
	753	try {
	754	return redisTemplate.opsForSet().randomMembers(key, size);
	755	} catch (Exception e) {
	756	e.printStackTrace();
	757	return null;
	758	}
	759	}
	760
	761	/**
72f2f5	762	* 根据key获取Set中的指定几个随机内容
C	763	*
	764	* @param key 键
	765	* @param size 个数
	766	* @return
	767	*/
	768	public List sRandomGet(String key, Integer size,int db) {
	769	try {
	770	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	771	return redisTemplate.opsForSet().randomMembers(key, size);
	772	} catch (Exception e) {
	773	e.printStackTrace();
	774	return null;
	775	}
	776	}
	777
	778	/**
a0ad14	779	* 根据value从一个set中查询,是否存在
C	780	*
	781	* @param key 键
	782	* @param value 值
	783	* @return true 存在 false不存在
	784	*/
	785	public boolean sHasKey(String key, Object value) {
	786	try {
	787	return redisTemplate.opsForSet().isMember(key, value);
	788	} catch (Exception e) {
	789	e.printStackTrace();
	790	return false;
	791	}
	792	}
	793
	794	/**
72f2f5	795	* 根据value从一个set中查询,是否存在
C	796	*
	797	* @param key 键
	798	* @param value 值
	799	* @return true 存在 false不存在
	800	*/
	801	public boolean sHasKey(String key, Object value,int db) {
	802	try {
	803	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	804	return redisTemplate.opsForSet().isMember(key, value);
	805	} catch (Exception e) {
	806	e.printStackTrace();
	807	return false;
	808	}
	809	}
	810
	811	/**
a0ad14	812	* 将数据放入set缓存
C	813	*
	814	* @param key 键
	815	* @param values 值可以是多个
	816	* @return 成功个数
	817	*/
	818	public long sSet(String key, Object... values) {
	819	try {
72f2f5	820	return redisTemplate.opsForSet().add(key, values);
C	821	} catch (Exception e) {
	822	e.printStackTrace();
	823	return 0;
	824	}
	825	}
	826
	827	/**
	828	* 将数据放入set缓存
	829	*
	830	* @param key 键
	831	* @param values 值可以是多个
	832	* @return 成功个数
	833	*/
	834	public long sSet(int db,String key, Object... values) {
	835	try {
	836	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	837	return redisTemplate.opsForSet().add(key, values);
C	838	} catch (Exception e) {
	839	e.printStackTrace();
	840	return 0;
	841	}
	842	}
	843
	844	/**
	845	* 将set数据放入缓存
	846	*
	847	* @param key 键
	848	* @param time 时间(秒)
	849	* @param values 值可以是多个
	850	* @return 成功个数
	851	*/
	852	public long sSetAndTime(String key, long time, Object... values) {
	853	try {
	854	Long count = redisTemplate.opsForSet().add(key, values);
	855	if (time > 0) {
	856	expire(key, time);
	857	}
	858	return count;
	859	} catch (Exception e) {
	860	e.printStackTrace();
	861	return 0;
	862	}
	863	}
	864
	865	/**
72f2f5	866	* 将set数据放入缓存
C	867	*
	868	* @param key 键
	869	* @param time 时间(秒)
	870	* @param values 值可以是多个
	871	* @return 成功个数
	872	*/
	873	public long sSetAndTime(int db,String key, long time, Object... values) {
	874	try {
	875	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	876	Long count = redisTemplate.opsForSet().add(key, values);
	877	if (time > 0) {
	878	expire(key, time,db);
	879	}
	880	return count;
	881	} catch (Exception e) {
	882	e.printStackTrace();
	883	return 0;
	884	}
	885	}
	886
	887	/**
a0ad14	888	* 获取set缓存的长度
C	889	*
	890	* @param key 键
	891	* @return
	892	*/
	893	public long sGetSetSize(String key) {
	894	try {
72f2f5	895	return redisTemplate.opsForSet().size(key);
C	896	} catch (Exception e) {
	897	e.printStackTrace();
	898	return 0;
	899	}
	900	}
	901
	902	/**
	903	* 获取set缓存的长度
	904	*
	905	* @param key 键
	906	* @return
	907	*/
	908	public long sGetSetSize(String key,int db) {
	909	try {
	910	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	911	return redisTemplate.opsForSet().size(key);
C	912	} catch (Exception e) {
	913	e.printStackTrace();
	914	return 0;
	915	}
	916	}
	917
	918	/**
	919	* 移除值为value的
	920	*
	921	* @param key 键
	922	* @param values 值可以是多个
	923	* @return 移除的个数
	924	*/
	925	public long setRemove(String key, Object... values) {
	926	try {
72f2f5	927	Long count = redisTemplate.opsForSet().remove(key, values);
C	928	return count;
	929	} catch (Exception e) {
	930	e.printStackTrace();
	931	return 0;
	932	}
	933	}
	934
	935
	936	/**
	937	* 移除值为value的
	938	*
	939	* @param key 键
	940	* @param values 值可以是多个
	941	* @return 移除的个数
	942	*/
	943	public long setRemove(int db,String key, Object... values) {
	944	try {
	945	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	946	Long count = redisTemplate.opsForSet().remove(key, values);
C	947	return count;
	948	} catch (Exception e) {
	949	e.printStackTrace();
	950	return 0;
	951	}
	952	}
	953	// ===============================list=================================
	954
	955	/**
	956	* 获取list缓存的内容
	957	*
	958	* @param key 键
	959	* @param start 开始
	960	* @param end 结束 0 到 -1代表所有值
	961	* @return
	962	*/
	963	public List<Object> lGet(String key, long start, long end) {
	964	try {
	965	return redisTemplate.opsForList().range(key, start, end);
	966	} catch (Exception e) {
	967	e.printStackTrace();
	968	return null;
	969	}
	970	}
	971
	972	/**
72f2f5	973	* 获取list缓存的内容
C	974	*
	975	* @param key 键
	976	* @param start 开始
	977	* @param end 结束 0 到 -1代表所有值
	978	* @return
	979	*/
	980	public List<Object> lGet(String key, long start, long end,int db) {
	981	try {
	982	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	983	return redisTemplate.opsForList().range(key, start, end);
	984	} catch (Exception e) {
	985	e.printStackTrace();
	986	return null;
	987	}
	988	}
	989
	990	/**
a0ad14	991	* 获取list缓存的长度
C	992	*
	993	* @param key 键
	994	* @return
	995	*/
	996	public long lGetListSize(String key) {
	997	try {
72f2f5	998	return redisTemplate.opsForList().size(key);
C	999	} catch (Exception e) {
	1000	e.printStackTrace();
	1001	return 0;
	1002	}
	1003	}
	1004
	1005	/**
	1006	* 获取list缓存的长度
	1007	*
	1008	* @param key 键
	1009	* @return
	1010	*/
	1011	public long lGetListSize(String key,int db) {
	1012	try {
	1013	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	1014	return redisTemplate.opsForList().size(key);
C	1015	} catch (Exception e) {
	1016	e.printStackTrace();
	1017	return 0;
	1018	}
	1019	}
	1020
	1021	/**
	1022	* 通过索引获取list中的值
	1023	*
	1024	* @param key 键
	1025	* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
	1026	* @return
	1027	*/
	1028	public Object lGetIndex(String key, long index) {
	1029	try {
	1030	return redisTemplate.opsForList().index(key, index);
	1031	} catch (Exception e) {
	1032	e.printStackTrace();
	1033	return null;
	1034	}
	1035	}
	1036
	1037	/**
72f2f5	1038	* 通过索引获取list中的值
C	1039	*
	1040	* @param key 键
	1041	* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
	1042	* @return
	1043	*/
	1044	public Object lGetIndex(String key, long index,int db) {
	1045	try {
	1046	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1047	return redisTemplate.opsForList().index(key, index);
	1048	} catch (Exception e) {
	1049	e.printStackTrace();
	1050	return null;
	1051	}
	1052	}
	1053
	1054	/**
a0ad14	1055	* 将list放入缓存
C	1056	*
	1057	* @param key 键
	1058	* @param value 值
	1059	* @return
	1060	*/
	1061	public boolean lSet(String key, Object value) {
	1062	try {
72f2f5	1063	redisTemplate.opsForList().rightPush(key, value);
C	1064	return true;
	1065	} catch (Exception e) {
	1066	e.printStackTrace();
	1067	return false;
	1068	}
	1069	}
	1070
	1071	/**
	1072	* 将list放入缓存
	1073	*
	1074	* @param key 键
	1075	* @param value 值
	1076	* @return
	1077	*/
	1078	public boolean lSet(String key, Object value,int db) {
	1079	try {
	1080	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	1081	redisTemplate.opsForList().rightPush(key, value);
C	1082	return true;
	1083	} catch (Exception e) {
	1084	e.printStackTrace();
	1085	return false;
	1086	}
	1087	}
	1088
	1089	/**
	1090	* 将list放入缓存
	1091	*
	1092	* @param key 键
	1093	* @param value 值
	1094	* @param time 时间(秒)
	1095	* @return
	1096	*/
	1097	public boolean lSet(String key, Object value, long time) {
	1098	try {
	1099	redisTemplate.opsForList().rightPush(key, value);
	1100	if (time > 0) {
	1101	expire(key, time);
	1102	}
	1103	return true;
	1104	} catch (Exception e) {
	1105	e.printStackTrace();
	1106	return false;
	1107	}
	1108	}
	1109
	1110	/**
	1111	* 将list放入缓存
	1112	*
	1113	* @param key 键
	1114	* @param value 值
72f2f5	1115	* @param time 时间(秒)
C	1116	* @return
	1117	*/
	1118	public boolean lSet(String key, Object value, long time,int db) {
	1119	try {
	1120	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1121	redisTemplate.opsForList().rightPush(key, value);
	1122	if (time > 0) {
	1123	expire(key, time,db);
	1124	}
	1125	return true;
	1126	} catch (Exception e) {
	1127	e.printStackTrace();
	1128	return false;
	1129	}
	1130	}
	1131
	1132	/**
	1133	* 将list放入缓存
	1134	*
	1135	* @param key 键
	1136	* @param value 值
a0ad14	1137	* @return
C	1138	*/
	1139	public boolean lSetAll(String key, List<Object> value) {
	1140	try {
72f2f5	1141	redisTemplate.opsForList().rightPushAll(key, value);
C	1142	return true;
	1143	} catch (Exception e) {
	1144	e.printStackTrace();
	1145	return false;
	1146	}
	1147	}
	1148
	1149	/**
	1150	* 将list放入缓存
	1151	*
	1152	* @param key 键
	1153	* @param value 值
	1154	* @return
	1155	*/
	1156	public boolean lSetAll(String key, List<Object> value,int db) {
	1157	try {
	1158	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	1159	redisTemplate.opsForList().rightPushAll(key, value);
C	1160	return true;
	1161	} catch (Exception e) {
	1162	e.printStackTrace();
	1163	return false;
	1164	}
	1165	}
	1166
	1167	/**
	1168	* 将list放入缓存
	1169	*
	1170	* @param key 键
	1171	* @param value 值
	1172	* @param time 时间(秒)
	1173	* @return
	1174	*/
	1175	public boolean lSetAll(String key, List<Object> value, long time) {
	1176	try {
	1177	// 设置超时时间原子化
	1178	redisTemplate.opsForList().rightPushAll(key, value);
	1179	if (time > 0) {
	1180	expire(key, time);
	1181	}
	1182	return true;
	1183	} catch (Exception e) {
	1184	e.printStackTrace();
	1185	return false;
	1186	}
	1187	}
	1188
	1189	/**
72f2f5	1190	* 将list放入缓存
C	1191	*
	1192	* @param key 键
	1193	* @param value 值
	1194	* @param time 时间(秒)
	1195	* @return
	1196	*/
	1197	public boolean lSetAll(String key, List<Object> value, long time,int db) {
	1198	try {
	1199	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1200	// 设置超时时间原子化
	1201	redisTemplate.opsForList().rightPushAll(key, value);
	1202	if (time > 0) {
	1203	expire(key, time,db);
	1204	}
	1205	return true;
	1206	} catch (Exception e) {
	1207	e.printStackTrace();
	1208	return false;
	1209	}
	1210	}
	1211
	1212	/**
a0ad14	1213	* 根据索引修改list中的某条数据
C	1214	*
	1215	* @param key 键
	1216	* @param index 索引
	1217	* @param value 值
	1218	* @return
	1219	*/
	1220	public boolean lUpdateIndex(String key, long index, Object value) {
	1221	try {
	1222	redisTemplate.opsForList().set(key, index, value);
	1223	return true;
	1224	} catch (Exception e) {
	1225	e.printStackTrace();
	1226	return false;
	1227	}
	1228	}
	1229
	1230	/**
72f2f5	1231	* 根据索引修改list中的某条数据
C	1232	*
	1233	* @param key 键
	1234	* @param index 索引
	1235	* @param value 值
	1236	* @return
	1237	*/
	1238	public boolean lUpdateIndex(String key, long index, Object value,int db) {
	1239	try {
	1240	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1241	redisTemplate.opsForList().set(key, index, value);
	1242	return true;
	1243	} catch (Exception e) {
	1244	e.printStackTrace();
	1245	return false;
	1246	}
	1247	}
	1248
	1249	/**
a0ad14	1250	* 移除N个值为value
C	1251	*
	1252	* @param key 键
	1253	* @param count 移除多少个
	1254	* @param value 值
	1255	* @return 移除的个数
	1256	*/
	1257	public long lRemove(String key, long count, Object value) {
	1258	try {
72f2f5	1259	Long remove = redisTemplate.opsForList().remove(key, count, value);
C	1260	return remove;
	1261	} catch (Exception e) {
	1262	e.printStackTrace();
	1263	return 0;
	1264	}
	1265	}
	1266
	1267	/**
	1268	* 移除N个值为value
	1269	*
	1270	* @param key 键
	1271	* @param count 移除多少个
	1272	* @param value 值
	1273	* @return 移除的个数
	1274	*/
	1275	public long lRemove(String key, long count, Object value,int db) {
	1276	try {
	1277	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	1278	Long remove = redisTemplate.opsForList().remove(key, count, value);
C	1279	return remove;
	1280	} catch (Exception e) {
	1281	e.printStackTrace();
	1282	return 0;
	1283	}
	1284	}
	1285
	1286
	1287	/**
	1288	* 根据给定的布隆过滤器添加值
	1289	*
	1290	* @param bloomFilterHelper bloom布隆过滤器解析类
	1291	* @param key redis 的key
	1292	* @param value redis 的value
	1293	* @param <T> 值的类型
	1294	*/
	1295	/*public <T> void addByBloomFilter(BloomFilterHelper<T> bloomFilterHelper, String key, T value) {
	1296	Preconditions.checkArgument(bloomFilterHelper != null, "bloomFilterHelper不能为空");
	1297	int[] offset = bloomFilterHelper.murmurHashOffset(value);
	1298	for (int i : offset) {
	1299	redisTemplate.opsForValue().setBit(key, i, true);
	1300	}
	1301	}*/
	1302
	1303
	1304	/**
	1305	* 根据给定的布隆过滤器判断值是否存在
	1306	*
	1307	* @param bloomFilterHelper bloom布隆过滤器解析类
	1308	* @param key redis 的key
	1309	* @param value redis 的value
	1310	* @param <T> 值的类型
	1311	* @return 存在 true
	1312	*/
	1313	/* public <T> boolean includeByBloomFilter(BloomFilterHelper<T> bloomFilterHelper, String key, T value) {
	1314	Preconditions.checkArgument(bloomFilterHelper != null, "bloomFilterHelper不能为空");
	1315	int[] offset = bloomFilterHelper.murmurHashOffset(value);
	1316	for (int i : offset) {
	1317	if (!redisTemplate.opsForValue().getBit(key, i)) {
	1318	return false;
	1319	}
	1320	}
	1321	return true;
	1322	}*/
	1323
	1324
	1325	/**
	1326	* zset 添加元素
	1327	*
	1328	* @param key
	1329	* @param time
	1330	* @param tuples
	1331	* @return
	1332	*/
	1333	public long zsSetAndTime(String key, long time, Set<ZSetOperations.TypedTuple<Object>> tuples) {
	1334	try {
	1335	Long count = redisTemplate.opsForZSet().add(key, tuples);
	1336	if (time > 0) {
	1337	expire(key, time);
	1338	}
	1339	return count;
	1340	} catch (Exception e) {
	1341	e.printStackTrace();
	1342	return 0;
	1343	}
	1344	}
	1345
	1346	/**
	1347	* zset 添加元素
	1348	*
	1349	* @param key
72f2f5	1350	* @param time
a0ad14	1351	* @param tuples
C	1352	* @return
	1353	*/
72f2f5	1354	public long zsSetAndTime(String key, long time, Set<ZSetOperations.TypedTuple<Object>> tuples,int db) {
a0ad14	1355	try {
72f2f5	1356	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
C	1357	Long count = redisTemplate.opsForZSet().add(key, tuples);
	1358	if (time > 0) {
	1359	expire(key, time,db);
	1360	}
	1361	return count;
	1362	} catch (Exception e) {
	1363	e.printStackTrace();
	1364	return 0;
	1365	}
	1366	}
	1367
	1368	/**
	1369	* zset 添加元素
	1370	*
	1371	* @param key
	1372	* @param tuples
	1373	* @return
	1374	*/
	1375	public long zsSet(String key, Set<ZSetOperations.TypedTuple<Object>> tuples) {
	1376	try {
	1377	Long count = redisTemplate.opsForZSet().add(key, tuples);
	1378	return count;
	1379	} catch (Exception e) {
	1380	e.printStackTrace();
	1381	return 0;
	1382	}
	1383	}
	1384
	1385	/**
	1386	* zset 添加元素
	1387	*
	1388	* @param key
	1389	* @param tuples
	1390	* @return
	1391	*/
	1392	public long zsSet(String key, Set<ZSetOperations.TypedTuple<Object>> tuples,int db) {
	1393	try {
	1394	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	1395	Long count = redisTemplate.opsForZSet().add(key, tuples);
C	1396	return count;
	1397	} catch (Exception e) {
	1398	e.printStackTrace();
	1399	return 0;
	1400	}
	1401	}
	1402
	1403	/**
	1404	* zs 移除元素
	1405	*
	1406	* @param key
	1407	* @param values
	1408	* @return
	1409	*/
	1410	public long zsRemove(String key, Object... values) {
	1411	try {
	1412	Long remove = redisTemplate.opsForZSet().remove(key, values);
	1413	return remove;
	1414	} catch (Exception e) {
	1415	e.printStackTrace();
	1416	return 0;
	1417	}
	1418	}
	1419
	1420
	1421	/**
72f2f5	1422	* zs 移除元素
C	1423	*
	1424	* @param key
	1425	* @param values
	1426	* @return
	1427	*/
	1428	public long zsRemove(int db,String key, Object... values) {
	1429	try {
	1430	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1431	Long remove = redisTemplate.opsForZSet().remove(key, values);
	1432	return remove;
	1433	} catch (Exception e) {
	1434	e.printStackTrace();
	1435	return 0;
	1436	}
	1437	}
	1438
	1439	/**
a0ad14	1440	* 通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列
C	1441	*
	1442	* @param key 键
	1443	* @param start 起始位置 0
	1444	* @param end 末尾位置 -1
	1445	* @return 0 -1 返回按分数递增的顺序集合仅返回 key
	1446	*/
	1447	public Set zsGet(String key, long start, long end) {
	1448	try {
72f2f5	1449	return redisTemplate.opsForZSet().range(key, start, end);
C	1450	} catch (Exception e) {
	1451	e.printStackTrace();
	1452	return null;
	1453	}
	1454	}
	1455
	1456	/**
	1457	* 通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列
	1458	*
	1459	* @param key 键
	1460	* @param start 起始位置 0
	1461	* @param end 末尾位置 -1
	1462	* @return 0 -1 返回按分数递增的顺序集合仅返回 key
	1463	*/
	1464	public Set zsGet(String key, long start, long end,int db) {
	1465	try {
	1466	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
a0ad14	1467	return redisTemplate.opsForZSet().range(key, start, end);
C	1468	} catch (Exception e) {
	1469	e.printStackTrace();
	1470	return null;
	1471	}
	1472	}
	1473
	1474
	1475	/**
	1476	* 通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列
	1477	*
	1478	* @param key 键
	1479	* @param start 起始位置 0
	1480	* @param end 末尾位置 -1
	1481	* @return 0 -1 返回按分数递增的顺序集合，返回成员对象
	1482	*/
	1483	public Set zsGetWithScores(String key, long start, long end) {
	1484	try {
	1485	return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
	1486	} catch (Exception e) {
	1487	e.printStackTrace();
	1488	return null;
	1489	}
	1490	}
	1491
	1492	/**
72f2f5	1493	* 通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列
C	1494	*
	1495	* @param key 键
	1496	* @param start 起始位置 0
	1497	* @param end 末尾位置 -1
	1498	* @return 0 -1 返回按分数递增的顺序集合，返回成员对象
	1499	*/
	1500	public Set zsGetWithScores(String key, long start, long end,int db) {
	1501	try {
	1502	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1503	return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
	1504	} catch (Exception e) {
	1505	e.printStackTrace();
	1506	return null;
	1507	}
	1508	}
	1509
	1510	/**
a0ad14	1511	* 通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递减(从大到小)顺序排列
C	1512	*
	1513	* @param key 键
	1514	* @param start 起始位置 0
	1515	* @param end 末尾位置 -1
	1516	* @return 0 -1 返回按分数递增的顺序集合仅返回 key
	1517	*/
	1518	public Set zsGetReverse(String key, long start, long end) {
	1519	try {
	1520	return redisTemplate.opsForZSet().reverseRange(key, start, end);
	1521	} catch (Exception e) {
	1522	e.printStackTrace();
	1523	return null;
	1524	}
	1525	}
	1526
72f2f5	1527	/**
C	1528	* 通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递减(从大到小)顺序排列
	1529	*
	1530	* @param key 键
	1531	* @param start 起始位置 0
	1532	* @param end 末尾位置 -1
	1533	* @return 0 -1 返回按分数递增的顺序集合仅返回 key
	1534	*/
	1535	public Set zsGetReverse(String key, long start, long end,int db) {
	1536	try {
	1537	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1538	return redisTemplate.opsForZSet().reverseRange(key, start, end);
	1539	} catch (Exception e) {
	1540	e.printStackTrace();
	1541	return null;
	1542	}
	1543	}
a0ad14	1544
C	1545	/**
	1546	* 通过索引区间返回有序集合成指定区间内的成员对象，其中有序集成员按分数值递减(从大到小)顺序排列
	1547	*
	1548	* @param key 键
	1549	* @param start 起始位置 0
	1550	* @param end 末尾位置 -1
	1551	* @return 0 -1 返回按分数递增的顺序集合，返回成员对象
	1552	*/
	1553	public Set zsGetReverseWithScores(String key, long start, long end) {
	1554	try {
	1555	return redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
	1556	} catch (Exception e) {
	1557	e.printStackTrace();
	1558	return null;
	1559	}
	1560	}
	1561
	1562	/**
	1563	* 通过索引区间返回有序集合成指定区间内的成员对象，其中有序集成员按分数值递减(从大到小)顺序排列
	1564	*
	1565	* @param key 键
	1566	* @param start 起始位置 0
	1567	* @param end 末尾位置 -1
	1568	* @return 0 -1 返回按分数递增的顺序集合，返回成员对象
	1569	*/
72f2f5	1570	public Set zsGetReverseWithScores(String key, long start, long end,int db) {
a0ad14	1571	try {
C	1572	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1573	return redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
	1574	} catch (Exception e) {
	1575	e.printStackTrace();
	1576	return null;
	1577	}
	1578	}
	1579	}