Redis

1.Redis介绍

Redis是一个开源的使用ANSIC语言编写、支持网络、可基于内存 亦可持久化的日志型、Key-Value数据库。

2.Redis特性

1.Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。

2.Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。

3.Redis支持数据的备份。

3.Redis下载

可以直接在windows上下载，通过上传工个上传到linux系统，也可以在linux下直接

最新稳定版本下载

wget http://download.redis.io/releases/redis-3.2.8.tar.gz

4.Redis安装

1.解压

tar -xzvf redis-4.0.8.tar.gz

2.安装

cd redis-4.0.8
make
cd src
make install PREFIX=/usr/local/redis

3.移动配置文件到安装目录

mkdir /usr/local/redis/etc
cd ..
mv redis.conf /usr/local/redis/etc

4.设置redis后台启动

vi /usr/local/redis/etc/redis.conf 

将daemonize no 改成daemonize yes，保存退出。

5.将redis加入到开机启动

vi /etc/rc.local　　

在里面添加

/usr/local/redis/bin/redis-server /usr/local/redis/etc/redis.conf

6.开启redis

/usr/local/redis/bin/redis-server /usr/local/redis/etc/redis.conf 

关闭redis服务

pkill redis

7.redis客户端连接测试（此时已默认开启了redis）

/usr/local/redis/bin/redis-cli

如果设置了密码，就要使用密码登录

/usr/local/redis/bin/redis-cli -h ip地址 -p 6379  -a 密码

设置密码

在配置文件中找到这行代码

# requirepass foobared

取消注释，后面设置密码，这是设置为1234

requirepass 1234

8.设置允许外网访问

在redis.conf文见中把bind开始的代码注释，如下

#bind 127.0.0.1

5.Redis数据类型与常见操作

5.1string类型常见操作

 5.2list操作

LPUSH key value [value ...]
在指定Key所关联的List Value的头部插入参数中给出的所有Values。如果该Key不存在，该命令将在插入之前创建一个与该Key关联的空链表，之后再将数据从链表的头部插入。如果该键的Value不是链表类型，该命令将返回相关的错误信息。
返回值：插入后链表中元素的数量

LPUSHX key value 	 
仅有当参数中指定的Key存在时，该命令才会在其所关联的List Value的头部插入参数中给出的Value，否则将不会有任何操作发生。
返回值：插入后链表中元素的数量

LRANGE key start stop 	 
该命令的参数start和end都是0-based。即0表示链表头部(leftmost)的第一个元素。其中start的值也可以为负值，-1将表示链表中的最后一个元素，即尾部元素，-2表示倒数第二个并以此类推。该命令在获取元素时，start和end位置上的元素也会被取出。如果start的值大于链表中元素的数量，空链表将会被返回。如果end的值大于元素的数量，该命令则获取从start(包括start)开始，链表中剩余的所有元素。
返回值：返回指定范围内元素的列表。　

LPOP key 	 
返回并弹出指定Key关联的链表中的第一个元素，即头部元素。如果该Key不存，返回nil。
返回值：链表头部的元素

LLEN key	 
返回指定Key关联的链表中元素的数量，如果该Key不存在，则返回0。如果与该Key关联的Value的类型不是链表，则返回相关的错误信息。
返回值：链表中元素的数量　　

LREM key count value  
在指定Key关联的链表中，count删除的个数 0 代表的是全部删除 	
返回值：返回被删除的元素数量

LSET key index value 
设定链表中指定位置的值为新值，其中0表示第一个元素，即头部元素，-1表示尾部元素。如果索引值Index超出了链表中元素的数量范围，该命令将返回相关的错误信息

LINDEX key index 	  
该命令将返回链表中指定位置(index)的元素，index是0-based，表示头部元素，如果index为-1，表示尾部元素。如果与该Key关联的不是链表，该命令将返回相关的错误信息。	
返回值：返回请求的元素，如果index超出范围，则返回nil　

LTRIM key start stop 	 
该命令将仅保留指定范围内的元素，从而保证链接中的元素数量相对恒定。start和stop参数都是0-based，0表示头部元素。和其他命令一样，start和stop也可以为负值，-1表示尾部元素。如果start大于链表的尾部，或start大于stop，该命令不错报错，而是返回一个空的链表，与此同时该Key也将被删除。如果stop大于元素的数量，则保留从start开始剩余的所有元素

