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  命令   ：

　　　　1 list

llen keyList :获取keyList的长度大小
lpop keyList:取出并移除keyList第一个元素，左边的元素
rpop keyList:取出并移除keyList最后一个元素，右边的元素
LINDEX key index:获取该索引下的元素。
lrem key count value:删除count个value。（count为正数,从头开始，删除count个value元素；count为负，则从尾部向头删除|count|个value元素；count为0，则所有的元素为value的都删除）
LSET key index value:设置索引为index下的元素为value.超出索引范围报错。
LTRIM key start end:清空索引在start 和end之外的元素，索引从0开始，两端保留，两端之外的清空。
RPOPLPUSH srckey dstkey:源队列srckey，目标队列dstkey，将srckey的最后一个移除，并放到dstkey的第一个。

　　　　2 set　

sadd key value : 向set添加元素
srem key value ：从set中移除元素
smembers key : 取出所有set元素
SISMEMBER key value: 查看value是否存在set中
SUNION key1 key2 ... keyN:将所有key合并后取出来，相同的值只取一次
scard key : 获取set中元素的个数
SRANDMEMBER key: Return a random element from a Set, without removing the element.随机取出一个
SDIFF key1 key2 ... keyN：获取第一set中不存在后面几个set里的元素。
SDIFFSTORE dstkey key1 key2 ... keyN：和sdiff相同，获取key1中不存在其他key里的元素，但要存储到dstkey中。
SINTER key1 key2 ... keyN:取出这些set的交集
SINTERSTORE dstkey key1 key2 ... keyN：取出这些key的交集并存储到dstkey
SMOVE srckey dstkey member：将元素member从srckey中转移到dstkey中，这个操作是原子的。　

　　

Redis整合Spring 单击版

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
	<!-- 整合单机版redis -->
	<!-- 创建jedisPoolConfig配置对象 -->
	<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<property name="maxTotal" value="20"></property>
		<property name="maxIdle" value="2"></property>
	</bean>
	<!-- 创建jedisPool连接单机版redis -->
	<bean id="jedisPool" class="redis.clients.jedis.JedisPool">
		<constructor-arg name="poolConfig" ref="poolConfig"></constructor-arg>
		<constructor-arg name="host" value="127.0.0.1"></constructor-arg>
		<constructor-arg name="port" value="6379"></constructor-arg>
	</bean>
</beans>

　　

　在远程服务上执行命令  $ redis-cli -h host -p port -a password

　　　　

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());

 

使用fastjson将对象转为json字符串后存储

public class RedisOps {
    public static void setJsonString(String key,Object object){
        Jedis jedis = RedisConnection.getJedis();
        jedis.set(key, JSON.toJSONString(object));
        jedis.close();
    }
    public static Object getJsonObject(String key,Class clazz){
        Jedis jedis = RedisConnection.getJedis();
        String value = jedis.get(key);
        jedis.close();
        return JSON.parseObject(value,clazz);
    }
}

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通常在业务层处理缓存  实例代码如下：

 public JSONObject selectByExample(Long id){
		User user=new User();
		//user=userMapper.selectByPrimaryKey(id);
		String us=RedisUtil.getRedis().get("user");
		 Map<String, String> hash=new HashMap<String, String>();
		// hash= (Map<String, String>)JSON.parse("dd");
		System.out.println(us);
		if(us!=null){
			return JSON.parseObject(us);
		}
		else{
			user=userMapper.selectByPrimaryKey(id);
			String userString=JSON.toJSONString(user);
			RedisUtil.getRedis().set("user", userString);
			
		    return JSON.parseObject(userString);
		}
}