redis---基础大全

Redis

1、Redis介绍

说明：
①redis是基于内存的nosql的数据库。（nosql: not only structure query language）
 Redis是一种面向“键/值”对数据类型的内存数据库
②no sql数据库有：
 hbase
 mongodb
 redis
③redis的性能高：
 读的速度：11万次/秒
 写的速度：8.1万次/秒
④redis底层的源码使用c来开发的，作者也提供了各种语言的客户端（java,php等等）
 不能使用命令jps（java processor status）查看进程名
  netstat -tunlp | grep 6379
⑤也可以用作消息的中间件（包含消息的发布和订阅）。
⑥应用在高并发和实时请求的场景。

1.1、redis.conf核心配置文件介绍

→ 配置信息的查看以及编辑	
	可以通过config命令来查看或设置配置项。
	1，查看
	   语法,Redis config命令格式如下：  
	   redis localost:6379> config get 配置名称
	   如: redis localost:6379> config get loglevel
	   1) "loglevel"
	   2) "notice"
	   使用*号获取所有配置项：redis localost:6379> config get *
	   
	2，编辑
	  可以通过修改redis.conf文件或使用config set命令来修改配置
	  方式1：永久方式 → 可以通过修改redis.conf文件
	  方式2：临时方式（redis server不重启，一直有效，重启失效）→ config set命令来修改配置
	  基本语法：
	  redis localost:6379> config set 配置名 配置值
	  eg: redis localost:6379> config set loglevel "warning"
		  redis localost:6379> config get loglevel
	  1) "loglevel"
	  2) "warning"  -->对当前服务有效，之后当服务重启之后，才会失效	

1.2、redis的安全设置

→ Redis的安全设置	
	设置Redis密码，修改redis.conf
		requirepass root --->将redis密码修改成为root
		启动客户端（连接远程的redis服务器）：src/redis-cli -h NODE01 -p 6379 -a root
	关闭服务：redis-cli -a root -h NODE01 shutdown
	注意：后续演示已经将requirepass设置关掉。

2、 redis常用数据类型

2.1 介绍

	Redis支持五种数据类型：
		string(字符串)
		hash(哈希)  
		list(列表)
		set（集合）
		zset（sorted set：有序集合）

2.2 redis常用数据类型之（string）

	意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象 。string类型是Redis最基本的数据类型，一个键最大能存储512MB（默认的值，可以在redis.conf中进行定制）。

	命令		    描述
	-------------------------------------------------------------------------------------
	SET key value				设置指定key的值（会覆盖无视数据类型）
	GET key						获取指定key的值
	GETRANGE key start end		 返回key中字符串值的子字符(从0开始的闭区间[start, end])
	GETSET key value			 将给定key的值设为value，并返回key的旧值(old value)
	GETBIT key offset			 对key所储存的字符串值，获取指定偏移量上的位(bit)
	MGET key1 [key2..] 			 获取所有(一个或多个)给定key的值
	SETBIT key offset value		  对key所储存的字符串值，设置或清除指定偏移量上的位(bit)
	SETEX key seconds value		  将值value关联到key，并将key的过期时间设为seconds(以秒为单位)
	SETNX key value	  			 只有在key不存在时设置key的值
	SETRANGE key offset value	  用value参数覆写给定key所储存的字符串值，从偏移量offset开始
	STRLEN key					 返回key所储存的字符串值的长度
	MSET key value [key value ...]	    同时设置一个或多个key-value对
	MSETNX key value [key value ...]	同时设置一个或多个key-value对，当且仅当所有给定key都不存在
	PSETEX key milliseconds value		这个命令和SETEX命令相似，但它以毫秒为单位设置key的生存时间，而不是像SETEX命令那样，以秒为单位
	INCR key						   将key中对应储存的数字值增一
	INCRBY key increment			    将key所储存的值加上给定的增量值（increment）
	INCRBYFLOAT key increment		     将key所储存的值加上给定的浮点增量值（increment）
	DECR key						   将key中储存的数字值减一
	DECRBY key decrement key			所储存的值减去给定的减量值（decrement）
	APPEND key value	如果key已经存在并且是一个字符串，APPEND命令将value追加到key原来的值的末尾

