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的主要内容,如果未能解决你的问题,请参考以下文章

redis存储session配制方法

Redis实现分布式锁(设计模式应用实战)

Redis实现分布式锁(设计模式应用实战)

Redis缓存:java语言注释符号,附超全教程文档

spring boot 整合 redis

Redis 学习 —— 数据类型及操作