Redis部分数据结构方法小结

package com.practice.util;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;


public class RedisUtil {
	private static final Log log = LogFactory.getLog(RedisUtil.class); 

    private static JedisPool jedisPool;//非切片连接池
    
    private static final Object lock = new Object();
    
    private static final int DEFAULT_TIME_OUT = 30000;
    
    private static String redisIp = "192.168.77.153";
    
    private static Integer redisPort = 7000;
    
    /**
	 * 构建redis切片连接池
	 * 
	 * @param ip
	 * @param port
	 * @return JedisPool
	 */
    public static JedisPool getJedisPool() {
        if (jedisPool == null) {
            synchronized (lock) {
            	if (jedisPool == null) {
                    JedisPoolConfig config = new JedisPoolConfig();
                    //设置连接池初始化大小和最大容量
                    
                    // 控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；
                    // 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
                    config.setMaxTotal(-1);
                    
                    // 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
                    config.setMaxIdle(1000);
                    // 表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；
                    config.setMaxWaitMillis(1000 * 30);
                    // 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
                    config.setTestOnBorrow(true);
                    // 写
                    jedisPool = new JedisPool(config, redisIp, redisPort,DEFAULT_TIME_OUT);
                    
                }
            }
        }
        return jedisPool;
    }
    
    /**
     * 返还到连接池
     * 
     * @param pool 
     * @param redis
     */
    public static void returnJedisResource(Jedis redis) {
        if (redis != null) {
            redis.close();
        }
    }
    
    //直接set key-value
    public static void setStructure(String key,String value){
    	JedisPool pool = null;
        Jedis jedis = null;
        try {
            pool = getJedisPool();
            jedis = pool.getResource();
            jedis.set(key, value);
        } catch (Exception e) {
            log.error(e);
        } finally {
            //返还到连接池
        	  returnJedisResource(jedis);
        }
    }
    
    public static void getSetStructure(String key){
    	JedisPool pool = null;
        Jedis jedis = null;
        String value = "";
        try {
            pool = getJedisPool();
            jedis = pool.getResource();
            value = jedis.get(key);
            System.out.println(value);
        } catch (Exception e) {
            log.error(e);
        } finally {
            //返还到连接池
        	  returnJedisResource(jedis);
        }
    }
    
    //通过key删除数据
    public static void delKey(String key){
    	JedisPool pool = null;
        Jedis jedis = null;
        try {
            pool = getJedisPool();
            jedis = pool.getResource();
            jedis.del(key);
            System.out.println("del key success");
        } catch (Exception e) {
            log.error(e);
        } finally {
            //返还到连接池
        	  returnJedisResource(jedis);
        }
    }
    
    //mset相当于 jedis.set("key1","value1");jedis.set("key2","value2")
    public static void msetData(String key1,String value1,String key2,String value2){
    	JedisPool pool = null;
        Jedis jedis = null;
        try {
            pool = getJedisPool();
            jedis = pool.getResource();
            jedis.mset(key1,value1,key2,value2);
        } catch (Exception e) {
            log.error(e);
        } finally {
            //返还到连接池
        	  returnJedisResource(jedis);
        }
    }
    
    public static void flushData(){
    	JedisPool pool = null;
        Jedis jedis = null;
        try {
            pool = getJedisPool();
            jedis = pool.getResource();
            jedis.flushAll();
            System.out.println("flushAll success");
        } catch (Exception e) {
            log.error(e);
        } finally {
            //返还到连接池
        	  returnJedisResource(jedis);
        }
    }
    
    //判断key是否存在，如果存在则返回1，否则则返回0 
    public static boolean booleanExsit(String key){
    	JedisPool pool = null;
        Jedis jedis = null;
        Boolean exsit = false;
        try {
            pool = getJedisPool();
            jedis = pool.getResource();
            exsit =  jedis.exists(key);
        } catch (Exception e) {
            log.error(e);
        } finally {
            //返还到连接池
        	  returnJedisResource(jedis);
        }
		return exsit;
    }
    
    public static void appendData(String key,String data){
    	JedisPool pool = null;
        Jedis jedis = null;
        try {
            pool = getJedisPool();
            jedis = pool.getResource();
            jedis.append(key, data);
        } catch (Exception e) {
            log.error(e);
        } finally {
            //返还到连接池
        	  returnJedisResource(jedis);
        }
    }
    
