Redis入门

redis-server  配置文件的名字

# 如 redis-server redis.conf

redis-cli -h 主机  -p 端口

#如 redis-cli -h 127.0.0.1 -p 6379

# 若有密码，再在客户端执行 auth 密码

 ping

 #返回pong成功

进入客户端后执行shutdown

或者

直接 redis-cli -p 6378 shutdown

keys  *

查询当前库的所有键

exists  <key>

判断某个键是否存在

del  <key>

删除某个键

expire   <key>   <seconds>

为键值设置过期时间，单位秒。

ttl   <key> 

查看还有多少秒过期，-1表示永不过期，-2表示已过期

dbsize  

查看当前数据库的key的数量

flushdb

清空当前库

flushall

通杀全部库（会触发rdb存盘） 

String是Redis最基本的类型，你可以理解成与Memcached一模一样的类型，一个key对应一个value。

String类型是二进制安全的。意味着Redis的string可以包含任何数据。比如jpg图片或者序列化的对象。

String类型是Redis最基本的数据类型，一个Redis中字符串value最多可以是512M

get   <key>

查询对应键值

set   <key>  <value>

添加键值对

setex  <key>  <过期时间>   <value>

设置键值的同时，设置过期时间，单位秒。

setnx  <key>  <value>

只有在 key 不存在时设置 key 的值

incr  <key>

将 key 中储存的数字值增1

只能对数字值操作，如果为空，新增值为1

mset  <key1>  <value1>  <key2>  <value2>  ..... 

同时设置一个或多个 key-value对  

mget  <key1>   <key2>   <key3> ..... 

同时获取一个或多个 value  

单键多值

Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素导列表的头部（左边）或者尾部（右边）。

它的底层实际是个双向链表，对两端的操作性能很高，通过索引下标的操作中间的节点性能会较差。

lpush/rpush  <key>  <value1>  <value2>  <value3> ....

从左边/右边插入一个或多个值。

lpop/rpop  <key> 

从左边/右边吐出一个值。

值在键在，值光键亡

 rpoplpush  <key1>  <key2>  

从<key1>列表右边吐出一个值，插到<key2>列表左边。

lrange <key> <index>

按照索引下标获得元素(从左到右)

lindex <key> <index>

按照索引下标获得元素(从左到右)

llen <key>

获得列表长度 

Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。

Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表,所以添加，删除，查找的复杂度都是O(1)。

sadd <key>  <value1>  <value2> .....   

将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。

smembers <key>

 取出该集合的所有值。

sismember <key>  <value>

 判断集合<key>是否为含有该<value>值，有返回1，没有返回0

srem <key> <value1> <value2> ....

 删除集合中的某个元素。

sinter <key1> <key2>  

 返回两个集合的交集元素。

sunion <key1> <key2>  

 返回两个集合的并集元素。

sdiff <key1> <key2>  

 返回两个集合的差集元素。

Redis  hash 是一个键值对集合。

Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。

类似Java里面的Map<String,Object>

hset <key>  <field>  <value>

给<key>集合中的  <field>键赋值<value>

hget <key1>  <field>   

 从<key1>集合<field> 取出 value 

hmset <key1>  <field1> <value1> <field2> <value2>...   

 批量设置hash的值

hexists key  <field>

查看哈希表 key 中，给定域 field 是否存在。 

hgetall <key>   

 列出该hash集合的所有field和values

hincrby <key> <field>  <increment> 

为哈希表 key 中的域 field 的值加上增量 increment 

       因为元素是有序的, 所以你也可以很快的根据评分（score）或者次序（position）来获取一个范围的元素。访问有序集合的中间元素也是非常快的,因此你能够使用有序集合作为一个没有重复成员的智能列表。

zadd  <key> <score1> <value1>  <score2> <value2>...

将一个或多个 member 元素及其 score 值加入到有序集 key 当中。

zrange <key>  <start> <stop>  [WITHSCORES]   

返回有序集 key 中，下标在<start> <stop>之间的元素

带WITHSCORES，可以让分数一起和值返回到结果集。

有序输出从小到大

zrevrange <key>  <start> <stop>  [WITHSCORES]   

同上，逆序按评分从大到小

zincrby <key> <increment> <value>

为元素的score加上增量

 zrem  <key>  <value>  

删除该集合下，指定值的元素 

 zcount <key>  <min>  <max> 

统计该集合，分数区间内的元素个数 

 zrank <key>  <value> 

返回该值在集合中的排名，从0开始。

# 仆跟随主的命令

#ip 和port为主的，这个命令在从上运行

slaveof  <ip>  <port>

# 仆不跟随主的命令，自己变为主（反客为主），需要其他从再确认主

slaveof no one 

# 打印主从复制的相关信息

info replication

# 打开集群模式

cluster-enabled yes  

