redis常用操作总结

    最近在工作中用到了redis,涉及到redis的入库,访问,以及对于集群的一些操作. 为了防止遗忘,特别把当时的使用情况总结一下

redis使用总结

一.redis简介

以下来自 redis官网
Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache and message broker. 
Redis has built-in replication, Lua scripting, LRU eviction, transactions and different levels of on-disk persistence, and provides high availability via Redis Sentinel and automatic partitioning with Redis Cluster

翻译: 
Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 
它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。 
Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）。

个人使用感觉:
最大的好处就是快!写入效率,读取速度都很快!
shell脚本界面很友好,当输入关键字后,还会有提示告诉我们应该怎样操作
缺点就是集群稳定性不高 : 用多线程写数据时,写入速度超过某个范围就写不过来了...会导致很多数据写入失败

二.linux操作redis

以下的示例都是用测试机器,端口为7001-7006  
或者是正式的集群,端口号为默认的6379来进行操作

1. redis服务端启动

  如果没有配置好path,需要到redis安装目录下面的bin目录执行 :

a. 默认方式启动redis

	./redis-server & //后台启动redis  

b. 指定配置文件启动redis

	./redis-server 配置文件所在的目录/配置文件名  //这种方式会按照配置文件里面的配置来启动redis

检验redis是否启动成功:

	ps -ef | grep 端口号 //端口号指的是redis端口号
	举例 : ps -ef | grep 7001

	另一种方法:
	lsof -i:端口号
	举例 : lsof -i:7001

如上: 证明redis已经成功启动!

2.redis客户端连接

同样,如果没有配置好path,需要到客户端的bin目录下执行命令: 

a.免密连接(集群没有配置密码)

	./redis-cli -c -h 主机名(ip) -p 端口号 // 无密码

b. 需要密码的连接

./redis-cil -c -h 主机名(ip) -p 端口号 -a  密码

3. 为redis分配hash槽

先来对redis的hash槽做一个基本的介绍:
 Redis 集群中内置了 16384 个哈希槽，当需要在 Redis 集群中放置一个 key-value时，
 redis 先对 key 使用 crc16 算法算出一个结果，然后把结果对 16384 取模.
这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽，redis 会根据节点数量大致均等的将哈希槽映射到不同的节点。

crc 16 算法实现:

    unsigned int keyHashSlot(char *key, int keylen) {  #
        int s, e; /* start-end indexes of { and } */
     
        for (s = 0; s < keylen; s++)
            if (key[s] == '{') break;
     
        /* No '{' ? Hash the whole key. This is the base case. */
        if (s == keylen) return crc16(key,keylen) & 0x3FFF;
     
        /* '{' found? Check if we have the corresponding '}'. */
        for (e = s+1; e < keylen; e++)
            if (key[e] == '}') break;
     
        /* No '}' or nothing betweeen {} ? Hash the whole key. */
        if (e == keylen || e == s+1) return crc16(key,keylen) & 0x3FFF;
     
        /* If we are here there is both a { and a } on its right. Hash
         * what is in the middle between { and }. */
        return crc16(key+s+1,e-s-1) & 0x3FFF;
    }

假设 : redis节点的数量为N, 那么为保证数据不发生倾斜, 每个节点应该分配hash槽的数量是 16384/N
有了这个分区的思路,开始对节点进行hash槽的分配

	分配命令: 
	redis-cli -c -h  主机名(ip地址) -p 端口号 -a 集群密码 cluster addslots {起始hash槽..结束hash槽} 	
	该命令表示 : 将起始hash槽到结束hash槽分配给指定的节点
	举例 :
		 redis-cli -c -h 10.182.26.195 -p 6379 -a 集群密码 xxxx addslots {0..5461}
		 redis-cli -c -h 10.182.26.196 -p 6379 -a 集群密码 xxxx addslots {5462..10922}
		 redis-cli -c -h 10.182.26.197 -p 6379 -a 集群密码 xxxx addslots {10923..16383}

