Redis（二）数据类型及基本用法

一、Redis基本特性

Redis是基于内存的Key-Value型高性能的NoSQL数据库。

常用命令请参考下列中文手册：

http://redisdoc.com

https://www.runoob.com/redis/redis-tutorial.html

基于键值对的数据结构

Redis的 key 只能是字符串类型

Redis的 value 主要提供了5种数据结构（即5种不同类型的值value）：

1. 字符串类型（String）常用
2. 散列类型（Hash）常用
3. 列表类型（List）
4. 集合类型（Set）
5. 有序集合类型（SortedSet，简称Zset）

Redis 是通过命令的的方式对数据进行操作的，而在java的开发中我们一般不会直接写命令，而是使用官方提供的一些java依赖包，通过对象的方法进行操作的（这些依赖包已经将命令封装起来了）

更好的是这些依赖包操作方法的名字和命令关键字大多都一样（作用也相同），所以这样我们一般记住一方的操作名称就行了，基本不用背两套方式了

（我练习的demo是使用 jedis.jar来操作 Redis，我的案例是java main 直接执行的）

如果你的开发环境使用springboot或其他，网上查一下就知道使用什么依赖了，我猜想操作方法名应该都一样

 

Redis数据库的操作

Redis每个数据库对外都是0开始递增的数字来命名，默认16个数据库，默认使用0号数据库

Redis不支持自定义数据库名字，默认是： 0、1、2、3、4 ... 15

Redis不支持为每个数据库设置不同的访问密码

多个数据库之间并不是完全独立的，可以使用命令：FlushAll，清空 Redis 全部的数据

命令	描述
select	来选择切换的数据库 例：select 目标数据库编号
dbsize	查看当前数据库的key的数量 例：dbsize
move	在多个数据库间移动数据 例：move key 目标数据库编号
flushdb	清除当前数据库的数据 例：flushdb

 

二、Redis 入门操作（demo）

我们在java开发过程中一般不会写直接写命令Redis，而是通过 jedis  这个依赖包来和 Redis 进行交互的 

通过 jedis 对象进行对 Redis 数据的操作 

需要引入jedis 依赖包：

    redis.clients
    jedis
    2.5.0

引入后为我们添加了 jedis 和 连接池 两个依赖

下面是 java 代码 

package com.redis.util;

import redis.clients.jedis.Jedis;

public class RedisDemo {

	public static void main(String[] args) {
	       //连接本地的 Redis 服务(地址和端口号)
	       Jedis jedis = new Jedis("localhost",6379);
	       System.out.println("连接成功");
	       //查看服务是否运行
	       System.out.println("服务正在运行: "+jedis.ping());
	       
	       testString(jedis);
	}
	
	/**
     * redis操作字符串
     */
    public static void testString(Jedis jedis) {
        //添加数据
        jedis.set("name", "youcong");
        System.out.println("添加数据操作："+jedis.get("name"));
        
        //拼接字符串
        jedis.append("name", ".com");
        System.out.println("拼接字符串操作："+jedis.get("name"));
        
        //删除数据
        jedis.del("name");
        System.out.println("删除数据操作："+jedis.get("name"));
        
        //设置多个键值对
        jedis.mset("name","yc","age","22","qq","1933108196");
        jedis.incr("age");//加1操作
        System.out.println("设置多个键值对操作："+jedis.get("name") + "-" + jedis.get("age") + "-" +jedis.get("qq"));
    }
}

 

三、连接池配置

1、创建 util 连接池类

JedisPoolConfig ：是连接池的配置对象，在这里为连接池配置信息

例：JedisPoolConfig config = new JedisPoolConfig();

JedisPool ：是连接池对象，引入config和一些基本连接信息

jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT);

Jedis ：是我们真正对Redis数据操作的对象，通过getResource()方法从连接池中获取

Jedis resource = jedisPool.getResource();

 