2.3 redis常用数据类型之hash(哈希)

	Redis hash 是一个键值对集合。Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。
	每个hash可以存储2的32-1次幂键值对（40多亿）。 

	命令	         	描述
	-------------------------------------------------------------------------------------    
	HDEL key field2 [field2]					  删除一个或多个哈是表字段
	HEXISTS key field							 查看hash表key中，指定字段是否存在
	HGET key field								 获取hash表中指定字段的值
	HGETALL key									 获取所有的字段和值
	HINCRBY key field increment					  为指定字段的整数值加上增量increment
	HINCRBYFLOAT key field increment			   为指定字段的浮点值加上增量increment
	HKEYS key									 获取所有的字段
	HLEN key									 获取字段的数量
	HMGET key field1 [field2]					  获取所有给定字段的值
	HMSET key f1 v1 [f2 v2]						  同时将多个file-value设置到key中
	HSET key field value						  将哈希表key的field设置为value
	HSETNX key field value						  当在field不存在时，设置相关字段的值
	HVALS key									 获取所有的值
	HSCAN key cursor [MATCH pattern] [COUNT count] 	迭代哈希表中的键值对

2.4 redis常用数据类型之List(链表)

	   Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。
	列表最多可存储 2的32-1次幂元素 (4294967295, 每个列表可存储40多亿)。 （列表：双向链表）
	
	  注意： ①list是双向链表
	        ②有序，不排重
	        ③其他类型可以通过值直接转换成string类型，反之则不行。如：不能将string转换为list

	命令			描述
	-------------------------------------------------------------------------------------  
	BLPOP key1 [key2 ] timeout					移除并获取列表中的第一个元素，如果没有会阻塞列表直到超时【单位是秒s】或发现可弹出元素为止
	BRPOP key1 [key2 ] timeout					移除并获取列表中的最后一个元素，如果没有会阻塞列表直到超市或发现可弹出元素为止
	BRPOPLPUSH source destination timeout		从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它，如果没有元素会阻塞列表知道等待超时或发现可弹出元素为止
	LINDEX key index						  通过索引获取列表中的元素
	LINSERT key BEFORE|AFTER pivot value		在列表的元素前或后插入元素
	LLEN key						获取列表长度
	LPOP key						移出并获取列表的第一个元素
	LPUSH key value1 [value2]		 将一个或多个值插入到列表头部
	LPUSHX key value				将一个或多个值插入到已存在的列表头部
	LRANGE key start stop			获取列表指定返回内的元素
	LREM key count value			移出列表元素
	LSET key index value			通过索引设置列表元素的值
	LTRIM key start stop			对一个列表进行修剪(trim)，也就是说，让列表只保留指定区间内的元素，删除其它
	RPOP key					    移出并获取列表最后一个元素
	RPOPLPUSH source destination	 移出列表的最后一个元素，并将该元素添加到另一列表并返回
	RPUSH key value1 [value2]		 在列表中添加一个或多个值
	RPUSHX key value				为已存在的列表添加值

2.5 redis常用数据类型之Set(集合)

→类型4之Set(集合)
    Redis的Set是string类型的无序集合。
    集合是通过哈希表实现的，与Java中的Set集合类似（无序，排重）
    注意：
    ①根据集合内元素的唯一性，第二次插入相同的元素将被忽略。
    集合中最大的成员数为 2的32 - 1次方 (4294967295, 每个集合可存储40多亿个成员)。

    命令			描述
    -----------------------------------------------------------------------------------
    SADD key member1 [member2]			 向集合添加一个或多个成员
    SCARD key							获取集合的成员数(size)
    SDIFF key1 [key2]					返回给定所有集合的差集  （差集 = 集合 - 交集）
    SDIFFSTORE dest key1 [key2]			 返回并保存给定集合差集保存到dest中
    SINTER key1 [key2]					返回给定集合的交集
    SINTERSTORE dest key1 [key2]		 返回并保存给定集合的交集到dest中
    SISMEMBER key member			 	 判断member元素是否是集合key的成员
    SMEMBERS key						返回集合中所有成员
    SMOVE src dest member			     将member元素从src移动到dest中
    SPOP key							移除并返回集合中的一个随机元素
    SRANDMEMBER key [count]				 返回集合中一个或多个随机元素
    SREM key member1 [member2]		  	  移除集合中一个或多个成员
    SUNION key1 [key2]					 返回所有给定集合的并集
    SUNIONSTORE dest key1 [key2]		  返回并保存给定集合的并集到dest
    SSCAN key cursor [match pattern] [count count]		迭代集合中的元素	

2.6 redis常用数据类型之zset(集合)

