redis学习笔记-java操作String类型

package com.naxsu.redis;

import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.List;

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

import redis.clients.jedis.Jedis;
import redis.clients.jedis.exceptions.JedisDataException;

/**
 * 对String类型进行操作
 * 为了僻免上面的测试的结果影响到当前测试方法，测试之前先把数据库给清空
 */
public class StringValuesCommandsTest{
	Jedis jedis = null;
	
	@Before
	public void before(){
		jedis = new Jedis("192.168.26.128");
		jedis.auth("123456");
		
		jedis.flushDB();
	}
	
	@Test
	public void flushDB() {
		jedis.flushDB();// 清空redis
	}
	
    @Test
    public void setAndGet() {
    	//对key为foo进行赋值
        String status = jedis.set("foo", "bar");
        //返回OK
        assertEquals("OK", status);
        //获取key为foo的值
        String value = jedis.get("foo");
        //取出的值为bar,所以相等
        assertEquals("bar", value);
        //由于不存在名为bar的key,所以取出来的值为null
        assertEquals(null, jedis.get("bar"));
    }

    @Test
    public void getSet() {
    	//将foo的值设为bar，并返回foo的旧值
        String value = jedis.getSet("foo", "bar");
        //旧值为null
        assertEquals(null, value);
        value = jedis.get("foo");
        assertEquals("bar", value);
    }

    @Test
    public void mget() {
    	//mget:返回所有(一个或多个)给定key的值
        List<String> values = jedis.mget("foo", "bar");
        List<String> expected = new ArrayList<String>();
        expected.add(null);
        expected.add(null);

        assertEquals(expected, values);

        jedis.set("foo", "bar");

        expected = new ArrayList<String>();
        expected.add("bar");
        expected.add(null);
        values = jedis.mget("foo", "bar");

        assertEquals(expected, values);

        jedis.set("bar", "foo");

        expected = new ArrayList<String>();
        expected.add("bar");
        expected.add("foo");
        values = jedis.mget("foo", "bar");

        assertEquals(expected, values);
    }

    @Test
    public void setnx() {
    	//setnx：将key的值设为value，当且仅当key不存在
        long status = jedis.setnx("foo", "bar");
        assertEquals(1, status);
        assertEquals("bar", jedis.get("foo"));

        status = jedis.setnx("foo", "bar2");
        assertEquals(0, status);
        assertEquals("bar", jedis.get("foo"));
    }

    @Test
    public void setex() {
    	//给foo设置生存时间设为20秒,值为bar
        String status = jedis.setex("foo", 20, "bar");
        assertEquals("OK", status);
        //返回foo的剩余生存时间
        long ttl = jedis.ttl("foo");
        assertTrue(ttl > 0 && ttl <= 20);
    }

    @Test
    public void mset() {
    	//mset:同时设置一个或多个key-value对
        String status = jedis.mset("foo", "bar", "bar", "foo");
        assertEquals("OK", status);
        assertEquals("bar", jedis.get("foo"));
        assertEquals("foo", jedis.get("bar"));
    }

    @Test
    public void msetnx() {
    	//msetnx:同时设置一个或多个key-value对，当且仅当key不存在
        long status = jedis.msetnx("foo", "bar", "bar", "foo");
        assertEquals(1, status);
        assertEquals("bar", jedis.get("foo"));
        assertEquals("foo", jedis.get("bar"));

        status = jedis.msetnx("foo", "bar1", "bar2", "foo2");
        assertEquals(0, status);
        assertEquals("bar", jedis.get("foo"));
        assertEquals("foo", jedis.get("bar"));
    }

    @Test(expected = JedisDataException.class)
    public void incrWrongValue() {
        jedis.set("foo", "bar");
        //foo的值是字符串类型，执行incr函数即抛出异常
        jedis.incr("foo");
    }

    @Test
    public void incr() {
    	//如果foo不存在，以0为foo的初始值，然后执行INCR操作
        long value = jedis.incr("foo");
        assertEquals(1, value);
        value = jedis.incr("foo");
        assertEquals(2, value);
    }

    @Test(expected = JedisDataException.class)
    public void incrByWrongValue() {
        jedis.set("foo", "bar");
        //foo的值是字符串，给他增加2净抛出异常
        jedis.incrBy("foo", 2);
    }

    @Test
    public void incrBy() {
    	//如果foo不存在，以0为foo的初始值，然后执行INCRBY命令，增加2。
        long value = jedis.incrBy("foo", 2);
        assertEquals(2, value);
        value = jedis.incrBy("foo", 2);
        assertEquals(4, value);
    }

    @Test(expected = JedisDataException.class)
    public void decrWrongValue() {
        jedis.set("foo", "bar");
        //foo的值为字符串，不能操作减一
        jedis.decr("foo");
    }

    @Test
    public void decr() {
    	//如果foo不存在，以0为foo的初始值，然后执行DECR操作。
        long value = jedis.decr("foo");
        assertEquals(-1, value);
        value = jedis.decr("foo");
        assertEquals(-2, value);
    }

    @Test(expected = JedisDataException.class)
    public void decrByWrongValue() {
        jedis.set("foo", "bar");
        //foo的值为字符串，不能操作减2
        jedis.decrBy("foo", 2);
    }

    @Test
    public void decrBy() {
        long value = jedis.decrBy("foo", 2);
        assertEquals(-2, value);
        value = jedis.decrBy("foo", 2);
        assertEquals(-4, value);
    }

    @Test
    public void append() {
    	//foo不存在，给foor的值设为bar，返回append后的值长度
        long value = jedis.append("foo", "bar");
        assertEquals(3, value);
        assertEquals("bar", jedis.get("foo"));
        //再次append,在之前的值之后
        value = jedis.append("foo", "bar");
        assertEquals(6, value);
        assertEquals("barbar", jedis.get("foo"));
    }

    @Test
    public void substr() {
        jedis.set("s", "This is a string");
        //截字符串操作，没什么好说的
        assertEquals("This", jedis.substr("s", 0, 3));
        assertEquals("ing", jedis.substr("s", -3, -1));
        assertEquals("This is a string", jedis.substr("s", 0, -1));
        assertEquals(" string", jedis.substr("s", 9, 100000));
    }

    @Test
    public void strlen() {
        jedis.set("s", "This is a string");
        assertEquals("This is a string".length(), jedis.strlen("s").intValue());
    }

    @Test
    public void incrLargeNumbers() {
        long value = jedis.incr("foo");
        assertEquals(1, value);
        assertEquals(1L + Integer.MAX_VALUE, (long) jedis.incrBy("foo",
                Integer.MAX_VALUE));
    }

    @Test(expected = JedisDataException.class)
    public void incrReallyLargeNumbers() {
        jedis.set("foo", Long.toString(Long.MAX_VALUE));
        long value = jedis.incr("foo");
        assertEquals(Long.MIN_VALUE, value);
    }
} 

 源码包迟点发布