Jcdm042-Mes.git

懒羊羊

2024-01-31 e57a8990ae56f657a59c435a0613c5f7a8728003

提交 \| 用户 \| 时间
e57a89	1	package com.jcdm.common.core.redis;
懒	2
	3	import org.springframework.cache.Cache;
	4	import org.springframework.stereotype.Component;
	5
	6	import javax.annotation.Resource;
	7	import java.util.Collection;
	8	import java.util.concurrent.TimeUnit;
	9
	10	/**
	11	* spring redis 工具类
	12	*
	13	* @author jc
	14	**/
	15	@SuppressWarnings(value = { "unchecked", "rawtypes" })
	16	@Component
	17	public class RedisCache
	18	{
	19	// @Autowired
	20	// public RedisTemplate redisTemplate;
	21
	22	@Resource
	23	public MyCache myCache;
	24
	25	/**
	26	* 缓存基本的对象，Integer、String、实体类等
	27	*
	28	* @param key 缓存的键值
	29	* @param value 缓存的值
	30	*/
	31	public <T> void setCacheObject(final String key, final T value)
	32	{
	33	myCache.put(key,value);
	34	// redisTemplate.opsForValue().set(key, value);
	35	}
	36
	37	/**
	38	* 缓存基本的对象，Integer、String、实体类等
	39	*
	40	* @param key 缓存的键值
	41	* @param value 缓存的值
	42	* @param timeout 时间
	43	* @param timeUnit 时间颗粒度
	44	*/
	45	public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
	46	{
	47	myCache.put(key,value);
	48	// redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
	49	}
	50
	51	/**
	52	* 设置有效时间
	53	*
	54	* @param key Redis键
	55	* @param timeout 超时时间
	56	* @return true=设置成功；false=设置失败
	57	*/
	58	public boolean expire(final String key, final long timeout)
	59	{
	60	return expire(key, timeout, TimeUnit.SECONDS);
	61	}
	62
	63	/**
	64	* 设置有效时间
	65	*
	66	* @param key Redis键
	67	* @param timeout 超时时间
	68	* @param unit 时间单位
	69	* @return true=设置成功；false=设置失败
	70	*/
	71	public boolean expire(final String key, final long timeout, final TimeUnit unit)
	72	{
	73	return true;
	74	// return redisTemplate.expire(key, timeout, unit);
	75	}
	76
	77	/**
	78	* 获取有效时间
	79	*
	80	* @param key Redis键
	81	* @return 有效时间
	82	*/
	83	// public long getExpire(final String key)
	84	// {
	85	// return redisTemplate.getExpire(key);
	86	// }
	87
	88	/**
	89	* 判断 key是否存在
	90	*
	91	* @param key 键
	92	* @return true 存在 false不存在
	93	*/
	94	public Boolean hasKey(String key)
	95	{
	96	return myCache.hasKey(key);
	97	// return redisTemplate.hasKey(key);
	98	}
	99
	100	/**
	101	* 获得缓存的基本对象。
	102	*
	103	* @param key 缓存键值
	104	* @return 缓存键值对应的数据
	105	*/
	106	public <T> T getCacheObject(final String key)
	107	{
	108	Cache.ValueWrapper valueWrapper = myCache.get(key);
	109	if (valueWrapper == null){
	110	return null;
	111	}else {
	112	return (T) valueWrapper.get();
	113	}
	114	// ValueOperations<String, T> operation = redisTemplate.opsForValue();
	115	// return operation.get(key);
	116	}
	117
	118	/**
	119	* 删除单个对象
	120	*
	121	* @param key
	122	*/
	123	public boolean deleteObject(final String key)
	124	{
	125	myCache.evict(key);
	126	return true;
	127	// return redisTemplate.delete(key);
	128	}
	129
	130	/**
	131	* 删除集合对象
	132	*
	133	* @param collection 多个对象
	134	* @return
	135	*/
	136	public boolean deleteObject(final Collection collection)
	137	{
	138	return myCache.deleteObject(collection);
	139	// return redisTemplate.delete(collection) > 0;
	140	}
	141
	142	/**
	143	* 缓存List数据
	144	*
	145	* @param key 缓存的键值
	146	* @param dataList 待缓存的List数据
	147	* @return 缓存的对象
	148	*/
	149	// public <T> long setCacheList(final String key, final List<T> dataList)
	150	// {
	151	// Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
	152	// return count == null ? 0 : count;
	153	// }
	154
	155	/**
	156	* 获得缓存的list对象
	157	*
	158	* @param key 缓存的键值
	159	* @return 缓存键值对应的数据
	160	*/
	161	// public <T> List<T> getCacheList(final String key)
	162	// {
	163	// return redisTemplate.opsForList().range(key, 0, -1);
	164	// }
	165
	166	/**
	167	* 缓存Set
	168	*
	169	* @param key 缓存键值
	170	* @param dataSet 缓存的数据
	171	* @return 缓存数据的对象
	172	*/
	173	// public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
	174	// {
	175	// BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
	176	// Iterator<T> it = dataSet.iterator();
	177	// while (it.hasNext())
	178	// {
	179	// setOperation.add(it.next());
	180	// }
	181	// return setOperation;
	182	// }
	183
	184	/**
	185	* 获得缓存的set
	186	*
	187	* @param key
	188	* @return
	189	*/
	190	// public <T> Set<T> getCacheSet(final String key)
	191	// {
	192	// return redisTemplate.opsForSet().members(key);
	193	// }
	194
	195	/**
	196	* 缓存Map
	197	*
	198	* @param key
	199	* @param dataMap
	200	*/
	201	// public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
	202	// {
	203	// if (dataMap != null) {
	204	// redisTemplate.opsForHash().putAll(key, dataMap);
	205	// }
	206	// }
	207
	208	/**
	209	* 获得缓存的Map
	210	*
	211	* @param key
	212	* @return
	213	*/
	214	// public <T> Map<String, T> getCacheMap(final String key)
	215	// {
	216	// return redisTemplate.opsForHash().entries(key);
	217	// }
	218
	219	/**
	220	* 往Hash中存入数据
	221	*
	222	* @param key Redis键
	223	* @param hKey Hash键
	224	* @param value 值
	225	*/
	226	// public <T> void setCacheMapValue(final String key, final String hKey, final T value)
	227	// {
	228	// redisTemplate.opsForHash().put(key, hKey, value);
	229	// }
	230
	231	/**
	232	* 获取Hash中的数据
	233	*
	234	* @param key Redis键
	235	* @param hKey Hash键
	236	* @return Hash中的对象
	237	*/
	238	// public <T> T getCacheMapValue(final String key, final String hKey)
	239	// {
	240	// HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
	241	// return opsForHash.get(key, hKey);
	242	// }
	243
	244	/**
	245	* 获取多个Hash中的数据
	246	*
	247	* @param key Redis键
	248	* @param hKeys Hash键集合
	249	* @return Hash对象集合
	250	*/
	251	// public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
	252	// {
	253	// return redisTemplate.opsForHash().multiGet(key, hKeys);
	254	// }
	255
	256	/**
	257	* 删除Hash中的某条数据
	258	*
	259	* @param key Redis键
	260	* @param hKey Hash键
	261	* @return 是否成功
	262	*/
	263	// public boolean deleteCacheMapValue(final String key, final String hKey)
	264	// {
	265	// return redisTemplate.opsForHash().delete(key, hKey) > 0;
	266	// }
	267
	268	/**
	269	* 获得缓存的基本对象列表
	270	*
	271	* @param pattern 字符串前缀
	272	* @return 对象列表
	273	*/
	274	public Collection<String> keys(final String pattern)
	275	{
	276	return myCache.keys(pattern);
	277	// return redisTemplate.keys(pattern);
	278	}
	279	}