~chenjiahe/hx_common.git

chenjiahe

2022-06-28 72f2f59ae69d4f64ef2bd0b4d505a759bd96a610

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