分配之后的结果:
使用 cluster nodes命令查看:

cluster nodes命令详解:

（该命令的）输出是空格分割的CSV字符串，每行代表集群中的一个节点。
每行的组成结构如下 : <id> <ip:port> <flags> <master> <ping-sent> <pong-recv> <config-epoch> <link-state> <slot> <slot> ... <slot>

每项的含义如下:

    id: 节点ID,是一个40字节的随机字符串，这个值在节点启动的时候创建，并且永远不会改变（除非使用CLUSTER RESET HARD命令）。
    ip:port: 客户端与节点通信使用的地址.
    flags: 逗号分割的标记位，可能的值有: myself, master, slave, fail?, fail, handshake, noaddr, noflags. 下一部分将详细介绍这些标记.
    master: 如果节点是slave，并且已知master节点，则这里列出master节点ID,否则的话这里列出”-“。
    ping-sent: 最近一次发送ping的时间，这个时间是一个unix毫秒时间戳，0代表没有发送过.
    pong-recv: 最近一次收到pong的时间，使用unix时间戳表示.
    config-epoch: 节点的epoch值（or of the current master if the node is a slave）。每当节点发生失败切换时，都会创建一个新的，独特的，递增的epoch。如果多个节点竞争同一个哈希槽时，epoch值更高的节点会抢夺到。
    link-state: node-to-node集群总线使用的链接的状态，我们使用这个链接与集群中其他节点进行通信.值可以是 connected 和 disconnected.
    slot: 哈希槽值或者一个哈希槽范围. 从第9个参数开始，后面最多可能有16384个 数(limit never reached)。代表当前节点可以提供服务的所有哈希槽值。如果只是一个值,那就是只有一个槽会被使用。如果是一个范围，这个值表示为起始槽-结束槽，节点将处理包括起始槽和结束槽在内的所有哈希槽。

从上述的结果可以看到,hash槽已经完美的分配!

4. 查看集群重要的信息

命令 : cluster info
结果如下: 

每项的含义如下:

id: 节点ID,是一个40字节的随机字符串，这个值在节点启动的时候创建，并且永远不会改变（除非使用CLUSTER RESET HARD命令）。
ip:port: 客户端与节点通信使用的地址.
flags: 逗号分割的标记位，可能的值有: myself, master, slave, fail?, fail, handshake, noaddr, noflags. 下一部分将详细介绍这些标记.
master: 如果节点是slave，并且已知master节点，则这里列出master节点ID,否则的话这里列出”-“。
ping-sent: 最近一次发送ping的时间，这个时间是一个unix毫秒时间戳，0代表没有发送过.
pong-recv: 最近一次收到pong的时间，使用unix时间戳表示.
config-epoch: 节点的epoch值（or of the current master if the node is a slave）。每当节点发生失败切换时，都会创建一个新的，独特的，递增的epoch。如果多个节点竞争同一个哈希槽时，epoch值更高的节点会抢夺到。
link-state: node-to-node集群总线使用的链接的状态，我们使用这个链接与集群中其他节点进行通信.值可以是 connected 和 disconnected.
slot: 哈希槽值或者一个哈希槽范围. 从第9个参数开始，后面最多可能有16384个 数(limit never reached)。代表当前节点可以提供服务的所有哈希槽值。如果只是一个值,那就是只有一个槽会被使用。如果是一个范围，这个值表示为起始槽-结束槽，节点将处理包括起始槽和结束槽在内的所有哈希槽。

5.redis的其它操作

a. 清空节点全部数据! (慎用!!)

flushall  //从删库到跑路的第一步

b. 查看节点全部的key

命令 : keys *

从上面可以看出 : 当前节点存储了 83461个key的数据

c. 向节点添加键值对数据

