使用redisTemplete简单封装的一个通用操作类

import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

/**
* Redis操作类
*/
public class RedisManager {
/**
* 过期时间，默认30分钟
*/
private Long expireTime = 1000 * 60 * 30L;

/**
* Redis模版
*/
private RedisTemplate<Serializable, Serializable> redisTemplate;

public void setRedisTemplate(RedisTemplate<Serializable, Serializable> redisTemplate) {
this.redisTemplate = redisTemplate;
}

public void setExpireTime(long expireTime) {
this.expireTime = expireTime;
}

private RedisSerializer<Object> getKeySerializer() {
return (RedisSerializer<Object>) redisTemplate.getKeySerializer();
}

private RedisSerializer<Object> getValueSerializer() {
return (RedisSerializer<Object>) redisTemplate.getValueSerializer();
}

private RedisSerializer<Object> getHashKeySerializer() {
return (RedisSerializer<Object>) redisTemplate.getHashKeySerializer();
}

private RedisSerializer<Object> getHashValueSerializer() {
return (RedisSerializer<Object>) redisTemplate.getHashValueSerializer();
}

private byte[] getKeyBytes(Object key) {
return getKeySerializer().serialize(key);
}

private byte[] getHashKeyBytes(Object key) {
return getHashKeySerializer().serialize(key);
}

private byte[] getValueBytes(Object value) {
return getValueSerializer().serialize(value);
}

private byte[] getHashValueBytes(Object value) {
return getHashValueSerializer().serialize(value);
}

private <T> T deserializeValue(byte[] bytes) {
return (T) getValueSerializer().deserialize(bytes);
}

private <T> T deserializeHashValue(byte[] bytes) {
return (T) getHashValueSerializer().deserialize(bytes);
}

/**
* 添加缓存数据（给定key已存在，进行覆盖）
*
* @param key
* @param value
* @throws DataAccessException
*/
public void set(final Object key, final Object value) throws DataAccessException {
redisTemplate.execute(new RedisCallback<Void>() {
@Override
public Void doInRedis(RedisConnection connection)
throws DataAccessException {
connection.set(getKeyBytes(key), getValueBytes(value));
return null;
}
});
}

/**
* 添加缓存数据（给定key已存在，不进行覆盖，直接返回false）
*
* @param key
* @param value
* @return 操作成功返回true，否则返回false
* @throws DataAccessException
*/
public boolean setNX(final Object key, final Object value) throws DataAccessException {
boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
return connection.setNX(getKeyBytes(key), getValueBytes(value));
}
});
return result;
}

/**
* 添加缓存数据，设定缓存失效时间
*
* @param key
* @param value
* @param expireSeconds 过期时间，单位 秒
* @throws DataAccessException
*/
public void setEx(final Object key, final Object value, final long expireSeconds) throws DataAccessException {
redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
connection.setEx(getKeyBytes(key), expireSeconds, getValueBytes(value));
return true;
}
});
}

/**
* 添加缓存数据，设定默认缓存失效时间
*
* @param key
* @param value
* @throws DataAccessException
*/
public void setEx(Object key, Object value) throws DataAccessException {
setEx(key, value, expireTime);
}

/**
* 获取key对应value
*
* @param key
* @return
* @throws DataAccessException
*/
public <T> T get(final Object key) throws DataAccessException {
byte[] result = redisTemplate.execute(new RedisCallback<byte[]>() {
@Override
public byte[] doInRedis(RedisConnection connection) throws DataAccessException {
return connection.get(getKeyBytes(key));
}
});
if (result == null) {
return null;
}
return deserializeValue(result);
}

public boolean hSet(final Object key, final Object field, final Object value) {
boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
return connection.hSet(getKeyBytes(key), getHashKeyBytes(field), getHashValueBytes(value));
}
});
return result;
}

public <T> T hGet(final Object key, final Object field) throws DataAccessException {
byte[] result = redisTemplate.execute(new RedisCallback<byte[]>() {
@Override
public byte[] doInRedis(RedisConnection connection) throws DataAccessException {
return connection.hGet(getKeyBytes(key), getHashKeyBytes(field));
}
});
if (result == null) {
return null;
}
return deserializeHashValue(result);
}

/**
* 设置超时时间
*
* @param key
* @param seconds
* @return
*/
public boolean expire(final Object key, final long seconds) {
boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
return connection.expire(getKeyBytes(key), seconds);
}
});

return result;
}

/**
* 删除指定key数据
*
* @param key
* @return 返回操作影响记录数
*/
public long del(final Object key) {
if (key == null) {
return 0l;
}
Long delNum = redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
return connection.del(getKeyBytes(key));
}
});
return delNum;
}

/**
* 用于删除哈希表 key 中的一个或多个指定字段，不存在的字段将被忽略
*
* @param key   哈希表对应的键
* @param filed 哈希表中要删除的键
* @return
*/
public Long hdel(final Object key, final Object... filed) {
if (key == null) {
return 0l;
}
final byte[] keys = getKeyBytes(key);
if (keys == null || keys.length == 0) {
return 0L;
}
Long delNum = redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
List<byte[]> fieldList = new ArrayList<byte[]>();
for (Object f : filed) {
if (f != null) {
byte[] hfs = getHashKeyBytes(f);
if (hfs != null && hfs.length > 0) {
fieldList.add(hfs);
}
}
}

if (fieldList.size() == 0) {
return 0L;
}

byte[][] bytes = new byte[0][];
return connection.hDel(keys, fieldList.toArray(bytes));
}
});
return delNum;
}

public Set<byte[]> keys(final Object key) {
if (key == null) {
return null;
}
Set<byte[]> bytesSet = redisTemplate.execute(new RedisCallback<Set<byte[]>>() {
@Override
public Set<byte[]> doInRedis(RedisConnection connection) throws DataAccessException {
return connection.keys(getKeyBytes(key));
}
});

return bytesSet;
}

public void flushDb() {
redisTemplate.execute(new RedisCallback<Void>() {
@Override
public Void doInRedis(RedisConnection redisConnection) throws DataAccessException {
redisConnection.flushDb();
return null;
}
});
}

/**
* size
*/
public Long dbSize() {
Long dbSize = redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
return redisConnection.dbSize();
}
});
return dbSize;
}
}