package com.redis.util;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisUtil {
	// 服务器IP地址
	private static String ADDR = "localhost";
	// 端口
	private static int PORT = 6379;
	// 密码（如果没有设置可不配置）
	// private static String PASSWORD = "123456";
	// 连接实例的最大连接数
	private static int MAX_ACTIVE = 50;
	// 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例(连接数)，默认值也是8。
	private static int MAX_IDLE = 10;
	// 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException
	private static int MAX_WAIT = 10000;
	// 连接超时的时间
	private static int TIMEOUT = 10000;
	// 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
	private static boolean TEST_ON_BORROW = true;

	private static JedisPool jedisPool = null;

	/**
	 * 初始化Redis连接池
	 */
	static {
		try {

			JedisPoolConfig config = new JedisPoolConfig();
			config.setMaxTotal(MAX_ACTIVE);
			config.setMaxIdle(MAX_IDLE);
			config.setMaxWaitMillis(MAX_WAIT);
			config.setTestOnBorrow(TEST_ON_BORROW);
			// jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, PASSWORD);//我没有设置连接密码
			jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	/**
	 * 获取Jedis实例
	 */
	public synchronized static Jedis getJedis() {
		try {
			if (jedisPool != null) {
				//从连接池中获取一个对象
				Jedis resource = jedisPool.getResource();
				return resource;
			} else {
				return null;
			}
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
	/***
	 * 
	 * 释放资源
	 */
	public static void returnResource(final Jedis jedis) {
		if (jedis != null) {
			jedisPool.returnResource(jedis);
		}
	}
}

2、java main方法通过连接池获取 jedis 对象进行操作

package com.redis.util;

import redis.clients.jedis.Jedis;

public class RedisDemo2 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Jedis jedis=RedisUtil.getJedis();
		System.out.println("服务正在运行: "+jedis.ping());
		System.out.println("获取当前存储数据的个数: "+jedis.dbSize());
	}
}

四、Redis的keys通用操作（重要）

Redis的key只能是字符串类型

详细命令可以查阅：https://www.runoob.com/redis/redis-keys.html

命令	描述
keys	获取符合规则的键名列表 格式是keys pattern, pattern支持glob风格通配符格式 ？  匹配一个字符（例：keys a? 得到 a 开头连个字符的 key） *    匹配任意字符（例：keys a* 得到 a 开头的所有key） [ ]  匹配中括号内的任意字符，可以用“-”来表示范围（例：keys k[1-3] 得到 k1、k2、k3） \x  匹配字符x，用于转义符号
exists	检查给定 key 是否存在，存在返回1，不存在返回0 格式：exists key
del	删除key 格式：del key
type	返回 key 所储存的值的类型 格式：type key
rename	修改key名 格式： rename oldKey newKey
renamenx	如果新名不存在则改名（这里不存在是指，newKey不存在） 格式：renamex oldKey newKey
ttl	以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live) 当 key 不存在时，返回 -2 当 key 存在但没有设置剩余生存时间时，返回 -1 否则，以秒为单位，返回 key 的剩余生存时间 格式：ttl key
expire	为给定 key 设置过期时间，以秒计 格式：expire key seconde
persist	移除 key 的过期时间，key 将持久保持 格式：persist key

import redis.clients.jedis.Jedis;

import java.util.Set;

/**
 * redis的key操作示例
 */
public class RedisKeyOperate {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1",6379);

        /**
         * 示例1： 相当于执行 keys *
         */
        Set keys = jedis.keys("*");
        keys.stream().forEach(System.out::println);
        System.out.println("======================");

        /**
         * 示例2：  相当于执行  keys k?
         */
        Set keys1 = jedis.keys("k?");
        keys1.stream().forEach(System.out::println);
        System.out.println("======================");

        /**
         * 示例3： 相当于执行  exists k1
         */
        Boolean existsKey = jedis.exists("k1");
        System.out.println("existsKey = " + existsKey);
        System.out.println("======================");

        /**
         * 示例4： 相当于执行 del k1
         */
        Long delK1 = jedis.del("k1");
        System.out.println("delK1 = " + delK1);
        System.out.println("======================");

        /**
         * 示例5： 相当于执行 type k2
         */
        String typeK2 = jedis.type("k2");
        System.out.println("typek2 = " + typeK2);
        System.out.println("======================");


        /**
         * 示例6： 相当于执行 rename k2 k22
         */
        String renameK2 = jedis.rename("k2", "k22");
        System.out.println("renameK2 = " + renameK2);
        System.out.println("======================");

        /**
         * 示例7: 相当于执行 renamenx t1 t11
         */
        Long renamenxt1 = jedis.renamenx("t1", "t11");
        System.out.println("renamenxt1 = "+renamenxt1);
    }
}

 

五、字符串类型（String）（重要）

String字符串：

格式: set key value

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

string类型是Redis最基本的数据类型，一个键最大能存储512MB

详细命令可以查阅：https://www.runoob.com/redis/redis-strings.html

下面是常用命令

