Redis入门教程（三）— Java中操做Redis

在Redis的官网上，咱们能够看到Redis的Java客户端众多

其中，Jedis是Redis官方推荐，也是使用用户最多的Java客户端。

开始前的准备

• 使用jedis使用到的jedis-2.1.0.jar，点击下载
• 若是使用Redis链接池的话，须要commons-pool-1.5.4.jar，点击下载
• 若是你缺乏junit的jar包，点击下载

建立项目

1. 首先建立一个新的Java Project，命名为Jedis(你也能够给它你喜好的名字)
2. 在项目中新建一个Folder(文件夹)，命名为“lib”
3. 将jedis-2.1.0.jar、commons-pool-1.5.4.jar、junit-4.10.jar复制到lib文件夹下
4. 选中文件夹或者三个jar文件，右击找到Build Path，选择菜单下的Add to Build Path加入到Build Path中

开始撸代码

继续以前，请务必阅读过Redis入门教程（二）—基本数据类型，这将对你有很大的帮助。

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

import org.junit.Before;
import org.junit.Test;

import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.Jedis;

/**
 * @author dotleo
 *
 */
public class Jedis_Test {
    
    //Java中操做Redis的对象
    private Jedis jedis ;
    
    @Before
    public void connection() {
        
        //链接Redis服务器，参数1为ip，参数2为端口号，请根据本身实际状况赋值
        jedis = new Jedis("192.168.1.233",6379);
    }
    
    /**
     * redis字符串操做
     */
    @Test
    public void stringTest() {
        
        //为避免屡次运行Redis中存在键，致使结果不符合预期，每次执行时清理当前库
        //特别注意：在开发中请勿如此操做
        jedis.flushDB();
        
        //添加字符串
        jedis.set("age", "101");
        System.out.println("age = " + jedis.get("age"));
        //批量添加字符串
        jedis.mset("age1","1","age2","2");
        System.out.println("age1 = " + jedis.get("age1"));
        System.out.println("age2 = " + jedis.get("age2"));
        //添加字符串（仅在不存在时）
        jedis.setnx("price", "101");
        System.out.println("price = " + jedis.get("price"));
        //加1操做
        jedis.incr("price");
        System.out.println("price = " + jedis.get("price"));
        //拼接字符串
        jedis.append("age", "years");
        System.out.println("age = " + jedis.get("age"));
        //截取字符串
        String str = jedis.getrange("age", 0L, 5L);
        System.out.println("age[0,5] = " + str);
        //获取字符串长度
        Long len = jedis.strlen("age");
        System.out.println("age length = " + len);
        //删除字符串
        jedis.del("age");
        System.out.print("age = " + jedis.get("age"));
    }
    
    /**
     * redis哈希操做
     */
    @Test
    public void hashTest() {
        
        //为避免屡次运行Redis中存在键，致使结果不符合预期，每次执行时清理当前库
        //特别注意：在开发中请勿如此操做
        jedis.flushDB();
        
        //添加值
        jedis.hset("student", "name", "zhangsan");
        //添加值（仅在不存在时）
        jedis.hsetnx("student", "age", "12");
        //批量添加值
        Map<String,String> map = new HashMap<String,String>();
        map.put("sex", "boy");
        map.put("address", "beijing");
        jedis.hmset("student", map);
        //获取值
        String str = jedis.hget("student", "name");
        System.out.println("student:name = " + str);
        //批量获取值
        List<String> list = jedis.hmget("student", "name","age");
        System.out.println("student:name = " + list.get(0));
        System.out.println("student:age = " + list.get(1));
        //获取key
        Set<String> set = jedis.hkeys("student");
        System.out.println("student keys:");
        for (String string : set) {
            System.out.println(string);
        }
        //获取值
        list = jedis.hvals("student");
        System.out.println("student vals:");
        for (String string : list) {
            System.out.println(string);
        }
        //获取key和值
        map = jedis.hgetAll("student");
        System.out.println("student keys vals:");
        for (String key:map.keySet()) {
            System.out.println(key + " = " + map.get(key));
        }
        //删除值
        jedis.hdel("student", "sex");
        System.out.println("student:sex = " + jedis.hget("student", "sex"));
        //获取长度
        Long len = jedis.hlen("student");
        System.out.println("student length = " + len);
    }
    
    /**
     * redis列表操做
     */
    @Test
    public void listTest() {
        
        //为避免屡次运行Redis中存在键，致使结果不符合预期，每次执行时清理当前库
        //特别注意：在开发中请勿如此操做
        jedis.flushDB();
        
        //表头添加
        jedis.lpush("student", "xiaoli","xiaowang","xiaoliu","xiaozhang");
        //表尾添加
        jedis.rpush("student", "zhangsan","lisi","wangwu");
        //经过索引获取元素
        String str = jedis.lindex("student", 1L);
        System.out.println("student 1st = " + str);
        //在元素前或者后插入元素
        jedis.linsert("student", LIST_POSITION.BEFORE, "xiaozhang", "zhangsan");
        //从表头弹出
        str = jedis.lpop("student");
        System.out.println("student first = " + str);
        //从表尾弹出
        str = jedis.rpop("student");
        System.out.println("student end = " + str);
        //删除
        jedis.lrem("student", 2, "zhangsan");
        //获取全部值
        List<String> list = jedis.lrange("student", 0L, -1L);
        System.out.println("student vals:");
        for (String string : list) {
            System.out.println(string);
        }
    }
    