类型5之zset(集合)
	zset（sorted set：有序集合）
		   Redis zset和set一样也是string类型元素的集合,且不允许重复的成员。不同的是每个元素都会关联一个double类型的分数。
		   redis正是通过分数来为集合中的成员进行从小到大的排序。
		   zset的成员是唯一的,但分数(score)却可以重复。
		   zadd命令 添加元素到集合，元素在集合中存在则更新对应score
		   
	注意： 
	   ①排重，且排序的
	   ②如何来排序的：
	      a) 若得分相同，根据值的字典顺序升序排列的
		  b) 若得分不同，根据分数的升序来排列的

	命令		         	描述
	——————————————————————————————————————————————————————————
	Zadd key score1 member1  [score2 member2]		 想有序集合添加一个或多个成员，或是更新已经存在成员的分数
	Zcard key						 获取有序集合的成员数
	Zcount key min max				  计算在有序集合中指定区间分数的成员数
	Zincrby key increment member		有序集合中对指定成员的分数上增量incr
	Zinterstore dest nkeys key [key..]	计算给定的一个或多个有序集的交集并保存在新的有序集合dest中
	Zlexcount key min max							  在有序集合中计算指定字典区间内成员数量
	Zrange key start stop [withscores]				   通过索引区间返回有序集合成指定区间内的成员
	Zrangebylex key min max [limit offset count]		通过字典区间返回有序集合的成员
	Zrangebyscore key min max [withscores] [limit]		通过分数返回有序集合指定区间内的成员
	Zrank key member						返回有序集合中指定成员的索引
	Zrem key member [member ...]			移除有序集合中的一个或多个成员
	Zremrangebylex key min max				移除有序集合中给定的字典区间的所有成员
	Zremrangebyrank key start stop			移除key中给定的排名区间的所有成员
	Zremrangebyscore key start stop			移除key中给定的分数区间的所有成员
	Zrevrange key start stop [withscores]	 返回有序key中指定区间内的成员，通过索引，分数从高到低
	Zrevrangebysocre key max min [withscores] 返回有序key中指定分数区间内的成员，通过索引，分数从高到低
	Zrevrank key memeber					返回key中指定成员的排名，key成员按分数值递减排序
	Zscore key member						返回key中member的分数
	Zunionstore dest numkeys key [key...]	  计算给定的一个或多个有序集的并集，并存储到新的dest中
	Zscan key cursor [match pattern] [COUNT count]	 迭代有序集合中的元素(包括元素成员和元素分值)

3 Redis集群（主从复制、读写分离）

注意这个集群不是分布式集群。

集群介绍

特点：
 1，主从复制、读写分离
    主节点（redis集群中处于主导地位的redis进程），作用是负责接收数据的写入
           并将写入的数据复制到从节点存储起来
    从节点（redis集群中处于从属地位的redis进程），作用是负责数据的读取。
	详解：
	   集群中的主从复制
			集群中的每个节点都有1个到N个复制品，其中一个为主节点，其余为从节点，如果主节点下线了，集群就会把这个主节点的一个从节点设置为新的主节点，继续工作。这个集群就不会因为一个主节点的下线而无法正常工作。
			如果某一个主节点和它所有的从节点都下线的话，redis集群就停止工作了。
			Redis集群不保证数据的强一致性，在特定的情况下，redis集群会丢失已经执行过的命令。
			使用异步复制(asynchronous replication)是Redis集群可能会丢失写命令的其中一个原因，有时候由于网络原因，如果网络断开时间太长，redis集群就会启用新的主节点，之前发给主节点的数据就会丢失。
			
			特点： ①主从复制，读写分离。
						写入数据时，向主节点写入，与此同时，数据会自动从主节点同步到从节点中。从节点只负责读取数据。（读取的速度：11万次/s； 写入的速度：8.1万次/s）
						原因：各司其职，效率最大化。（让数据的流向一致）	
				  ②配置redis集群时，将从节点设置为read-only,不能写。强行向从节点存入数据，会报错。

 2，Redis集群是一个分布式Redis存储架构，可以在多个节点之间进行数据共享，解决Redis高可用、可扩展等问题。Redis集群提供了一下两个好处
		①将数据自动切分(split)到多个节点
		③当集群中的某一个节点故障时，redis还可继续处理客户端的请求
		一个Redis集群包含16384个哈希槽(hash slot)，数据库中的每个数据都属于这16384个哈希槽中的一个。集群使用公式CRC16(key)%16384来计算
		key属于哪一个槽。集群中的每一个节点负责处理一部分哈希槽。
			
		集群中有三台节点：
			 节点名            哈希槽开始编号            哈希槽结束的编号
		————————————————————————————————————————————————————————————————————————
		   NODE01            0                                5461
		   NODE02            5462                             10921
		   NODE03            10922                            16383
		   
		   如何将指定的key存储到指定的哈希槽中的，使用的算法是：
			 CRC(KEY) % 16384 
		   然后，根据余数的范围，动态存储key以及对应的值到集群中相应的redis节点上