LINSERT key BEFORE|AFTER pivot value   
该命令的功能是在pivot元素的前面或后面插入参数中的元素value。如果Key不存在，该命令将不执行任何操作。如果与Key关联的Value类型不是链表，相关的错误信息将被返回。	
返回值：成功插入后链表中元素的数量，如果没有找到pivot，返回-1，如果key不存在，返回0

L表示左，R表示右，操作都相同。　　

5.3hash类型常见操作

HSET key field value	 
为指定的Key设定Field/Value对，如果Key不存在，该命令将创建新Key以参数中的Field/Value对，如果参数中的Field在该Key中已经存在，则用新值覆盖其原有值。
返回值：1表示新的Field被设置了新值，0表示Field已经存在，用新值覆盖原有值

HGET key field 	 
返回指定Key中指定Field的关联值。	
返回值：返回参数中Field的关联值，如果参数中的Key或Field不存，返回nil

HSETNX key field value	 
只有当参数中的Key或Field不存在的情况下，为指定的Key设定Field/Value对，否则该命令不会进行任何操作。 	
返回值：1表示新的Field被设置了新值，0表示Key或Field已经存在，该命令没有进行任何操作。

HEXISTS key field 	 
判断指定Key中的指定Field是否存在。	
返回值：1表示存在，0表示参数中的Field或Key不存在

HLEN key 	 
获取该Key所包含的Field的数量。	返回Key包含的Field数量，如果Key不存在，返回0

HDEL key field [field ...] 	 
从指定Key的Hashes Value中删除参数中指定的多个字段，如果不存在的字段将被忽略。
返回值：如果Key不存在，则将其视为空Hashes，并返回0，否则返回实际删除的Field数量

HINCRBY key field increment 	 
增加指定Key中指定Field关联的Value的值。如果Key或Field不存在，该命令将会创建一个新Key或新Field，并将其关联的Value初始化为0，之后再指定数字增加的操作。该命令支持的数字是64位有符号整型，即increment可以负数。返回值：运算后的值

HGETALL key	 
获取该键包含的所有Field/Value。其返回格式为一个Field、一个Value，并以此类推。	
返回值：Field/Value的列表

HKEYS key 	 
返回指定Key的所有Fields名。	
返回值：Field的列表

HVALS key 	 
返回指定Key的所有Values名。 	
返回值：Value的列表

HMGET key field [field ...] 	 
获取和参数中指定Fields关联的一组Values。如果请求的Field不存在，其值返回nil。如果Key不存在，该命令将其视为空Hash，因此返回一组nil。	
返回值：返回和请求Fields关联的一组Values，其返回顺序等同于Fields的请求顺序

HMSET key field value [field value ...]	 
逐对依次设置参数中给出的Field/Value对。如果其中某个Field已经存在，则用新值覆盖原有值。如果Key不存在，则创建新Key，同时设定参数中的Field/Value

6.Jedis介绍与快速入门

通过java来操作redis使用jedis

1.搭建jedis环境（导入jedis的jar包）

2.编写测试类

package com.test;

import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;

public class JedisTest {
    public Jedis jedis;
    @Before
    public void before(){
       jedis =new Jedis("192.168.239.129");
        jedis.auth("admin");
    }
    @Test
     public void test(){
        jedis.set("name","11111");
        String name = jedis.get("name");
        System.out.println(name);

    }
}

在这个测试中，可能会发生异常，所以在运行之前需要进行检查：

1. redis服务器是否开启

2. linux的防火墙是否关闭

3. 在redis.conf配置文件中 bind 127.0.0.1 代表的是外部不可以访问redis，需要外部访问，要关闭这个，然后设置密码。

　　　　　　关闭绑定：直接注释， #bind 127.0.0.1 

　　　　　　设置密码：

vim redis.conf

　　　　　　　　打开requirepass并设置密码

requirepass

设置之后可先在命令行登录测试密码的正确性（登录上面有），然后在运行java代码　　

3.代码参考

3.1string

//string操作
public class JedisDemo2 {
    Jedis jedis;

