redis
Posted 温一壶月光当茶饮
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了redis相关的知识，希望对你有一定的参考价值。
Redis
1 redis介绍： redis是开源的 key-value形式存储数据，C语言编写的框架
特点 ： 1 高性能：提供多种语言的API set效率 11万次/秒 get效率8.1万次/秒
2 数据完全存放在内存中，支持数据持久化
3 value 可以是字符串，hash(map) 列表list 集合(set) 有序集合(sorted set)
2 适用场景 《1》缓存 《2》消息队列
3 命令
Redis 操作对象：（要求对象必须要序列化）
1 创建对象序列化工具：
/**
* 序列化就是将一个对象转换为二进制的数据流。这样就可以进行传输，或者保存到文件中。如果一个类的对象要想实现序列化，就必须实现serializable接口。在此接口中没有任何的方法，此接口只是作为一个标识，表示本类的对象具备了序列化的能力而已。
* 反序列化:将二进制数据流转换成相应的对象。
* 如果想要完成对象的序列化，则还要依靠ObjectOutputStream和ObjectInputStream,前者属于序列化操作，而后者属于反序列化操作。
*
*/
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class SerializationUtil {
/**
* 序列化
*
* @param object
* @return
*/
public static byte[] serialize(Object object) {
ObjectOutputStream oos = null;
ByteArrayOutputStream baos = null;
try {
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(object);
byte[] bytes = baos.toByteArray();
return bytes;
} catch (Exception e) {
}
return null;
}
/**
* 反序列化
*
* @param bytes
* @return
*/
public static Object deserialize(byte[] bytes) {
ByteArrayInputStream bais = null;
try {
bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
} catch (Exception e) {
}
return null;
}
}
测试：
// 存入一个 user对象
jedis.set("user".getBytes(), SerializationUtil.serialize(user));
// 获取
byte[] bs = jedis.get("user".getBytes());
User desUser = (User) SerializationUtil.deserialize(bs);
System.out.println(desUser.getId() + ":" + desUser.getName());
2 List<User> userList （对象集合）在缓存中的存储和获取。
将List<User> userList转成字节数组 方便加入缓存中
private static byte[] cacheUserList(List<User> userList) {
if (userList.isEmpty()) {
throw new NullPointerException("Can‘t serialize null");
}
byte[] value = null;
ByteArrayOutputStream bos = null;
ObjectOutputStream os = null;
try {
bos = new ByteArrayOutputStream();
os = new ObjectOutputStream(bos);
for (User user : userList) {
os.writeObject(user);
}
os.writeObject(null);
bos.close();
os.close();
value = bos.toByteArray();
} catch (Exception e) {
throw new IllegalArgumentException("Non-serializable object", e);
}
return value;
}
将字节数组转成相应的list<User>
private static List<User> getUserCache(byte[] in) {
List<User> userList = new ArrayList<User>();
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
try {
if (in != null) {
bis = new ByteArrayInputStream(in);
ois = new ObjectInputStream(bis);
while (true) {
User user = (User) ois.readObject();
if (user == null) {
break;
} else {
userList.add(user);
}
}
}
bis.close();
ois.close();
} catch (Exception e) {
e.printStackTrace();
}
return userList;
}
测试：
//将userList加入缓存
redis.set("Key".getBytes(), cacheUserList(userList));
//获取缓存中userList数据
byte[] in = jedis.get("Key".getBytes());
List<User> userArr = getUserCache(in);
3 RedisUtil工具类
package com.utils;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class RedisUtil {
/*构造函数私有化 防止别人new*/
private RedisUtil(){};
private static String host="localhost";
private static int port=6379;
private static int timeout=10000;
private static JedisPool jedis=null;
private static JedisPoolConfig jedisPoolConfig=null;
/*连接池中创建连接*/
static{
jedisPoolConfig=new JedisPoolConfig();
/*最大连接数*/
jedisPoolConfig.setMaxTotal(1024);
/*最大空闲实例数*/
jedisPoolConfig.setMaxIdle(200);
/*等待连接池给链接的最大时间 毫秒*/
jedisPoolConfig.setMaxWaitMillis(10000);
/*在borrow一个jedis实例时，是否提前进行alidate操作；如果为true，则得到的jedis实例均是可用的；*/
jedisPoolConfig.setTestOnBorrow(true);
jedis=new JedisPool(jedisPoolConfig, host, port, timeout);
}
public synchronized static Jedis getRedis(){
if(jedis!=null){
return jedis.getResource();
}
else{
return new JedisPool(jedisPoolConfig, host, port, timeout).getResource();
}
}
public static void closeRedis(final Jedis jedis){
if(jedis!=null){
jedis.close();
}
}
// 存对象
public static void setObject(Jedis jedis, String key, Object obj) throws Exception {
ObjectOutputStream oos = null; //对象输出流
ByteArrayOutputStream bos = null; //内存缓冲流
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(obj);
byte[] byt = bos.toByteArray();
jedis.set(key.getBytes(), byt);
bos.close();
oos.close();
}
// 取对象
public static Object getObject(Jedis jedis, String key) throws Exception {
byte[] byt = jedis.get(key.getBytes());
ObjectInputStream ois = null; //对象输入流
ByteArrayInputStream bis = null; //内存缓冲流
Object obj = null;
bis = new ByteArrayInputStream(byt);
ois = new ObjectInputStream(bis);
obj = ois.readObject();
bis.close();
ois.close();
return obj;
}
}
4 在创建的RedisUtil工具类中添加方法
// 存对象
public static void setObject(Jedis jedis, String key, Object obj) throws Exception {
ObjectOutputStream oos = null; //对象输出流
ByteArrayOutputStream bos = null; //内存缓冲流
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(obj);
byte[] byt = bos.toByteArray();
jedis.set(key.getBytes(), byt);
bos.close();
oos.close();
}
// 取对象
public static Object getObject(Jedis jedis, String key) throws Exception {
byte[] byt = jedis.get(key.getBytes());
ObjectInputStream ois = null; //对象输入流
ByteArrayInputStream bis = null; //内存缓冲流
Object obj = null;
bis = new ByteArrayInputStream(byt);
ois = new ObjectInputStream(bis);
obj = ois.readObject();
bis.close();
ois.close();
return obj;
}
测试：
RedisUtil.setObject(RedisUtil.getRedis(), "ddd", user);
User ui=(User) RedisUtil.getObject(RedisUtil.getRedis(), "ddd");
redis的map,list set，string的用法
/**
* 操作普通键值对
*/
@Test
public void test01(){
//存入1个key=name value=hello的键值对
jedis.set("name", "hello");
String value = jedis.get("name"); //获取key=name的值
System.out.println(value);
jedis.del("name");
value = jedis.get("name"); //获取key=name的值
System.out.println(value);
}
/**
* 操作List
*/
@Test
public void test02(){
//将zhoufeng 加入students数组的开头,如果该元素是第一个元素，那么会自动创建students数组
jedis.rpush("students", "first");
//将zhangsan加入到students的末尾
jedis.lpush("students", "end");
//移除students的第一个元素
jedis.lpop("students");
//移除students的最后一个元素
jedis.rpop("students");
//移除制定的元素,第二个参数表示要移除的个数，因为list中是允许出现重复元素的
jedis.lrem("student", 1, "first") ;
//获取students数组的所有元素
List <String> students = jedis.lrange("students", 0, -1) ;
System.out.println(students);
}
/**
* 操作Set
*/
@Test
public void test03(){
//添加元素
jedis.sadd("teachers", "zhangsan");
jedis.sadd("teachers", "lisi","hello");
jedis.sadd("teachers", "wangwu");
//判断Set是否包含制定元素
Boolean b1 = jedis.sismember("teachers", "wangwu");
Boolean b2 = jedis.sismember("teachers", "xxxxx");
System.out.println(b1 + " " + b2);
//获取Set内所有的元素
Set<String> members = jedis.smembers("teachers");
Iterator<String> it = members.iterator() ;
while(it.hasNext()){
System.out.println(it.next());
}
// jedis.sunion(keys...) 可以将多个Set合并成1个并返回合并后的Set
}
/**
* 操作带排序功能的Set
*/
@Test
public void test04(){
//添加元素，会根据第二个参数排序
jedis.zadd("emps", 5 , "aaa") ;
jedis.zadd("emps", 1 , "bbbb") ;
jedis.zadd("emps", 3 , "ccc") ;
jedis.zadd("emps", 2 , "ddd") ;
//获取所有元素
Set<String> emps = jedis.zrange("emps", 0, -1) ;
Iterator<String> it = emps.iterator() ;
while(it.hasNext()){
System.out.println(it.next());
}
}
/**
* 存入对象,使用Map作为对象
*/
@Test
public void test05(){
Map<String , String > car = new HashMap<String , String >() ;
car.put("COLOR", "red") ;
car.put("SIZE", "2T");
car.put("NO", "8888");
jedis.hmset("car", car);
//获取整个对象
Map<String, String> result = jedis.hgetAll("car");
Iterator<Entry<String, String>> it = result.entrySet().iterator();
while(it.hasNext()){
Entry<String, String> entry = it.next() ;
System.out.println("key:" + entry.getKey() + " value:" + entry.getValue());
}
//也可以获取制定的属性
String no = jedis.hget("car", "NO") ;
System.out.println("NO:" + no);
}
以上是关于redis的主要内容，如果未能解决你的问题，请参考以下文章