# 设定节点配置文件名

cluster-config-file  nodes-6379.conf 

# 设定节点失联时间，超过该时间（毫秒），集群自动进行主从切换。

cluster-node-timeout 15000

# 默认是yes ，如果选no那么即使某一部分的slot完全下线(包括从机)，集群也会继续以现存的数据提供服务。 

cluster-require-full-coverage yes

package com.shuai;

import redis.clients.jedis.Jedis;

import java.util.*;

/**

 * @author Shuai

 * @create 2020-07-14 0:17

 */

public class Test1 {

    public static void main(String[] args) {

        //连接本地的 Redis 服务

        Jedis jedis = new Jedis("hadoop102", 6379);

        //查看服务是否运行，打出pong表示OK

        System.out.println("connection is OK==========>: " + jedis.ping());

        //---------下面的全是逻辑代码，环境准备只需要第一行代码-----

        //key

        Set<String> keys = jedis.keys("*");

        for (Iterator iterator = keys.iterator(); iterator.hasNext(); ) {

            String key = (String) iterator.next();

            System.out.println(key);

        }

        System.out.println("jedis.exists====>" + jedis.exists("k2"));

        System.out.println(jedis.ttl("k1"));

        //Jedis-API:    String

        System.out.println(jedis.get("k1"));

        jedis.set("k4", "k4_Redis");

        System.out.println("----------------------------------------");

        jedis.mset("str1", "v1", "str2", "v2", "str3", "v3");

        System.out.println(jedis.mget("str1", "str2", "str3"));

        //Jedis-API:    List

        List<String> list = jedis.lrange("mylist", 0, -1);

        for (String element : list) {

            System.out.println(element);

        }

        //Jedis-API:    set

        jedis.sadd("orders", "jd001");

        jedis.sadd("orders", "jd002");

        jedis.sadd("orders", "jd003");

        Set<String> set1 = jedis.smembers("orders");

        for (Iterator iterator = set1.iterator(); iterator.hasNext(); ) {

            String string = (String) iterator.next();

            System.out.println(string);

        }

        jedis.srem("orders", "jd002");

        //Jedis-API:    hash

        jedis.hset("hash1", "userName", "lisi");

        System.out.println(jedis.hget("hash1", "userName"));

        Map<String, String> map = new HashMap<String, String>();

        map.put("telphone", "13810169999");

        map.put("address", "atguigu");

        map.put("email", "abc@163.com");

        jedis.hmset("hash2", map);

        List<String> result = jedis.hmget("hash2", "telphone", "email");

        for (String element : result) {

            System.out.println(element);

        }

        //Jedis-API:    zset

        jedis.zadd("zset01", 60d, "v1");

        jedis.zadd("zset01", 70d, "v2");

        jedis.zadd("zset01", 80d, "v3");

        jedis.zadd("zset01", 90d, "v4");

        Set<String> s1 = jedis.zrange("zset01", 0, -1);

        for (Iterator iterator = s1.iterator(); iterator.hasNext(); ) {

            String string = (String) iterator.next();

            System.out.println(string);

        }

    }

}

import redis.clients.jedis.HostAndPort;

import redis.clients.jedis.JedisCluster;

import redis.clients.jedis.JedisPoolConfig;

import java.util.HashSet;

import java.util.Set;

/**

 * @author Shuai

 * @create 2020-07-16 17:13

 */

public class JedisClusterTest {

    public static void main(String[] args) {

        JedisCluster jedisCluter = JedisClusterTest.getJedisCluter();

        jedisCluter.set("k111", "v111");

        jedisCluter.set("k222", "v222");

        jedisCluter.set("k333", "v333");

        System.out.println(jedisCluter.get("k111"));

        System.out.println(jedisCluter.get("k222"));

        System.out.println(jedisCluter.get("k333"));

    }

    public static JedisCluster jedisCluster = null;

    public static JedisCluster getJedisCluter() {

        if (jedisCluster == null) {

            Set<HostAndPort> hostAndPortSet = new HashSet<>();

            hostAndPortSet.add(new HostAndPort("192.168.75.102", 6379));

            hostAndPortSet.add(new HostAndPort("hadoop102", 6380));

            hostAndPortSet.add(new HostAndPort("hadoop102", 6381));

            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

            jedisPoolConfig.setMaxTotal(20);

            jedisPoolConfig.setBlockWhenExhausted(true);

            jedisPoolConfig.setMaxWaitMillis(2000);

            jedisPoolConfig.setMaxIdle(5);

            jedisPoolConfig.setMinIdle(5);

            jedisPoolConfig.setTestOnBorrow(true);

            JedisCluster jedisCluster = new JedisCluster(hostAndPortSet, jedisPoolConfig);

            return jedisCluster;

        } else {

            return jedisCluster;

        }

    }

}