集群搭建

	~~>配置：
			注意：
			   ①在虚拟机NODE02,NODE03上创建目录
					/opt/soft
					
			   ②将压缩包拷贝到NODE02,NODE03上，解压后、重新编译，重命名，然后修改redis.conf配置文件即可或者是：直接从NODE01上将编译好的redis拷贝到NODE02,NODE03上  （前提：已经配好好了NODE01到NODE02,NODE03的免密码登录）
							   scp -r /opt/redis root@NODE03:/opt
			   ③修改/etc/profile.d/bigdata-etc.sh，配置环境变量，并source生效
			   ④配置Master-Slave，只需要在slave上redis.conf配置文件中添加master节点ip port就可以
				修改redis.conf配置文件
				拷贝：
				scp -r /opt/redis/redis.conf  root@NODE02:/opt/redis/redis.conf
				修改：
					slaveof <masterip> <masterport>
					logfile /opt/redis/logs/redis.log(日志文件，目录必须存在,创建目录：mkdir -p /opt/redis/logs)	
					bind 从节点主机名 （如：bind NODE02）
				另外需要注意一下slave-read-only 必须要为yes，这表示slave只读不写，这也是redis的推荐配置。				
				⑤启动配置了slave的服务
					两台从服务器只具备读的操作，不具备写的能力。
					启动客户端：src/redis-cli -h NODE02 -p 6379 -a root	
					关闭服务：redis-cli -a root -h NODE02 shutdown

若是强行在从节点写入数据，报错

主节点读写都可以（建议只负责写入数据）

3.1 准备

	 步骤：
		 1，Maven工程的创建
		 2,  准备资源文件redis.properties
		 3,  准备一个接口存储字符串字面值
		 4, 工具类（Jedis池，从JedisPool中获得Jedis的实例即可）
		 5, 书写一个测试类（选用单元测试框架Junit）
		   i)初始化
		   ii)测试
		   iii)资源的释放
   
      pom依赖：
        <!-- redis db server的java客户端之jedis -->
		<dependency>			   				
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.9.0</version>
		 </dependency>

3.2 API操作redis

源码以及效果

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class JedisClientDemo {
    private Jedis jedis;

    @Before
    public void setup() {
        jedis = new Jedis("NODE01", 6379, 2000);
    }

    @Test
    public void testCRUD() {
        //①演示string
        String code = jedis.set("empName", "张三");
        System.out.println("code = " + code);

        String empName = jedis.get("empName");
        System.out.println("员工名是：" + empName);
        System.out.println("\n______________________________________________\n");

        //②演示hash
        //存储一个实例到db中
        Map<String, String> map = new LinkedHashMap<>();
        map.put("name", "李四");
        map.put("age", "18");
        map.put("address", "非洲");
        jedis.hmset("emp", map);

        //取出来
        Map<String, String> result = jedis.hgetAll("emp");
        System.out.println("返回的值是：" + result);
        System.out.println("\n______________________________________________\n");
        
        //②演示list
        //存储
        jedis.lpush("bigdata24","张三","张二","张一","张四");

        //读取
        List<String>  stuNames = jedis.lrange("redis",0,-1);
        System.out.println("名字有："+stuNames);
        System.out.println("\n______________________________________________\n");
        
        //②演示set
        //存储
        jedis.sadd("courseNames","语文","数学","数学","英语");
        //取出
        Set<String> courseNames = jedis.smembers("courseNames");
        System.out.println("课程名是："+courseNames);
        System.out.println("\n______________________________________________\n");
        
        //②演示zset
        //存储
        Map<String,Double> scoreMap = new LinkedHashMap<>();
        scoreMap.put("张三",78D);//int → double（基本数据类型会自动进行类型提升）;   Integer → Double(引用类型不能自动进行转换)
        scoreMap.put("李渊",77D);
        scoreMap.put("刘被",60D);
        jedis.zadd("stuExamScores",scoreMap);
        //读取
        //Set<String> names = jedis.zrange("stuExamScores",0,-1);
        Set<String> names = jedis.zrevrange("stuExamScores",0,-1);
        System.out.println("names = "+names);//刘被 李渊 张三
    }

    @After
    public void cleanUp() {
        if (jedis != null) {
            jedis.close();
        }
    }
}

3.3 使用jedis池进行优化

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class JedisPoolUtil {
    private static JedisPool pool;
    public static Jedis getJedisFromPool() {
        if (pool == null) {//外层的if是为了提高效率
            synchronized (JedisPoolUtil.class) {
                if (pool == null) { //该if是为了保证JedisPool实例的唯一性（单例）
                    JedisPoolConfig config = new JedisPoolConfig();
                    config.setMaxIdle(30);
                    config.setMaxTotal(100);
                    config.setTestOnBorrow(true);
                    pool = new JedisPool(config, "NODE01", 6379);
                }
            }
        }
        return pool.getResource();
    }
    /**
     * 将当前的Jedis实例归还到Jedis池中存储起来
     * @param jedis
     */
    public static void releaseReource(Jedis jedis) {
        if (jedis != null) {
            pool.returnResourceObject(jedis);
        }
    }
}