    //截取value的值
    public static void getRange(String key){
    	JedisPool pool = null;
        Jedis jedis = null;
        try {
            pool = getJedisPool();
            jedis = pool.getResource();
            String value = jedis.getrange(key, 0, 1);
            System.out.println(value);
            System.out.println();
        } catch (Exception e) {
            log.error(e);
        } finally {
            //返还到连接池
        	  returnJedisResource(jedis);
        }
    }
    
    //列表操作 用于将一个或多个值插入到列表的尾部(最右边), 如果列表不存在，一个空列表会被创建并执行 RPUSH 操作。 当列表存在但不是列表类型时，返回一个错误。
    public static void rpush(String key){
    	JedisPool pool = null;
        Jedis jedis = null;
        try {
            pool = getJedisPool();
            jedis = pool.getResource();
            jedis.rpush(key, "Hello how are you?");  
            jedis.rpush(key, "Fine thanks. I'm having fun with redis.");  
            jedis.rpush(key, "I should look into this NOSQL thing ASAP");         
            } catch (Exception e) {
            log.error(e);
        } finally {
            //返还到连接池
        	  returnJedisResource(jedis);
        }
    }
    
    //取出列表中相应位置的值
    public static void getPushValue(String key){
    	JedisPool pool = null;
        Jedis jedis = null;
        try {
            pool = getJedisPool();
            jedis = pool.getResource();
            //第一个是key，第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有  
            List<String> values = jedis.lrange(key, 0, -1);
            System.out.println(values);
            } catch (Exception e) {
            log.error(e);
        } finally {
            //返还到连接池
        	  returnJedisResource(jedis);
        }
    }
    
    public static void Set(String key){
    	JedisPool pool = null;
        Jedis jedis = null;
        try {
            pool = getJedisPool();
            jedis = pool.getResource();
            jedis.sadd("myset", "1");  
            jedis.sadd("myset", "2");  
            jedis.sadd("myset", "3");  
            jedis.sadd("myset", "4");  
            Set<String> setValues = jedis.smembers("myset"); 
            System.out.println(setValues);
        } catch (Exception e) {
            log.error(e);
        } finally {
            //返还到连接池
        	  returnJedisResource(jedis);
        }
    }
    
    public static void srem(String key){
    	JedisPool pool = null;
        Jedis jedis = null;
        try {
            pool = getJedisPool();
            jedis = pool.getResource();
            jedis.srem(key, "4");
            Set<String> setValues = jedis.smembers("myset"); 
            System.out.println(setValues);
        } catch (Exception e) {
            log.error(e);
        } finally {
            //返还到连接池
        	  returnJedisResource(jedis);
        }
    }
    
    public static void hmset(){
    	JedisPool pool = null;
        Jedis jedis = null;
        try {
            pool = getJedisPool();
            jedis = pool.getResource();
            Map<String, String> pairs = new HashMap<String, String>(); 
            pairs.put("name", "Akshi");  
            pairs.put("age", "2");  
            pairs.put("sex", "Female");  
            jedis.hmset("kid", pairs);  
            List<String> name = jedis.hmget("kid", "name");
            System.out.println(name);
        } catch (Exception e) {
            log.error(e);
        } finally {
            //返还到连接池
        	  returnJedisResource(jedis);
        }
    }
    
    public static void increment(){
    	JedisPool pool = null;
        Jedis jedis = null;
        try {
            pool = getJedisPool();
            jedis = pool.getResource();
            jedis.hset("hashs", "entryKey", "1");  
            jedis.hset("hashs", "entryKey1", "entryValue1");  
            jedis.hset("hashs", "entryKey2", "entryValue2");  
            // 判断某个值是否存在 
            jedis.hexists("hashs", "entryKey");
            System.out.println(jedis.hincrBy("hashs", "entryKey", 1));  
        } catch (Exception e) {
            log.error(e);
        } finally {
            //返还到连接池
        	  returnJedisResource(jedis);
        }
    }

　　

Redis在工程开发中还是比较常用的Nosql内存数据库，简单巩固一下它的各种数据类型与用法~