set key(键) value(值)
 举例 : set name libai //设置键为name ,value为libai
 get key(键) // 获得某个键的值
 举例 : get name 

d.删除节点中某个键的数据

del key(键) 
举例 : del name

e.查询某个节点占用资源情况

info memory

三. 通过java使用redis

1. maven导入redis依赖

	在 <dependencies></dependencies> 标签里面添加:
	<dependency>
	            <groupId>redis.clients</groupId>
	            <artifactId>jedis</artifactId>
	            <version>2.9.0</version>
	            <type>jar</type>
	            <scope>compile</scope>
	</dependency>
	<dependency>
	            <groupId>org.apache.commons</groupId>
	            <artifactId>commons-pool2</artifactId>
	            <version>2.4.2</version>
	</dependency>
	如果在打jar包的时候希望把redis相关的依赖打进jar包里
	需要在pom.xml 添加上类似的配置
	   <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                        	<!-- 自动将所有不使用的类全部排除掉 -->
                        	<minimizeJar>false</minimizeJar>
                            <transformers>
                                <transformer
               implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>cn.mastercom.bigdata.test.RedisTest</mainClass>
                                </transformer>
                            </transformers>
							<artifactSet>
								<includes>
									<include>org.apache.commons:commons-pool2</include>
									<include>redis*</include>
								</includes>
							</artifactSet>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