    /**
     * redis集合操做
     */
    @Test
    public void setTest() {

        //为避免屡次运行Redis中存在键，致使结果不符合预期，每次执行时清理当前库
        //特别注意：在开发中请勿如此操做
        jedis.flushDB();
        
        //添加成员
        jedis.sadd("student", "zhangsan","lisi");
        jedis.sadd("monitor","wangwu","zhangsan");
        //获取成员数
        Long count = jedis.scard("student");
        System.out.println("student count = " + count);
        //获取成员
        Set<String> set = jedis.smembers("student");
        System.out.println("student members:");
        for (String string : set) {
            System.out.println(string);
        }
        //是否为该集合的成员
        boolean bool = jedis.sismember("student", "zhangsan");
        System.out.println("member zhangsan exist?\n" + bool);
        //交集
        set = jedis.sinter("student","monitor");
        System.out.println("student inter monitor members:");
        for (String string : set) {
            System.out.println(string);
        }
        //并集
        set = jedis.sunion("student","monitor");
        System.out.println("student union monitor members:");
        for (String string : set) {
            System.out.println(string);
        }
        //补集
        set = jedis.sdiff("student","monitor");
        System.out.println("student diff monitor members:");
        for (String string : set) {
            System.out.println(string);
        }
        //随机返回成员
        String str = jedis.srandmember("student");
        System.out.println("random member:\n" + str);
        //移动成员
        jedis.smove("student", "monitor", "lisi");
        //删除成员
        jedis.srem("monitor", "zhangsan");
        //显示
        set = jedis.smembers("student");
        System.out.println("student members:");
        for (String string : set) {
            System.out.println(string);
        }
        set = jedis.smembers("monitor");
        System.out.println("monitor members:");
        for (String string : set) {
            System.out.println(string);
        }
    }
    
    /**
     * redis有序集合操做
     */
    @Test
    public void sortSetTest() {

        //为避免屡次运行Redis中存在键，致使结果不符合预期，每次执行时清理当前库
        //特别注意：在开发中请勿如此操做
        jedis.flushDB();
        
        //添加成员
        Map<Double,String> map = new HashMap<Double,String>();
        map.put(50d, "zhangsan");
        map.put(60d, "lisi");
        map.put(70d, "wangwu");
        map.put(80d, "zhaoliu");
        map.put(90d, "yangqi");
        map.put(120d, "xiaoming");
        map.put(130d, "xiaozhang");
        map.put(140d, "xiaoli");
        map.put(150d, "xiaoliu");
        jedis.zadd("score", map);
        //更新分数
        jedis.zadd("score", 100d, "zhangsan");
        //获取成员的分数值
        Double dou = jedis.zscore("score", "zhangsan");
        System.out.println("zhangsan score :\n" + dou);
        //按照成员分数小到大返回索引区间的成员
        Set<String> set = jedis.zrange("score", 0, -1);
        System.out.println("score member order:");
        for (String string : set) {
            System.out.println(string);
        }
        //按照成员分数大到小返回索引区间的成员
        set = jedis.zrevrange("score", 0, -1);
        System.out.println("score member reverse:");
        for (String string : set) {
            System.out.println(string);
        }
        //按照成员分数小到大返回分数值区间的成员
        set = jedis.zrangeByScore("score", 50d, 80d);
        System.out.println("score member order:");
        for (String string : set) {
            System.out.println(string);
        }
        //返回有序集合中指定成员的索引
        Long index = jedis.zrank("score", "xiaoliu");
        System.out.println("xiaoliu index is:\n" + index);
    }
}

若是你读过个人Redis入门教程（二）—基本数据类型，你会发现上面这些命令在其中都有说起，只是诸如参数传递的形式、返回值的类型等有少量不一样，但方法名和文中的指令彻底相同，其余方面也大同小异。所以在上面的代码中并无像文章中同样尽量多的列出全部的函数，还需你本身勤于练习、摸索。

Redis链接池

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

/**
 * @author dotleo
 *
 */
public class RedisUtil {

    //Redis服务器ip地址
    private static final String IP_ADDRESS = "192.168.1.233";
    
    //Redis端口号
    private static final int PORT = 6379;
    
    //可用链接实例的最大数目，默认值为8；
    //若是赋值为-1，则表示不限制；若是pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
    private static final int MAX_ACTIVE = 1024;
    
    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    private static final int MAX_IDLE = 200;
    
    //等待可用链接的最大时间，单位毫秒，默认值为-1，表示永不超时。若是超过等待时间，则直接抛出JedisConnectionException；
    private static final int MAX_WAIT = 10000;
    
    //在borrow一个jedis实例时，是否提早进行validate操做；若是为true，则获得的jedis实例均是可用的；  
    private static boolean TEST_ON_BORROW = true;
    
    //Jedis链接池对象
    private static JedisPool jedisPool = null;
    
    
    /**
     * 初始化链接池
     */
    static {
        try {
            JedisPoolConfig conf = new JedisPoolConfig();
            conf.setMaxActive(MAX_ACTIVE);
            conf.setMaxIdle(MAX_IDLE);
            conf.setMaxWait(MAX_WAIT);
            conf.setTestOnBorrow(TEST_ON_BORROW);
            jedisPool = new JedisPool(conf, IP_ADDRESS, PORT);
        } catch(Exception ex) {
            ex.printStackTrace();
        }
    }
    
     /**
     * 获取Jedis实例
     * @return Jedis实例
     */
    public synchronized static Jedis getJedis() {  
         try {  
             if (jedisPool != null) {  
                 Jedis resource = jedisPool.getResource();  
                 return resource;  
             } else {  
                 return null;  
             }  
         } catch (Exception e) {  
             e.printStackTrace();  
             return null;  
         }  
     }
    
    /** 
     * 释放jedis资源 
     * @param jedis Jedis对象 
     */  
     public static void returnResource(final Jedis jedis) {  
         if (jedis != null) {  
              jedisPool.returnResourceObject(jedis);  
         }  
     }  
}