    @Before
    public void createJedis() {
        jedis = new Jedis("192.168.19.128");
        // 设置密码
        jedis.auth("admin");
    }

    // 演示 set get
    @Test
    public void test1() {
        jedis.set("username", "tom");        
        String value = jedis.get("username");
        System.out.println(value);
    }
    
    //演示mset  mget
    @Test
    public void test2(){
        jedis.mset("password","123","age","20");
        
        List<String> values = jedis.mget("username","password","age");
        
        System.out.println(values);
    }
    
    //演示  append  setrange  getrange
    @Test
    public void test3(){
        //jedis.append("username"," is boy");
        
        //jedis.setrange("username", 7,"girl");
        System.out.println(jedis.get("username"));
        System.out.println(jedis.getrange("username", 7, -1));
    }
}

3.2list

//list操作
public class JedisDemo3 {
    Jedis jedis;

    @Before
    public void createJedis() {
        jedis = new Jedis("192.168.19.128");
        // 设置密码
        jedis.auth("admin");
    }

    // 演示lpush lrange
    @Test
    public void test1() {
        jedis.lpush("names", "tom", "james", "张三", "李四");
        List<String> names = jedis.lrange("names", 0, -1);
        System.out.println(names);
    }

    // lset
    @Test
    public void test2() {
        // jedis.lset("names", 1, "王五");
        // List<String> names = jedis.lrange("names", 0, -1);
        // System.out.println(names);

        String value = jedis.lindex("names", 1);
        System.out.println(value);
    }

    // linsert
    @Test
    public void test3() {
        jedis.linsert("names", LIST_POSITION.BEFORE, "james", "fox");

        List<String> names = jedis.lrange("names", 0, -1);
        System.out.println(names);
    }
    
    // lrem
    @Test
    public void test4(){
        jedis.lrem("names", 1, "tom");
        List<String> names = jedis.lrange("names", 0, -1);
        System.out.println(names);
    }
}

3.3hash

//hash操作
public class JedisDemo4 {
    Jedis jedis;

    @Before
    public void createJedis() {
        jedis = new Jedis("192.168.19.128");
        // 设置密码
        jedis.auth("admin");
    }

    // 演示hset hget
    @Test
    public void test1() {
        jedis.hset("user", "username", "tom");

        String value = jedis.hget("user", "username");
        System.out.println(value);
    }

    // 演示hmset hmget
    @Test
    public void test2() {
        Map<String, String> hash = new HashMap<String, String>();
        hash.put("password", "123");
        hash.put("sex", "male");
        jedis.hmset("user", hash);

        List<String> values = jedis.hmget("user", "username", "password", "sex");
        System.out.println(values);
    }
    
    //演示  hgetall hkeys  kvals
    @Test
    public void test3(){
        Map<String, String> map = jedis.hgetAll("user");
        for(String key:map.keySet()){
            System.out.println(key+"  "+map.get(key));
        }
        
        Set<String> keys = jedis.hkeys("user");
        System.out.println(keys);
        
        List<String> values = jedis.hvals("user");
        System.out.println(values);
    }
    
//    演示hdel
    @Test
    public void test4(){
        jedis.hdel("user", "username","password");
        Map<String, String> map = jedis.hgetAll("user");
        for(String key:map.keySet()){
            System.out.println(key+"  "+map.get(key));
        }
    }
}

3.4set

//set操作
public class JedisDemo5 {
    Jedis jedis;

    @Before
    public void createJedis() {
        jedis = new Jedis("192.168.19.128");
        // 设置密码
        jedis.auth("admin");        
    }
    
    //演示sadd smembers
    @Test
    public void test1(){
        jedis.sadd("language1","java","c++","ruby","python");
        
        Set<String> smembers = jedis.smembers("language1");
        System.out.println(smembers);
    }
    
    //演示srem
    @Test
    public void test2(){
        jedis.srem("language1", "java");
        Set<String> smembers = jedis.smembers("language1");
        System.out.println(smembers);
    }
    
    //差集 sdiff
    @Test
    public void test3(){
        jedis.sadd("language1","java","c++","ruby","python");
        jedis.sadd("language2","ios","c++","c#","android");
        
        Set<String> sdiff = jedis.sdiff("language1","language2");
        System.out.println(sdiff);
    }
    