2. 使用java获取redis连接

	首先写一个获取redis连接的工具类 : 
	
	import java.util.HashSet;
	import java.util.Set;
	
	import redis.clients.jedis.HostAndPort;
	import redis.clients.jedis.JedisCluster;
	import redis.clients.jedis.JedisPoolConfig;
	
	/**
	 * 获取redis连接的工具类
	 * @author xmr
	 *
	 */
	public class JedisClusterFactory 
	{
		private static JedisCluster jc = null;
		private static HostAndPort [] hostAndPort;
		private final static String SPLIT = ","; 
		
	    private static class InstanceHolder 
	    {
	        private static final JedisClusterFactory instance = new JedisClusterFactory();
	    }
	
	    public static JedisClusterFactory getInstance() 
	    {
	        return InstanceHolder.instance;
	    }
	    public static void main(String[] args) 
	    {
	    	
		}
	    /**		
	     * 获取redis连接
	     * @param redisConfig
	     * @param timeOut
	     * @param password
	     * @return
	     */
	    public JedisCluster getJedisCluster(String redisConfig, int timeOut, String password) 
	    {
	    	if (jc != null)
	    	{
	    		return jc;
	    	}
	    	
	    	String [] strs = redisConfig.split(SPLIT);
	    	hostAndPort = new HostAndPort[strs.length];
	    	for (int i = 0; i < strs.length; i++)
	    	{
	    		hostAndPort[i] = new HostAndPort(strs[i].split(":")[0], Integer.valueOf(strs[i].split(":")[1]));
	    	}
	    	
	        Set<HostAndPort> hostAndPorts = new HashSet<HostAndPort>();
	        for (int i = 0; i < strs.length; i++)
	        {
	        	hostAndPorts.add(hostAndPort[i]);
	        }
	
	        JedisPoolConfig config = new JedisPoolConfig();
	        jc = new JedisCluster(hostAndPorts, timeOut, 0, 30, password, config);
	        return jc;
	}

**使用方法, 在该类或者是任意一个类的main方法里面添加如下代码 : **

	  public static void main(String[] args) 
		{
			JedisCluster jc  = JedisClusterFactory.getInstance().getJedisCluster(args[0], 10000, args[1]);
			// args[0] 是集群的节点和端口号  形如: 10.182.26.195:6379,10.182.26.196:6379,10.182.26.197:6379  注意: 这里必须是集群的全部节点,少输入或者是输错一个,都会导致连接失败!
			// args[1] 是redis集群的密码		
		}

3. 使用java将数据写入redis

	/**
	     * 将文件保存到redis,以key作为文件名
	     * @param jc 
	     * @param f
	     */
	    public static void saveFileToRedis(JedisCluster jc, File f) {
	
	        try (FileInputStream fis = new FileInputStream(f);
	             ByteArrayOutputStream baos = new ByteArrayOutputStream();
	        ) {
	
	            IOUtils.copy(fis, baos);
	
	            byte[] value = baos.toByteArray();
	
	                jc.set((f.getName(), value);
	
	        } catch (IOException e) {
	//            log.error("保存文件到redis出现问题", e);
	        }
	    }
	
	调用办法 : 
	public static void main(String[] args) 
	{
		JedisCluster jc  = JedisClusterFactory.getInstance().getJedisCluster(args[0], 10000, args[1]); //获取redis连接
		 File f = new File("C:\\Users\\DELL\\Desktop\\SIMU\\FINGERPRINT_OUT_163366914.txt.gz"); // 获取file流
        saveFileToRedis(jc, f); // 将文件写入redis
	}

去redis里面使用 get FINGERPRINT_OUT_163366914.txt.gz 命令 查看我们刚刚入库的数据

  从结果中可以看到:
  上述代码的写入方式是以key为文件名, 以文件的二进制内容作为值
  为什么要采用这种方式呢?
  因为写入的是.gz的压缩文件,用这种方式可以节约redis的内存占用,毕竟内存这种东西实在是太昂贵了!! 浪费不起啊!!!

4. 使用java读取入库后的文件

  这里我写了两个方法  : 第一个方法是得到一个可以读取这种数据的BufferedReader流
  第二个方法通过我获得的这个流 去读取数据,输出结果: 

	  两个方法如下 :
	  
	  /**
	     * 从redis集群中加载GZ文件并解压缩，返回一个BufferedReader
	     *
	     * @param jc  jedisCluster对象
	     * @param key 文件名
	     * @return BufferedReader对象或<tt>NULL</tt>
	     */
	    public static BufferedReader loadsAndUnzipFileFromRedis(JedisCluster jc, String key) {
	        assert jc != null;
	        assert key != null && key.length() != 0;

	        byte[] bytes = jc.get(key.getBytes());

	        ByteArrayInputStream bais = null;
	        GZIPInputStream gzis = null;
	        InputStreamReader isr = null;
            try {
            	bais = new ByteArrayInputStream(bytes);
            	gzis = new GZIPInputStream(bais);
            	isr = new InputStreamReader(gzis);
	            return new BufferedReader(isr);
            } catch (IOException e) {
            	log.error("创建BufferedReader出现异常", e);
				try	
				{
					if (bais != null) 
						bais.close();
				} 
				catch (Exception e0) 
				{ 
					
				}
            	return null;
            }

	}

	/**
	 * 通过BufferedReader流读取入库数据
	 * just for test
	 * @param br
	 */
	private static void readSimuConfig(BufferedReader br) {
		if (br == null) 
		{
			System.out.println("没有获取到bufferedReader! 请检查! ");
			return;
		}

		try {
			while ((br.readLine()) != null)
			{
				String sline = br.readLine();
				System.out.println(sline);
			}
			
		} catch (Exception ee){
			System.out.println("读取key失败! ");
		}
		finally 
		{
			if(br != null)
			{
				try {
					br.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	
	调用方法 : 
	public static void main(String[] args) 
	{
		
		JedisCluster jc  = JedisClusterFactory.getInstance().getJedisCluster(args[0], 10000, args[1]); // 获取redis连接
		String rowkey = args[2]; //获取行键 
		BufferedReader br = RedisUtil.loadsAndUnzipFileFromRedis(jc, rowkey); //获取BufferedReader流
		readSimuConfig(br); //读取并输出数据
		
	}

args 参数如下图所示 :

部分输出结果:

可以证明 : 入库,读取都能够成功! 

四.参考链接:

redis中文官网
redis官网