命令	描述
get、set、del	获取key的值、设置key的值、删除key的值 格式： GET key SET key value DEL key
append	如果 key 已经存在并且是一个字符串， APPEND 命令将指定的 value 追加到该 key 原来值（value）的末尾 格式：append key值 追加的值
strlen	返回键值的长度 格式：strlen key值
incr、decr	递增和递减整数值，增减1 格式 ：incr key值
incrby、dcrby	递增和递减整数值，可指定增减的数值 格式 ：incrby key值 正负数值
getrange	获取指定范围内的值 格式：getrange key值 起始索引 结束索引
setrange	从索引位置开始设置后面的值， 格式：setrange key值 offset索引 值
setex(set with expore)	将值 value 关联到 key ，并将 key 的过期时间设为 seconds (以秒为单位) 格式：SETEX key seconds value
setnx(set if not exist)	（可实现分布式锁） 只有在 key 不存在时设置 key 的值才会生效，key存在将不会存储或替换KEY值 成功返回1，失败返回0 格式：SETNX key value
mset、mget	同时设置一个或多个 key-value 对 格式：MSET key1 "Hello" key2 "World" 获取所有(一个或多个)给定 key 的值 格式：mget key1 key2
msetnx	同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在时才能存储成功，否则全部存不进去 格式：MSETNX key1 value1 key2 value2 .. keyN valueN
getset	将给定 key 的值设为 value ，并返回 key 的旧值(old value) 格式：GETSET key_name value

 

六、散列类型（Hash）（重要）

Hash（哈希）

格式: hmset name  key1 value1 key2 value2

Redis hash 是一个键值(key=>value)对集合，KV模式不变，但V是一个键值对（可以想象为：String key,Map value）

如果哈希表不存在，一个新的哈希表被创建并进行 HSET 操作。如果字段已经存在于哈希表中，旧值将被覆盖。

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

详细命令可以查阅：https://www.runoob.com/redis/redis-hashes.html

下面是常用命令（hash的命令很好区分，都是H开头的）

命令	描述
hset、hget	设置单个值 格式：hset key field value 获取单个值 格式：hget key field
hmset、hmget	同时将多个 field-value (域-值)对设置到哈希表 key 中。 格式：HMSET key field1 value1 [field2 value2 ]  获取所有给定字段的值 格式：HMGET key field1 [field2]
hdel	删除一个或多个哈希表字段 格式：hdel key field1 [field2]
hgetall	获取在哈希表中指定 key 的所有 字段 和 值 格式：hgetall key
hlen	获取哈希表中字段的数量 格式：hlen key
hkeys、hvals	获取所有哈希表中的字段(field) 格式：hkeys key 获取哈希表中所有值(value) 格式：hvals key
hexists	查看哈希表 key 中，指定的字段是否存在。 如果哈希表含有给定字段，返回 1 。 如果哈希表不含有给定字段，或 key 不存在，返回 0  格式：hexists key field
hincrby	为哈希表 key 中的指定字段的整数值加上增量 increment  格式：HINCRBY key field increment
hincrbyfloat	为哈希表 key 中的指定字段的浮点数值加上增量 increment  格式：HINCRBYFLOAT key field increment
hsetnx	只有在字段 field 不存在时，设置哈希表字段的值 格式：HSETNX key field value

 

七、列表类型（List）

List（列表）

注意：list都是栈结构，先进后出；list的值可以重复

Left push：左开始进

Right push：右开始进（出的和写的顺序一样）

底层实现上不是数组，而是链表，也就是说头部和尾部插入一个新元素，其时间复杂度是常数级别的；其弊端是：元素的定位比数组慢

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

详细命令可以查阅：https://www.runoob.com/redis/redis-lists.html

格式: lpush  name  value

在 key 对应 list 的头部添加字符串元素

格式: rpush  name  value

在 key 对应 list 的尾部添加字符串元素

格式: lrem name  index

key 对应 list 中删除 count 个和 value 相同的元素

格式: llen name

返回 key 对应 list 的长度

 

八、集合类型（Set）

Set（集合）

格式: sadd  name  value

Redis的Set是string类型的无序集合。

集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。

详细命令可以查阅：https://www.runoob.com/redis/redis-sets.html

 

九、有序集合（SortedSet，简称Zset）

zset(sorted set：有序集合)

格式: zadd  name score value

Redis zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。

不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

zset的成员是唯一的,但分数(score)却可以重复。

详细命令可以查阅：https://www.runoob.com/redis/redis-sorted-sets.html

 

十、Java连接Redis增删改查案例

该案例使用了上面的连接池获取 jedis 对象 对数据进行操作

包含了

1. 操作字符串
2. 操作map集合
3. 操作List集合
4. 操作set集合

