1. 分别序列化 elements ,然后 set 存储
2.序列化List对象，set存储
这两种方法都类似MC的 Object方法存储，运用这种方式意味着放弃Redis对List提供的 *** 作方法。
import net.spy.memcached.compat.CloseUtil
import net.spy.memcached.compat.log.Logger
import net.spy.memcached.compat.log.LoggerFactory
import redis.clients.jedis.Client
import redis.clients.jedis.Jedis
import redis.clients.jedis.JedisPool
import redis.clients.jedis.JedisPoolConfig
import java.io.*
import java.util.ArrayList
import java.util.List
import java.util.Random
/**
* Created by IntelliJ IDEA.
* User: lifeng.xu
* Date: 12-6-11
* Time: 上午11:10
* To change this template use File | Settings | File Templates.
*/
public class JedisTest {
private static Logger logger = LoggerFactory.getLogger(JedisTest.class)
/**
* Jedis Pool for Jedis Resource
* @return
*/
public static JedisPool buildJedisPool(){
JedisPoolConfig config = new JedisPoolConfig()
config.setMaxActive(1)
config.setMinIdle(50)
config.setMaxIdle(3000)
config.setMaxWait(5000)
JedisPool jedisPool = new JedisPool(config,
"*****", ****)
return jedisPool
}
/**
* Test Data
* @return
*/
public static List<User>buildTestData(){
User a = new User()
a.setName("a")
User b = new User()
b.setName("b")
List<User>list = new ArrayList<User>()
list.add(a)
list.add(b)
return list
}
/**
* Test for
*/
public static void testSetElements(){
List<User>testData = buildTestData()
Jedis jedis = buildJedisPool().getResource()
String key = "testSetElements" + new Random(1000).nextInt()
jedis.set(key.getBytes(), ObjectsTranscoder.serialize(testData))
//验证
byte[] in = jedis.get(key.getBytes())
List<User>list = ObjectsTranscoder.deserialize(in)
for(User user : list){
System.out.println("testSetElements user name is:" + user.getName())
}
}
public static void testSetEnsemble(){
List<User>testData = buildTestData()
Jedis jedis = buildJedisPool().getResource()
String key = "testSetEnsemble" + new Random(1000).nextInt()
jedis.set(key.getBytes(), ListTranscoder.serialize(testData))
//验证
byte[] in = jedis.get(key.getBytes())
List<User>list = (List<User>)ListTranscoder.deserialize(in)
for(User user : list){
System.out.println("testSetEnsemble user name is:" + user.getName())
}
}
public static void main(String[] args) {
testSetElements()
testSetEnsemble()
}
public static void close(Closeable closeable) {
if (closeable != null) {
try {
closeable.close()
} catch (Exception e) {
logger.info("Unable to close %s", closeable, e)
}
}
}
static class User implements Serializable{
String name
public String getName() {
return name
}
public void setName(String name) {
this.name = name
}
}
static class ObjectsTranscoder{
public static byte[] serialize(List<User>value) {
if (value == null) {
throw new NullPointerException("Can't serialize null")
}
byte[] rv=null
ByteArrayOutputStream bos = null
ObjectOutputStream os = null
try {
bos = new ByteArrayOutputStream()
os = new ObjectOutputStream(bos)
for(User user : value){
os.writeObject(user)
}
os.writeObject(null)
os.close()
bos.close()
rv = bos.toByteArray()
} catch (IOException e) {
throw new IllegalArgumentException("Non-serializable object", e)
} finally {
close(os)
close(bos)
}
return rv
}
public static List<User>deserialize(byte[] in) {
List<User>list = new ArrayList<User>()
ByteArrayInputStream bis = null
ObjectInputStream is = null
try {
if(in != null) {
bis=new ByteArrayInputStream(in)
is=new ObjectInputStream(bis)
while (true) {
User user = (User) is.readObject()
if(user == null){
break
}else{
list.add(user)
}
}
is.close()
bis.close()
}
} catch (IOException e) {
logger.warn("Caught IOException decoding %d bytes of data",
in == null ? 0 : in.length, e)
} catch (ClassNotFoundException e) {
logger.warn("Caught CNFE decoding %d bytes of data",
in == null ? 0 : in.length, e)
} finally {
CloseUtil.close(is)
CloseUtil.close(bis)
}
return list
}
}
static class ListTranscoder{
public static byte[] serialize(Object value) {
if (value == null) {
throw new NullPointerException("Can't serialize null")
}
byte[] rv=null
ByteArrayOutputStream bos = null
ObjectOutputStream os = null
try {
bos = new ByteArrayOutputStream()
os = new ObjectOutputStream(bos)
os.writeObject(value)
os.close()
bos.close()
rv = bos.toByteArray()
} catch (IOException e) {
throw new IllegalArgumentException("Non-serializable object", e)
} finally {
close(os)
close(bos)
}
return rv
}
public static Object deserialize(byte[] in) {
Object rv=null
ByteArrayInputStream bis = null
ObjectInputStream is = null
try {
if(in != null) {
bis=new ByteArrayInputStream(in)
is=new ObjectInputStream(bis)
rv=is.readObject()
is.close()
bis.close()
}
} catch (IOException e) {
logger.warn("Caught IOException decoding %d bytes of data",
in == null ? 0 : in.length, e)
} catch (ClassNotFoundException e) {
logger.warn("Caught CNFE decoding %d bytes of data",
in == null ? 0 : in.length, e)
} finally {
CloseUtil.close(is)
CloseUtil.close(bis)
}
return rv
}
}
}
package com.chen.utils
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.stereotype.Component
import org.springframework.util.CollectionUtils
import java.util.Collection
import java.util.List
import java.util.Map
import java.util.Set
import java.util.concurrent.TimeUnit
@Component
public final class RedisUtil {
@Autowired
private RedisTemplate redisTemplate
/*
@param key 键
@param time 时间（秒）
@return
*/
public boolean expire(String key,long time){
try {
if (time >0){
redisTemplate.expire(key,time, TimeUnit.SECONDS)
}
return true
}catch (Exception e){
return false
}
}
/*
根据key 获取过期时间
@param key 键 不能为null
@return 时间（秒）返回0代表永久有效
*/
public long getExpire(String key){
return redisTemplate.getExpire(key,TimeUnit.SECONDS)
}
/*
判断key 是否存在
@param key 键
@return ture 存在 false不存在
*/
public boolean hasKey(String key){
try {
return redisTemplate.hasKey(key)
}catch (Exception e){
return false
}
}
/*
删除缓存
@param key 可以传一个值或者多个值
*/
@SuppressWarnings("unchecked")
public void del(String... key){
if (key != null &&key.length >0){
if (key.length == 1){
redisTemplate.delete(key[0])
}else {
redisTemplate.delete((Collection ) CollectionUtils.arrayToList(key))
}
}
}
//=========================String==================================
/*
普通缓存获取
@param key 键
@return 值
*/
public Object get(String key){
return key == null ? null : redisTemplate.opsForValue().get(key)
}
/*
普通缓存放入
@param key 键
@param value 值
@return turn 成功 false 失败
*/
public boolean set(String key,Object value){
try {
redisTemplate.opsForValue().set(key,value)
return true
}catch (Exception e){
return false
}
}
/*
普通缓存放入并设置时间
@param key 键
@param value 值
@param time 时间（秒） time要大于0 如果time小于0，将设置成无限制
@return turn 成功 false 失败
*/
public boolean set(String key,Object value,long time){
try {
if (time >0){
redisTemplate.opsForValue().set(key,value,time,TimeUnit.SECONDS)
}else {
redisTemplate.opsForValue().set(key,value)
}
return true
}catch (Exception e){
return false
}
}
/*
递增
@param key 键
@param delta 值 要增加几（大于0）
@return
*/
public long incr(String key,long delta){
if (delta <0){
throw new RuntimeException("递增因子必须大于0")
}
return redisTemplate.opsForValue().increment(key,delta)
}
/*
递减
@param key 键
@param delta 值 要减少几（大于0）
@return
*/
public long decr(String key,long delta){
if (delta <0){
throw new RuntimeException("递减因子必须大于0")
}
return redisTemplate.opsForValue().decrement(key,delta)
}
// ================================Map=================================
/**
* HashGet
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item)
}
/**
* 获取hashKey对应的所有键值
* @param key 键
* @return 对应的多个键值
*/
public Map hmget(String key) {
return redisTemplate.opsForHash().entries(key)
}
/**
* HashSet
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public boolean hmset(String key, Map map) {
try {
redisTemplate.opsForHash().putAll(key, map)
return true
} catch (Exception e) {
e.printStackTrace()
return false
}
}
/**
* HashSet 并设置时间
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hmset(String key, Map map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map)
if (time >0) {
expire(key, time)
}
return true
} catch (Exception e) {
e.printStackTrace()
return false
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value)
return true
} catch (Exception e) {
e.printStackTrace()
return false
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value)
if (time >0) {
expire(key, time)
}
return true
} catch (Exception e) {
e.printStackTrace()
return false
}
}
/**
* 删除hash表中的值
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item)
}
/**
* 判断hash表中是否有该项的值
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item)
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by)
}
/**
* hash递减
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by)
}
// ============================set=============================
/**
* 根据key获取Set中的所有值
* @param key 键
* @return
*/
public Set sGet(String key) {
try {
return redisTemplate.opsForSet().members(key)
} catch (Exception e) {
e.printStackTrace()
return null
}
}
/**
* 根据value从一个set中查询,是否存在
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value)
} catch (Exception e) {
e.printStackTrace()
return false
}
}
/**
* 将数据放入set缓存
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values)
} catch (Exception e) {
e.printStackTrace()
return 0
}
}
/**
* 将set数据放入缓存
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key, long time, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values)
if (time >0)
expire(key, time)
return count
} catch (Exception e) {
e.printStackTrace()
return 0
}
}
/**
* 获取set缓存的长度
* @param key 键
* @return
*/
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key)
} catch (Exception e) {
e.printStackTrace()
return 0
}
}
/**
* 移除值为value的
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values)
return count
} catch (Exception e) {
e.printStackTrace()
return 0
}
}
// ===============================list=================================
/**
* 获取list缓存的内容
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end)
} catch (Exception e) {
e.printStackTrace()
return null
}
}
/**
* 获取list缓存的长度
* @param key 键
* @return
*/
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key)
} catch (Exception e) {
e.printStackTrace()
return 0
}
}
/**
* 通过索引 获取list中的值
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
* @return
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index)
} catch (Exception e) {
e.printStackTrace()
return null
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value)
return true
} catch (Exception e) {
e.printStackTrace()
return false
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value)
if (time >0)
expire(key, time)
return true
} catch (Exception e) {
e.printStackTrace()
return false
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List value) {
try {
redisTemplate.opsForList().rightPushAll(key, value)
return true
} catch (Exception e) {
e.printStackTrace()
return false
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, List value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value)
if (time >0)
expire(key, time)
return true
} catch (Exception e) {
e.printStackTrace()
return false
}
}
/**
* 根据索引修改list中的某条数据
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value)
return true
} catch (Exception e) {
e.printStackTrace()
return false
}
}
/**
* 移除N个值为value
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key, long count, Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value)
return remove
} catch (Exception e) {
e.printStackTrace()
return 0
}
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）