~chenjiahe/hx-redisson.git

guang

2024-06-14 93ac75952d5d6f64256434b99c8da612fa339263

提交 \| 用户 \| age
da6731	1	package com.hx.redisson.config;
C	2
	3	import com.hx.redisson.manager.RedisManager;
848054	4	import org.redisson.api.RLock;
F	5	import org.redisson.api.RedissonClient;
da6731	6	import org.slf4j.Logger;
C	7	import org.slf4j.LoggerFactory;
	8	import org.springframework.beans.factory.annotation.Autowired;
	9	import org.springframework.data.redis.core.RedisTemplate;
	10	import org.springframework.data.redis.core.ZSetOperations;
	11	import org.springframework.util.CollectionUtils;
	12
	13	import java.util.List;
	14	import java.util.Map;
	15	import java.util.Set;
	16	import java.util.concurrent.TimeUnit;
	17
	18	/**
	19	* <h1>RedisUtil 操作工具类</h1>
	20	* @author CJH
	21	*/
	22	public class RedissonUtil {
	23
	24	private Logger logger = LoggerFactory.getLogger(RedissonUtil.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 {
	40	if (time < 0) {
	41	throw new RuntimeException("设置时间不能为负数："+time);
	42	}
	43	return true;
	44	} catch (Exception e) {
	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);
	64	} catch (Exception e) {
	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 {
	81	if (time < 0) {
	82	throw new RuntimeException("设置时间不能为负数："+time);
	83	}
	84	return true;
	85	} catch (Exception e) {
	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);
	106	} catch (Exception e) {
	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
	122
	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
	135	/**
	136	* 判断key是否存在
	137	*
	138	* @param key 键
	139	* @return true 存在 false不存在
	140	*/
	141	public boolean hasKey(String key) {
	142	try {
	143	return redisTemplate.hasKey(key);
	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);
	159	return redisTemplate.hasKey(key);
	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
	182	/**
	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
	199	// ============================String=============================
	200
	201	/**
	202	* 普通缓存获取
	203	*
	204	* @param key 键
	205	* @return 值
	206	*/
	207	public Object get(String key) {
	208	return key == null ? null : redisTemplate.opsForValue().get(key);
	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);
	219	return key == null ? null : redisTemplate.opsForValue().get(key);
	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	/**
	283	* 普通缓存放入并设置时间
	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	/**
	306	* 普通缓存放入并设置时间，并增加时间类型选择
	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	/**
	329	* 普通缓存放入并设置时间，并增加时间类型选择
	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	/**
	353	* 递增
	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	}
	363	return redisTemplate.opsForValue().increment(key, delta);
	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);
	378	return redisTemplate.opsForValue().increment(key, delta);
	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
	395	/**
	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
	410
	411	/**如果值存在就不存入，如果不存在就存入
	412	* @param key 键
	413	* @param value 值
	414	* @param timeOut 时间
	415	* @param unit 时间单位
	416	*/
	417	public Boolean setIfAbsent(String key, Object value, long timeOut, TimeUnit unit) {
	418	try {
	419	return redisTemplate.opsForValue().setIfAbsent(key, value, timeOut, unit);
	420	} catch (Exception e) {
	421	e.printStackTrace();
	422	return null;
	423	}
	424	}
	425
	426	/**如果值存在就不存入，如果不存在就存入
	427	* @param key 键
	428	* @param value 值
	429	* @param timeOut 时间
	430	* @param unit 时间单位
	431	*/
	432	public Boolean setIfAbsent(String key, Object value, long timeOut, TimeUnit unit,int db) {
	433	try {
	434	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	435	return redisTemplate.opsForValue().setIfAbsent(key, value, timeOut, unit);
	436	} catch (Exception e) {
	437	e.printStackTrace();
	438	return null;
	439	}
	440	}
	441
	442	// ================================Map=================================
	443
	444	/**
	445	* HashGet
	446	*
	447	* @param key 键不能为null
	448	* @param item 项不能为null
	449	* @return 值
	450	*/
	451	public Object hget(String key, String item) {
	452	return redisTemplate.opsForHash().get(key, item);
	453	}
	454
	455	/**
	456	* HashGet
	457	*
	458	* @param key 键不能为null
	459	* @param item 项不能为null
	460	* @return 值
	461	*/
	462	public Object hget(String key, String item,int db) {
	463	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	464	return redisTemplate.opsForHash().get(key, item);
	465	}
	466
	467	/**
	468	* 获取hashKey对应的所有键值
	469	*
	470	* @param key 键
	471	* @return 对应的多个键值
	472	*/
	473	public Map<Object, Object> hmget(String key) {
	474	return redisTemplate.opsForHash().entries(key);
	475	}
	476
	477	/**
	478	* 获取hashKey对应的所有键值
	479	*
	480	* @param key 键
	481	* @return 对应的多个键值
	482	*/
	483	public Map<Object, Object> hmget(String key,int db) {
	484	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	485	return redisTemplate.opsForHash().entries(key);
	486	}
	487
	488
	489	/**
	490	* HashSet
	491	*
	492	* @param key 键
	493	* @param map 对应多个键值
	494	* @return true 成功 false 失败
	495	*/
	496	public boolean hmset(String key, Map<String, Object> map) {
	497	try {
	498	redisTemplate.opsForHash().putAll(key, map);
	499	return true;
	500	} catch (Exception e) {
	501	e.printStackTrace();
	502	return false;
	503	}
	504	}
	505
	506	/**
	507	* HashSet
	508	*
	509	* @param key 键
	510	* @param map 对应多个键值
	511	* @return true 成功 false 失败
	512	*/
	513	public boolean hmset(String key, Map<String, Object> map,int db) {
	514	try {
	515	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	516	redisTemplate.opsForHash().putAll(key, map);
	517	return true;
	518	} catch (Exception e) {
	519	e.printStackTrace();
	520	return false;
	521	}
	522	}
	523
	524	/**
	525	* HashSet 并设置时间
	526	*
	527	* @param key 键
	528	* @param map 对应多个键值
	529	* @param time 时间(秒)
	530	* @return true成功 false失败
	531	*/
	532	public boolean hmset(String key, Map<String, Object> map, long time) {
	533	try {
	534	redisTemplate.opsForHash().putAll(key, map);
	535	if (time > 0) {
	536	expire(key, time);
	537	}
	538	return true;
	539	} catch (Exception e) {
	540	e.printStackTrace();
	541	return false;
	542	}
	543	}
	544
	545	/**
	546	* HashSet 并设置时间
	547	*
	548	* @param key 键
	549	* @param map 对应多个键值
	550	* @param time 时间(秒)
	551	* @return true成功 false失败
	552	*/
	553	public boolean hmset(String key, Map<String, Object> map, long time,int db) {
	554	try {
	555	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	556	redisTemplate.opsForHash().putAll(key, map);
	557	if (time > 0) {
	558	expire(key, time,db);
	559	}
	560	return true;
	561	} catch (Exception e) {
	562	e.printStackTrace();
	563	return false;
	564	}
	565	}
	566
	567	/**
	568	* 向一张hash表中放入数据,如果不存在将创建
	569	*
	570	* @param key 键
	571	* @param item 项
	572	* @param value 值
	573	* @return true 成功 false失败
	574	*/
	575	public boolean hset(String key, String item, Object value) {
	576	try {
	577	redisTemplate.opsForHash().put(key, item, value);
	578	return true;
	579	} catch (Exception e) {
	580	e.printStackTrace();
	581	return false;
	582	}
	583	}
	584
	585	/**
	586	* 向一张hash表中放入数据,如果不存在将创建
	587	*
	588	* @param key 键
	589	* @param item 项
	590	* @param value 值
	591	* @return true 成功 false失败
	592	*/
	593	public boolean hset(String key, String item, Object value,int db) {
	594	try {
	595	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	596	redisTemplate.opsForHash().put(key, item, value);
	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) {
	614	try {
	615	redisTemplate.opsForHash().put(key, item, value);
	616	if (time > 0) {
	617	expire(key, time);
	618	}
	619	return true;
	620	} catch (Exception e) {
	621	e.printStackTrace();
	622	return false;
	623	}
	624	}
	625
	626	/**
	627	* 向一张hash表中放入数据,如果不存在将创建
	628	*
	629	* @param key 键
	630	* @param item 项
	631	* @param value 值
	632	* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
	633	* @return true 成功 false失败
	634	*/
	635	public boolean hset(String key, String item, Object value, long time,int db) {
	636	try {
	637	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	638	redisTemplate.opsForHash().put(key, item, value);
	639	if (time > 0) {
	640	expire(key, time,db);
	641	}
	642	return true;
	643	} catch (Exception e) {
	644	e.printStackTrace();
	645	return false;
	646	}
	647	}
	648
	649	/**
	650	* 删除hash表中的值
	651	*
	652	* @param key 键不能为null
	653	* @param item 项可以使多个不能为null
	654	*/
	655	public void hdel(String key, Object... item) {
	656	redisTemplate.opsForHash().delete(key, item);
	657	}
	658
	659	/**
	660	* 删除hash表中的值
	661	*
	662	* @param key 键不能为null
	663	* @param item 项可以使多个不能为null
	664	*/
	665	public void hdel(int db,String key, Object... item) {
	666	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	667	redisTemplate.opsForHash().delete(key, item);
	668	}
	669
	670	/**
	671	* 判断hash表中是否有该项的值
	672	*
	673	* @param key 键不能为null
	674	* @param item 项不能为null
	675	* @return true 存在 false不存在
	676	*/
	677	public boolean hHasKey(String key, String item) {
	678	return redisTemplate.opsForHash().hasKey(key, item);
	679	}
	680
	681	/**
	682	* 判断hash表中是否有该项的值
	683	*
	684	* @param key 键不能为null
	685	* @param item 项不能为null
	686	* @return true 存在 false不存在
	687	*/
	688	public boolean hHasKey(String key, String item,int db) {
	689	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	690	return redisTemplate.opsForHash().hasKey(key, item);
	691	}
	692
	693
	694	/**
	695	* hash递增如果不存在,就会创建一个并把新增后的值返回
	696	*
	697	* @param key 键
	698	* @param item 项
	699	* @param by 要增加几(大于0)
	700	* @return
	701	*/
	702	public double hincr(String key, String item, double by) {
	703	return redisTemplate.opsForHash().increment(key, item, by);
	704	}
	705
	706	/**
	707	* hash递增如果不存在,就会创建一个并把新增后的值返回
	708	*
	709	* @param key 键
	710	* @param item 项
	711	* @param by 要增加几(大于0)
	712	* @return
	713	*/
	714	public double hincr(String key, String item, double by,int db) {
	715	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	716	return redisTemplate.opsForHash().increment(key, item, by);
	717	}
	718
	719	/**
	720	* hash递减
	721	*
	722	* @param key 键
	723	* @param item 项
	724	* @param by 要减少记(小于0)
	725	* @return
	726	*/
	727	public double hdecr(String key, String item, double by) {
	728	return redisTemplate.opsForHash().increment(key, item, -by);
	729	}
	730
	731	/**
	732	* hash递减
	733	*
	734	* @param key 键
	735	* @param item 项
	736	* @param by 要减少记(小于0)
	737	* @return
	738	*/
	739	public double hdecr(String key, String item, double by,int db) {
	740	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	741	return redisTemplate.opsForHash().increment(key, item, -by);
	742	}
	743
	744	// ============================set=============================
	745
	746	/**
	747	* 根据key获取Set中的所有值
	748	*
	749	* @param key 键
	750	* @return
	751	*/
	752	public Set<Object> sGet(String key) {
	753	try {
	754	return redisTemplate.opsForSet().members(key);
	755	} catch (Exception e) {
	756	e.printStackTrace();
	757	return null;
	758	}
	759	}
	760
	761	/**
	762	* 根据key获取Set中的所有值
	763	*
	764	* @param key 键
	765	* @return
	766	*/
	767	public Set<Object> sGet(String key,int db) {
	768	try {
	769	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	770	return redisTemplate.opsForSet().members(key);
	771	} catch (Exception e) {
	772	e.printStackTrace();
	773	return null;
	774	}
	775	}
	776
	777	/**
	778	* 根据key获取Set中的指定几个随机内容
	779	*
	780	* @param key 键
	781	* @param size 个数
	782	* @return
	783	*/
	784	public List sRandomGet(String key, Integer size) {
	785	try {
	786	return redisTemplate.opsForSet().randomMembers(key, size);
	787	} catch (Exception e) {
	788	e.printStackTrace();
	789	return null;
	790	}
	791	}
	792
	793	/**
	794	* 根据key获取Set中的指定几个随机内容
	795	*
	796	* @param key 键
	797	* @param size 个数
	798	* @return
	799	*/
	800	public List sRandomGet(String key, Integer size,int db) {
	801	try {
	802	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	803	return redisTemplate.opsForSet().randomMembers(key, size);
	804	} catch (Exception e) {
	805	e.printStackTrace();
	806	return null;
	807	}
	808	}
	809
	810	/**
	811	* 根据value从一个set中查询,是否存在
	812	*
	813	* @param key 键
	814	* @param value 值
	815	* @return true 存在 false不存在
	816	*/
	817	public boolean sHasKey(String key, Object value) {
	818	try {
	819	return redisTemplate.opsForSet().isMember(key, value);
	820	} catch (Exception e) {
	821	e.printStackTrace();
	822	return false;
	823	}
	824	}
	825
	826	/**
	827	* 根据value从一个set中查询,是否存在
	828	*
	829	* @param key 键
	830	* @param value 值
	831	* @return true 存在 false不存在
	832	*/
	833	public boolean sHasKey(String key, Object value,int db) {
	834	try {
	835	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	836	return redisTemplate.opsForSet().isMember(key, value);
	837	} catch (Exception e) {
	838	e.printStackTrace();
	839	return false;
	840	}
	841	}
	842
	843	/**
	844	* 将数据放入set缓存
	845	*
	846	* @param key 键
	847	* @param values 值可以是多个
	848	* @return 成功个数
	849	*/
	850	public long sSet(String key, Object... values) {
	851	try {
	852	return redisTemplate.opsForSet().add(key, values);
	853	} catch (Exception e) {
	854	e.printStackTrace();
	855	return 0;
	856	}
	857	}
	858
	859	/**
	860	* 将数据放入set缓存
	861	*
	862	* @param key 键
	863	* @param values 值可以是多个
	864	* @return 成功个数
	865	*/
	866	public long sSet(int db,String key, Object... values) {
	867	try {
	868	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	869	return redisTemplate.opsForSet().add(key, values);
	870	} catch (Exception e) {
	871	e.printStackTrace();
	872	return 0;
	873	}
	874	}
	875
	876	/**
	877	* 将set数据放入缓存
	878	*
	879	* @param key 键
	880	* @param time 时间(秒)
	881	* @param values 值可以是多个
	882	* @return 成功个数
	883	*/
	884	public long sSetAndTime(String key, long time, Object... values) {
	885	try {
	886	Long count = redisTemplate.opsForSet().add(key, values);
	887	if (time > 0) {
	888	expire(key, time);
	889	}
	890	return count;
	891	} catch (Exception e) {
	892	e.printStackTrace();
	893	return 0;
	894	}
	895	}
	896
	897	/**
	898	* 将set数据放入缓存
	899	*
	900	* @param key 键
	901	* @param time 时间(秒)
	902	* @param values 值可以是多个
	903	* @return 成功个数
	904	*/
	905	public long sSetAndTime(int db,String key, long time, Object... values) {
	906	try {
	907	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	908	Long count = redisTemplate.opsForSet().add(key, values);
	909	if (time > 0) {
	910	expire(key, time,db);
	911	}
	912	return count;
	913	} catch (Exception e) {
	914	e.printStackTrace();
	915	return 0;
	916	}
	917	}
	918
	919	/**
	920	* 获取set缓存的长度
	921	*
	922	* @param key 键
	923	* @return
	924	*/
	925	public long sGetSetSize(String key) {
	926	try {
	927	return redisTemplate.opsForSet().size(key);
	928	} catch (Exception e) {
	929	e.printStackTrace();
	930	return 0;
	931	}
	932	}
	933
	934	/**
	935	* 获取set缓存的长度
	936	*
	937	* @param key 键
	938	* @return
	939	*/
	940	public long sGetSetSize(String key,int db) {
	941	try {
	942	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	943	return redisTemplate.opsForSet().size(key);
	944	} catch (Exception e) {
	945	e.printStackTrace();
	946	return 0;
	947	}
	948	}
	949
	950	/**
	951	* 移除值为value的
	952	*
	953	* @param key 键
	954	* @param values 值可以是多个
	955	* @return 移除的个数
	956	*/
	957	public long setRemove(String key, Object... values) {
	958	try {
	959	Long count = redisTemplate.opsForSet().remove(key, values);
	960	return count;
	961	} catch (Exception e) {
	962	e.printStackTrace();
	963	return 0;
	964	}
	965	}
	966
	967
	968	/**
	969	* 移除值为value的
	970	*
	971	* @param key 键
	972	* @param values 值可以是多个
	973	* @return 移除的个数
	974	*/
	975	public long setRemove(int db,String key, Object... values) {
	976	try {
	977	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	978	Long count = redisTemplate.opsForSet().remove(key, values);
	979	return count;
	980	} catch (Exception e) {
	981	e.printStackTrace();
	982	return 0;
	983	}
	984	}
	985	// ===============================list=================================
	986
	987	/**
	988	* 获取list缓存的内容
	989	*
	990	* @param key 键
	991	* @param start 开始
	992	* @param end 结束 0 到 -1代表所有值
	993	* @return
	994	*/
	995	public List<Object> lGet(String key, long start, long end) {
	996	try {
	997	return redisTemplate.opsForList().range(key, start, end);
	998	} catch (Exception e) {
	999	e.printStackTrace();
	1000	return null;
	1001	}
	1002	}
	1003
	1004	/**
	1005	* 获取list缓存的内容
	1006	*
	1007	* @param key 键
	1008	* @param start 开始
	1009	* @param end 结束 0 到 -1代表所有值
	1010	* @return
	1011	*/
	1012	public List<Object> lGet(String key, long start, long end,int db) {
	1013	try {
	1014	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1015	return redisTemplate.opsForList().range(key, start, end);
	1016	} catch (Exception e) {
	1017	e.printStackTrace();
	1018	return null;
	1019	}
	1020	}
	1021
	1022	/**
	1023	* 获取list缓存的长度
	1024	*
	1025	* @param key 键
	1026	* @return
	1027	*/
	1028	public long lGetListSize(String key) {
	1029	try {
	1030	return redisTemplate.opsForList().size(key);
	1031	} catch (Exception e) {
	1032	e.printStackTrace();
	1033	return 0;
	1034	}
	1035	}
	1036
	1037	/**
	1038	* 获取list缓存的长度
	1039	*
	1040	* @param key 键
	1041	* @return
	1042	*/
	1043	public long lGetListSize(String key,int db) {
	1044	try {
	1045	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1046	return redisTemplate.opsForList().size(key);
	1047	} catch (Exception e) {
	1048	e.printStackTrace();
	1049	return 0;
	1050	}
	1051	}
	1052
	1053	/**
	1054	* 通过索引获取list中的值
	1055	*
	1056	* @param key 键
	1057	* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
	1058	* @return
	1059	*/
	1060	public Object lGetIndex(String key, long index) {
	1061	try {
	1062	return redisTemplate.opsForList().index(key, index);
	1063	} catch (Exception e) {
	1064	e.printStackTrace();
	1065	return null;
	1066	}
	1067	}
	1068
	1069	/**
	1070	* 通过索引获取list中的值
	1071	*
	1072	* @param key 键
	1073	* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
	1074	* @return
	1075	*/
	1076	public Object lGetIndex(String key, long index,int db) {
	1077	try {
	1078	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1079	return redisTemplate.opsForList().index(key, index);
	1080	} catch (Exception e) {
	1081	e.printStackTrace();
	1082	return null;
	1083	}
	1084	}
	1085
	1086	/**
	1087	* 将list放入缓存
	1088	*
	1089	* @param key 键
	1090	* @param value 值
	1091	* @return
	1092	*/
	1093	public boolean lSet(String key, Object value) {
	1094	try {
	1095	redisTemplate.opsForList().rightPush(key, value);
	1096	return true;
	1097	} catch (Exception e) {
	1098	e.printStackTrace();
	1099	return false;
	1100	}
	1101	}
	1102
	1103	/**
	1104	* 将list放入缓存
	1105	*
	1106	* @param key 键
	1107	* @param value 值
	1108	* @return
	1109	*/
	1110	public boolean lSet(String key, Object value,int db) {
	1111	try {
	1112	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1113	redisTemplate.opsForList().rightPush(key, value);
	1114	return true;
	1115	} catch (Exception e) {
	1116	e.printStackTrace();
	1117	return false;
	1118	}
	1119	}
	1120
	1121	/**
	1122	* 将list放入缓存
	1123	*
	1124	* @param key 键
	1125	* @param value 值
	1126	* @param time 时间(秒)
	1127	* @return
	1128	*/
	1129	public boolean lSet(String key, Object value, long time) {
	1130	try {
	1131	redisTemplate.opsForList().rightPush(key, value);
	1132	if (time > 0) {
	1133	expire(key, time);
	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 值
	1147	* @param time 时间(秒)
	1148	* @return
	1149	*/
	1150	public boolean lSet(String key, Object value, long time,int db) {
	1151	try {
	1152	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1153	redisTemplate.opsForList().rightPush(key, value);
	1154	if (time > 0) {
	1155	expire(key, time,db);
	1156	}
	1157	return true;
	1158	} catch (Exception e) {
	1159	e.printStackTrace();
	1160	return false;
	1161	}
	1162	}
	1163
	1164	/**
	1165	* 将list放入缓存
	1166	*
	1167	* @param key 键
	1168	* @param value 值
	1169	* @return
	1170	*/
	1171	public boolean lSetAll(String key, List<Object> value) {
	1172	try {
	1173	redisTemplate.opsForList().rightPushAll(key, value);
	1174	return true;
	1175	} catch (Exception e) {
	1176	e.printStackTrace();
	1177	return false;
	1178	}
	1179	}
	1180
	1181	/**
	1182	* 将list放入缓存
	1183	*
	1184	* @param key 键
	1185	* @param value 值
	1186	* @return
	1187	*/
	1188	public boolean lSetAll(String key, List<Object> value,int db) {
	1189	try {
	1190	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1191	redisTemplate.opsForList().rightPushAll(key, value);
	1192	return true;
	1193	} catch (Exception e) {
	1194	e.printStackTrace();
	1195	return false;
	1196	}
	1197	}
	1198
	1199	/**
	1200	* 将list放入缓存
	1201	*
	1202	* @param key 键
	1203	* @param value 值
	1204	* @param time 时间(秒)
	1205	* @return
	1206	*/
	1207	public boolean lSetAll(String key, List<Object> value, long time) {
	1208	try {
	1209	// 设置超时时间原子化
	1210	redisTemplate.opsForList().rightPushAll(key, value);
	1211	if (time > 0) {
	1212	expire(key, time);
	1213	}
	1214	return true;
	1215	} catch (Exception e) {
	1216	e.printStackTrace();
	1217	return false;
	1218	}
	1219	}
	1220
	1221	/**
	1222	* 将list放入缓存
	1223	*
	1224	* @param key 键
	1225	* @param value 值
	1226	* @param time 时间(秒)
	1227	* @return
	1228	*/
	1229	public boolean lSetAll(String key, List<Object> value, long time,int db) {
	1230	try {
	1231	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1232	// 设置超时时间原子化
	1233	redisTemplate.opsForList().rightPushAll(key, value);
	1234	if (time > 0) {
	1235	expire(key, time,db);
	1236	}
	1237	return true;
	1238	} catch (Exception e) {
	1239	e.printStackTrace();
	1240	return false;
	1241	}
	1242	}
	1243
	1244	/**
	1245	* 根据索引修改list中的某条数据
	1246	*
	1247	* @param key 键
	1248	* @param index 索引
	1249	* @param value 值
	1250	* @return
	1251	*/
	1252	public boolean lUpdateIndex(String key, long index, Object value) {
	1253	try {
	1254	redisTemplate.opsForList().set(key, index, value);
	1255	return true;
	1256	} catch (Exception e) {
	1257	e.printStackTrace();
	1258	return false;
	1259	}
	1260	}
	1261
	1262	/**
	1263	* 根据索引修改list中的某条数据
	1264	*
	1265	* @param key 键
	1266	* @param index 索引
	1267	* @param value 值
	1268	* @return
	1269	*/
	1270	public boolean lUpdateIndex(String key, long index, Object value,int db) {
	1271	try {
	1272	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1273	redisTemplate.opsForList().set(key, index, value);
	1274	return true;
	1275	} catch (Exception e) {
	1276	e.printStackTrace();
	1277	return false;
	1278	}
	1279	}
	1280
	1281	/**
	1282	* 移除N个值为value
	1283	*
	1284	* @param key 键
	1285	* @param count 移除多少个
	1286	* @param value 值
	1287	* @return 移除的个数
	1288	*/
	1289	public long lRemove(String key, long count, Object value) {
	1290	try {
	1291	Long remove = redisTemplate.opsForList().remove(key, count, value);
	1292	return remove;
	1293	} catch (Exception e) {
	1294	e.printStackTrace();
	1295	return 0;
	1296	}
	1297	}
	1298
	1299	/**
	1300	* 移除N个值为value
	1301	*
	1302	* @param key 键
	1303	* @param count 移除多少个
	1304	* @param value 值
	1305	* @return 移除的个数
	1306	*/
	1307	public long lRemove(String key, long count, Object value,int db) {
	1308	try {
	1309	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1310	Long remove = redisTemplate.opsForList().remove(key, count, value);
	1311	return remove;
	1312	} catch (Exception e) {
	1313	e.printStackTrace();
	1314	return 0;
	1315	}
	1316	}
	1317
	1318
	1319	/**
	1320	* 根据给定的布隆过滤器添加值
	1321	*
	1322	* @param bloomFilterHelper bloom布隆过滤器解析类
	1323	* @param key redis 的key
	1324	* @param value redis 的value
	1325	* @param <T> 值的类型
	1326	*/
	1327	/*public <T> void addByBloomFilter(BloomFilterHelper<T> bloomFilterHelper, String key, T value) {
	1328	Preconditions.checkArgument(bloomFilterHelper != null, "bloomFilterHelper不能为空");
	1329	int[] offset = bloomFilterHelper.murmurHashOffset(value);
	1330	for (int i : offset) {
	1331	redisTemplate.opsForValue().setBit(key, i, true);
	1332	}
	1333	}*/
	1334
	1335
	1336	/**
	1337	* 根据给定的布隆过滤器判断值是否存在
	1338	*
	1339	* @param bloomFilterHelper bloom布隆过滤器解析类
	1340	* @param key redis 的key
	1341	* @param value redis 的value
	1342	* @param <T> 值的类型
	1343	* @return 存在 true
	1344	*/
	1345	/* public <T> boolean includeByBloomFilter(BloomFilterHelper<T> bloomFilterHelper, String key, T value) {
	1346	Preconditions.checkArgument(bloomFilterHelper != null, "bloomFilterHelper不能为空");
	1347	int[] offset = bloomFilterHelper.murmurHashOffset(value);
	1348	for (int i : offset) {
	1349	if (!redisTemplate.opsForValue().getBit(key, i)) {
	1350	return false;
	1351	}
	1352	}
	1353	return true;
	1354	}*/
	1355
	1356
	1357	/**
	1358	* zset 添加元素
	1359	*
	1360	* @param key
	1361	* @param time
	1362	* @param tuples
	1363	* @return
	1364	*/
	1365	public long zsSetAndTime(String key, long time, Set<ZSetOperations.TypedTuple<Object>> tuples) {
	1366	try {
	1367	Long count = redisTemplate.opsForZSet().add(key, tuples);
	1368	if (time > 0) {
	1369	expire(key, time);
	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 time
	1383	* @param tuples
	1384	* @return
	1385	*/
	1386	public long zsSetAndTime(String key, long time, Set<ZSetOperations.TypedTuple<Object>> tuples,int db) {
	1387	try {
	1388	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1389	Long count = redisTemplate.opsForZSet().add(key, tuples);
	1390	if (time > 0) {
	1391	expire(key, time,db);
	1392	}
	1393	return count;
	1394	} catch (Exception e) {
	1395	e.printStackTrace();
	1396	return 0;
	1397	}
	1398	}
	1399
	1400	/**
	1401	* zset 添加元素
	1402	*
	1403	* @param key
	1404	* @param tuples
	1405	* @return
	1406	*/
	1407	public long zsSet(String key, Set<ZSetOperations.TypedTuple<Object>> tuples) {
	1408	try {
	1409	Long count = redisTemplate.opsForZSet().add(key, tuples);
	1410	return count;
	1411	} catch (Exception e) {
	1412	e.printStackTrace();
	1413	return 0;
	1414	}
	1415	}
	1416
	1417	/**
	1418	* zset 添加元素
	1419	*
	1420	* @param key
	1421	* @param tuples
	1422	* @return
	1423	*/
	1424	public long zsSet(String key, Set<ZSetOperations.TypedTuple<Object>> tuples,int db) {
	1425	try {
	1426	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1427	Long count = redisTemplate.opsForZSet().add(key, tuples);
	1428	return count;
	1429	} catch (Exception e) {
	1430	e.printStackTrace();
	1431	return 0;
	1432	}
	1433	}
	1434
	1435	/**
	1436	* zs 移除元素
	1437	*
	1438	* @param key
	1439	* @param values
	1440	* @return
	1441	*/
	1442	public long zsRemove(String key, Object... values) {
	1443	try {
	1444	Long remove = redisTemplate.opsForZSet().remove(key, values);
	1445	return remove;
	1446	} catch (Exception e) {
	1447	e.printStackTrace();
	1448	return 0;
	1449	}
	1450	}
	1451
	1452
	1453	/**
	1454	* zs 移除元素
	1455	*
	1456	* @param key
	1457	* @param values
	1458	* @return
	1459	*/
	1460	public long zsRemove(int db,String key, Object... values) {
	1461	try {
	1462	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1463	Long remove = redisTemplate.opsForZSet().remove(key, values);
	1464	return remove;
	1465	} catch (Exception e) {
	1466	e.printStackTrace();
	1467	return 0;
	1468	}
	1469	}
	1470
	1471	/**
	1472	* 通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列
	1473	*
	1474	* @param key 键
	1475	* @param start 起始位置 0
	1476	* @param end 末尾位置 -1
	1477	* @return 0 -1 返回按分数递增的顺序集合仅返回 key
	1478	*/
	1479	public Set zsGet(String key, long start, long end) {
	1480	try {
	1481	return redisTemplate.opsForZSet().range(key, start, end);
	1482	} catch (Exception e) {
	1483	e.printStackTrace();
	1484	return null;
	1485	}
	1486	}
	1487
	1488	/**
	1489	* 通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列
	1490	*
	1491	* @param key 键
	1492	* @param start 起始位置 0
	1493	* @param end 末尾位置 -1
	1494	* @return 0 -1 返回按分数递增的顺序集合仅返回 key
	1495	*/
	1496	public Set zsGet(String key, long start, long end,int db) {
	1497	try {
	1498	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1499	return redisTemplate.opsForZSet().range(key, start, end);
	1500	} catch (Exception e) {
	1501	e.printStackTrace();
	1502	return null;
	1503	}
	1504	}
	1505
	1506
	1507	/**
	1508	* 通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列
	1509	*
	1510	* @param key 键
	1511	* @param start 起始位置 0
	1512	* @param end 末尾位置 -1
	1513	* @return 0 -1 返回按分数递增的顺序集合，返回成员对象
	1514	*/
	1515	public Set zsGetWithScores(String key, long start, long end) {
	1516	try {
	1517	return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
	1518	} catch (Exception e) {
	1519	e.printStackTrace();
	1520	return null;
	1521	}
	1522	}
	1523
	1524	/**
	1525	* 通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列
	1526	*
	1527	* @param key 键
	1528	* @param start 起始位置 0
	1529	* @param end 末尾位置 -1
	1530	* @return 0 -1 返回按分数递增的顺序集合，返回成员对象
	1531	*/
	1532	public Set zsGetWithScores(String key, long start, long end,int db) {
	1533	try {
	1534	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1535	return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
	1536	} catch (Exception e) {
	1537	e.printStackTrace();
	1538	return null;
	1539	}
	1540	}
	1541
	1542	/**
	1543	* 通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递减(从大到小)顺序排列
	1544	*
	1545	* @param key 键
	1546	* @param start 起始位置 0
	1547	* @param end 末尾位置 -1
	1548	* @return 0 -1 返回按分数递增的顺序集合仅返回 key
	1549	*/
	1550	public Set zsGetReverse(String key, long start, long end) {
	1551	try {
	1552	return redisTemplate.opsForZSet().reverseRange(key, start, end);
	1553	} catch (Exception e) {
	1554	e.printStackTrace();
	1555	return null;
	1556	}
	1557	}
	1558
	1559	/**
	1560	* 通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递减(从大到小)顺序排列
	1561	*
	1562	* @param key 键
	1563	* @param start 起始位置 0
	1564	* @param end 末尾位置 -1
	1565	* @return 0 -1 返回按分数递增的顺序集合仅返回 key
	1566	*/
	1567	public Set zsGetReverse(String key, long start, long end,int db) {
	1568	try {
	1569	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1570	return redisTemplate.opsForZSet().reverseRange(key, start, end);
	1571	} catch (Exception e) {
	1572	e.printStackTrace();
	1573	return null;
	1574	}
	1575	}
	1576
	1577	/**
	1578	* 通过索引区间返回有序集合成指定区间内的成员对象，其中有序集成员按分数值递减(从大到小)顺序排列
	1579	*
	1580	* @param key 键
	1581	* @param start 起始位置 0
	1582	* @param end 末尾位置 -1
	1583	* @return 0 -1 返回按分数递增的顺序集合，返回成员对象
	1584	*/
	1585	public Set zsGetReverseWithScores(String key, long start, long end) {
	1586	try {
	1587	return redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
	1588	} catch (Exception e) {
	1589	e.printStackTrace();
	1590	return null;
	1591	}
	1592	}
	1593
	1594	/**
	1595	* 通过索引区间返回有序集合成指定区间内的成员对象，其中有序集成员按分数值递减(从大到小)顺序排列
	1596	*
	1597	* @param key 键
	1598	* @param start 起始位置 0
	1599	* @param end 末尾位置 -1
	1600	* @return 0 -1 返回按分数递增的顺序集合，返回成员对象
	1601	*/
	1602	public Set zsGetReverseWithScores(String key, long start, long end,int db) {
	1603	try {
	1604	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1605	return redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
	1606	} catch (Exception e) {
	1607	e.printStackTrace();
	1608	return null;
	1609	}
	1610	}
848054	1611
F	1612	/**
	1613	* 原子加
	1614	* @param key 键
	1615	* @param num 数量
	1616	*/
	1617	public Long increment(String key,long num) {
	1618	try {
	1619	return redisTemplate.opsForValue().increment(key, num);
	1620	} catch (Exception e) {
	1621	e.printStackTrace();
	1622	return null;
	1623	}
	1624	}
	1625
	1626	/**
	1627	* 原子加
	1628	* @param key 键
	1629	* @param num 数量
	1630	* @param db 数据库
	1631	*/
	1632	public Long increment(String key,long num,int db) {
	1633	try {
	1634	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1635	return redisTemplate.opsForValue().increment(key, num);
	1636	} catch (Exception e) {
	1637	e.printStackTrace();
	1638	return null;
	1639	}
	1640	}
	1641
	1642	/**
	1643	* 原子减
	1644	* @param key 键
	1645	* @param num 数量
	1646	*/
	1647	public Long decrement(String key,long num) {
	1648	try {
	1649	return redisTemplate.opsForValue().decrement(key, num);
	1650	} catch (Exception e) {
	1651	e.printStackTrace();
	1652	return null;
	1653	}
	1654	}
	1655
	1656	/**
	1657	* 原子减
	1658	* @param key 键
	1659	* @param num 数量
	1660	* @param db 数据库
	1661	*/
	1662	public Long decrement(String key,long num,int db) {
	1663	try {
	1664	RedisTemplate redisTemplate = redisManager.getRedisTemplate(db);
	1665	return redisTemplate.opsForValue().decrement(key, num);
	1666	} catch (Exception e) {
	1667	e.printStackTrace();
	1668	return null;
	1669	}
	1670	}
	1671
	1672
	1673	/**
	1674	* 获取红锁
	1675	* @param key 锁key
	1676	* @param db 数据库编号
	1677	*/
	1678	public RLock getRLock(String key,int db) {
	1679	RLock lock = null;
	1680	try {
	1681	RedissonClient redissonClient = RedisManager.redissonTemplateMap.get(db+"");
	1682	lock = redissonClient.getLock(key);
	1683	} catch (Exception e) {
	1684	e.printStackTrace();
	1685	}
	1686	return lock;
	1687	}
	1688
da6731	1689	}