    //交集
    @Test
    public void test4(){
        jedis.sadd("language1","java","c++","ruby","python");
        jedis.sadd("language2","ios","c++","c#","android");
        Set<String> sinter = jedis.sinter("language1","language2");
        System.out.println(sinter);
    }
    
    //并集
    @Test
    public void test5(){
        jedis.sadd("language1","java","c++","ruby","python");
        jedis.sadd("language2","ios","c++","c#","android");
        Set<String> sunion = jedis.sunion("language1","language2");
        System.out.println(sunion);
    }   
}

3.5sortedset

//sortedset操作
public class JedisDemo6 {
    Jedis jedis;

    @Before
    public void createJedis() {
        jedis = new Jedis("192.168.19.128");
        // 设置密码
        jedis.auth("admin");

    }

    // 演示zadd zrange zrangeByScore
    @Test
    public void test1() {
        Map<String, Double> sm = new HashMap<String, Double>();
        sm.put("张三", 70.0);
        sm.put("李四", 80.0);
        sm.put("王五", 90.0);
        sm.put("赵六", 60.0);
        jedis.zadd("zkey", sm);

        Set<String> set = jedis.zrange("zkey", 0, -1);
        System.out.println(set);
        // 根据分数获取
        Set<String> set1 = jedis.zrangeByScore("zkey", 70.0, 90.0);
        System.out.println(set1);
    }

    // 获取分数元素 zrangeWithScores
    @Test
    public void test2() {
        Map<String, Double> sm = new HashMap<String, Double>();
        sm.put("张三", 70.0);
        sm.put("李四", 80.0);
        sm.put("王五", 90.0);
        sm.put("赵六", 60.0);
        jedis.zadd("zkey", sm);

        Set<Tuple> zws = jedis.zrangeWithScores("zkey", 0, -1);
        for (Tuple t : zws) {
            System.out.println(t.getScore() + "  " + t.getElement());
        }
    }

    // zrank
    @Test
    public void test3() {
        Map<String, Double> sm = new HashMap<String, Double>();
        sm.put("张三", 70.0);
        sm.put("李四", 80.0);
        sm.put("王五", 90.0);
        sm.put("赵六", 60.0);
        jedis.zadd("zkey", sm);

        Long num = jedis.zrank("zkey", "赵六");
        System.out.println(num);
    }

    // zscore
    @Test
    public void test4() {
        Map<String, Double> sm = new HashMap<String, Double>();
        sm.put("张三", 70.0);
        sm.put("李四", 80.0);
        sm.put("王五", 90.0);
        sm.put("赵六", 60.0);
        jedis.zadd("zkey", sm);
        Double zscore = jedis.zscore("zkey", "张三");
        System.out.println(zscore);
    }

    // zrem
    @Test
    public void test5() {
        Map<String, Double> sm = new HashMap<String, Double>();
        sm.put("张三", 70.0);
        sm.put("李四", 80.0);
        sm.put("王五", 90.0);
        sm.put("赵六", 60.0);
        jedis.zadd("zkey", sm);

        jedis.zrem("zkey", "李四");
        
        Set<Tuple> zws = jedis.zrangeWithScores("zkey", 0, -1);
        for (Tuple t : zws) {
            System.out.println(t.getScore() + "  " + t.getElement());
        }
    }
}

3.6key

//key的通用操作
public class JedisDemo7 {
    Jedis jedis;

    @Before
    public void createJedis() {
        jedis = new Jedis("192.168.19.128");
    }
    // keys patten
    @Test
    public void test1(){
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);
    }
    
    // del key
    @Test
    public void test2(){
        Long del = jedis.del("user");
        System.out.println(del);
    }
    
    //关于key时间设置
    @Test
    public void test3(){
        //jedis.expire("username", 200); //设置生命周期为200秒
        jedis.persist("username");
        Long ttl = jedis.ttl("username"); //获取生命周期值
        System.out.println(ttl);     
    }
}　

在redis.conf文见中把bind开始的代码注释

转载于:https://www.cnblogs.com/zys2019/p/11447169.html