redis 工具类 - 工具类 - java - 计算机学科 | D & PersonalBlog = D の Java = 别怕路长梦远

	import java.util.*;
	import java.util.concurrent.TimeUnit;

	@SuppressWarnings(value = { "unchecked", "rawtypes" })
	@Component
	public class RedisCache
	{
	@Autowired
	public RedisTemplate redisTemplate;

	/**
	* 缓存基本的对象，Integer、String、实体类等
	*
	* @param key 缓存的键值
	* @param value 缓存的值
	*/
	public <T> void setCacheObject(final String key, final T value)
	{
	redisTemplate.opsForValue().set(key, value);
	}

	/**
	* 缓存基本的对象，Integer、String、实体类等
	*
	* @param key 缓存的键值
	* @param value 缓存的值
	* @param timeout 时间
	* @param timeUnit 时间颗粒度
	*/
	public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
	{
	redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
	}

	/**
	* 设置有效时间
	*
	* @param key Redis 键
	* @param timeout 超时时间
	* @return true = 设置成功；false = 设置失败
	*/
	public boolean expire(final String key, final long timeout)
	{
	return expire(key, timeout, TimeUnit.SECONDS);
	}

	/**
	* 设置有效时间
	*
	* @param key Redis 键
	* @param timeout 超时时间
	* @param unit 时间单位
	* @return true = 设置成功；false = 设置失败
	*/
	public boolean expire(final String key, final long timeout, final TimeUnit unit)
	{
	return redisTemplate.expire(key, timeout, unit);
	}

	/**
	* 获得缓存的基本对象。
	*
	* @param key 缓存键值
	* @return 缓存键值对应的数据
	*/
	public <T> T getCacheObject(final String key)
	{
	ValueOperations<String, T> operation = redisTemplate.opsForValue();
	return operation.get(key);
	}

	/**
	* 删除单个对象
	*
	* @param key
	*/
	public boolean deleteObject(final String key)
	{
	return redisTemplate.delete(key);
	}

	/**
	* 删除集合对象
	*
	* @param collection 多个对象
	* @return
	*/
	public long deleteObject(final Collection collection)
	{
	return redisTemplate.delete(collection);
	}

	/**
	* 缓存 List 数据
	*
	* @param key 缓存的键值
	* @param dataList 待缓存的 List 数据
	* @return 缓存的对象
	*/
	public <T> long setCacheList(final String key, final List<T> dataList)
	{
	Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
	return count == null ? 0 : count;
	}

	/**
	* 获得缓存的 list 对象
	*
	* @param key 缓存的键值
	* @return 缓存键值对应的数据
	*/
	public <T> List<T> getCacheList(final String key)
	{
	return redisTemplate.opsForList().range(key, 0, -1);
	}

	/**
	* 缓存 Set
	*
	* @param key 缓存键值
	* @param dataSet 缓存的数据
	* @return 缓存数据的对象
	*/
	public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
	{
	BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
	Iterator<T> it = dataSet.iterator();
	while (it.hasNext())
	{
	setOperation.add(it.next());
	}
	return setOperation;
	}

	/**
	* 获得缓存的 set
	*
	* @param key
	* @return
	*/
	public <T> Set<T> getCacheSet(final String key)
	{
	return redisTemplate.opsForSet().members(key);
	}

	/**
	* 缓存 Map
	*
	* @param key
	* @param dataMap
	*/
	public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
	{
	if (dataMap != null) {
	redisTemplate.opsForHash().putAll(key, dataMap);
	}
	}

	/**
	* 获得缓存的 Map
	*
	* @param key
	* @return
	*/
	public <T> Map<String, T> getCacheMap(final String key)
	{
	return redisTemplate.opsForHash().entries(key);
	}

	/**
	* 往 Hash 中存入数据
	*
	* @param key Redis 键
	* @param hKey Hash 键
	* @param value 值
	*/
	public <T> void setCacheMapValue(final String key, final String hKey, final T value)
	{
	redisTemplate.opsForHash().put(key, hKey, value);
	}

	/**
	* 获取 Hash 中的数据
	*
	* @param key Redis 键
	* @param hKey Hash 键
	* @return Hash 中的对象
	*/
	public <T> T getCacheMapValue(final String key, final String hKey)
	{
	HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
	return opsForHash.get(key, hKey);
	}

	/**
	* 删除 Hash 中的数据
	*
	* @param key
	* @param hkey
	*/
	public void delCacheMapValue(final String key, final String hkey)
	{
	HashOperations hashOperations = redisTemplate.opsForHash();
	hashOperations.delete(key, hkey);
	}

	/**
	* 获取多个 Hash 中的数据
	*
	* @param key Redis 键
	* @param hKeys Hash 键集合
	* @return Hash 对象集合
	*/
	public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
	{
	return redisTemplate.opsForHash().multiGet(key, hKeys);
	}

	/**
	* 获得缓存的基本对象列表
	*
	* @param pattern 字符串前缀
	* @return 对象列表
	*/
	public Collection<String> keys(final String pattern)
	{
	return redisTemplate.keys(pattern);
	}
	}

# Redis 使用 FastJson 序列化工具类

	/**
	* Redis 使用 FastJson 序列化
	*
	* @author sg
	*/
	public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {

	public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

	private Class<T> clazz;

	static
	{
	ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
	}

	public FastJsonRedisSerializer(Class<T> clazz)
	{
	super();
	this.clazz = clazz;
	}

	@Override
	public byte[] serialize(T t) throws SerializationException {
	if (t == null)
	{
	return new byte[0];
	}
	return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
	}

	@Override
	public T deserialize(byte[] bytes) throws SerializationException {
	if (bytes == null \|\| bytes.length <= 0)
	{
	return null;
	}
	String str = new String(bytes, DEFAULT_CHARSET);

	return JSON.parseObject(str, clazz);
	}

	protected JavaType getJavaType(Class<?> clazz) {
	return TypeFactory.defaultInstance().constructType(clazz);
	}
	}

计算机学科工具类

# Redis 使用 FastJson 序列化工具类

MyBatis工具类

Result工具类