package com.demo.redis;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import redis.clients.jedis.Jedis;

public class TestRedis {

    private Jedis jedis;
    
    /**
     * 连接redis服务器
     */
    public void connectRedis() {
        jedis=RedisUtil.getJedis();
    }
    
    /**
     * redis操作字符串
     */
    public void testString() {
        //添加数据
        jedis.set("name", "youcong");
        System.out.println(jedis.get("name"));
        
        //拼接字符串
        jedis.append("name", ".com");
        System.out.println(jedis.get("name"));
        
        //删除数据
        jedis.del("name");
        System.out.println(jedis.get("name"));
        
        //设置多个键值对
        jedis.mset("name","yc","age","22","qq","1933108196");
        jedis.incr("age");//加1操作
        System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-" +jedis.get("qq"));
    }
    
    
    /**
     * redis操作map集合
     */
    public void testMap() {
        //添加数据
        Map map = new HashMap();
        
        map.put("name", "yc");
        map.put("age", "22");
        map.put("qq", "1933108196");
        jedis.hmset("user", map);
        
        //取出users中的Name,执行结果:[minxr]-->注意结果是一个泛型的List
        //第一个参数是存入redis中map对象的key,后面跟的是放入map中对象的key,后面的key可以是多个，是可变的
        List rsmap = jedis.hmget("user", "name","age","qq");
        System.out.println(rsmap);
        
    
        //删除map中的某个键值
        jedis.hdel("user", "age");
        System.out.println(jedis.hmget("user", "age"));//因为删除了，所以返回的是Null
        System.out.println(jedis.hlen("user"));//返回key为user的键中存放的值的个数2
        System.out.println(jedis.exists("user"));//是否存在key为user的记录，返回true
        System.out.println(jedis.hkeys("user"));//返回map对象中的所有key
        System.out.println(jedis.hvals("user"));//返回map对象中的所有value
        
        Iterator iter = jedis.hkeys("user").iterator();
        while(iter.hasNext()) {
            String key = iter.next();
            System.out.println(key+":" + jedis.hmget("user", key));
        }
    }
    
    /**
     * redis操作List集合
     */
    public void testList() {
        //开始前，先移除所有的内容
        jedis.del("java framework");
        System.out.println(jedis.lrange("java framework", 0, -1));
        
        //先向key java framework 中存放三条数据
        jedis.lpush("java framework","spring");
        jedis.lpush("java framework", "struts");
        jedis.lpush("java framework", "hibernate");
        
        //再取出所有数据jedis.lrange是按范围取出
        //第一个是key,第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有
        System.out.println(jedis.lrange("java framework", 0, -1));
        
        jedis.del("java framework");
        jedis.rpush("java framework", "spring");
        jedis.rpush("java framework", "struts");
        jedis.rpush("java framework","hibernate");
        System.out.println(jedis.lrange("java framework", 0, -1));
    }
    
    
    /**
     * redis操作set集合
     * 
     */
    public void testSet() {
        
        //添加
        jedis.sadd("user", "liuling");
        jedis.sadd("user", "xinxin");
        jedis.sadd("user","ling");
        jedis.sadd("user", "zhangxinxin");
        jedis.sadd("user", "who");
        
        //删除
        jedis.srem("user", "who");
        System.out.println(jedis.smembers("user"));//获取所有加入的value
        System.out.println(jedis.sismember("user", "who"));//判断who是否是user集合的元素
        System.out.println(jedis.srandmember("user"));
        System.out.println(jedis.scard("user"));//返回集合的元素个数
    }
    
    
    /**
     * redis排序
     */
    
    public void testSort() {
        //jedis 排序
        //注意，此处的rpush和lpush是List的操作。是一个双向链表（但从表现来看的)
        jedis.del("a");//先清除数据，再加入数据进行测试
        jedis.rpush("a", "1");
        jedis.lpush("a", "6");
        jedis.lpush("a", "3");
        jedis.lpush("a", "9");
        System.out.println(jedis.lrange("a", 0, -1));
        System.out.println(jedis.sort("a"));//[1,3,6,9] //输入排序后结果
        System.out.println(jedis.lrange("a", 0, -1));
    }
    
    
    /**
     * redis连接池
     */
    public void testRedisPool() {
        RedisUtil.getJedis().set("newname", "test");
        System.out.println(RedisUtil.getJedis().get("newname"));
    }
    
    public static void main(String[] args) {
        TestRedis test = new TestRedis();
        test.connectRedis();
        test.testSort();
    }
}