Redis

目录

Redis简介

安装教程

配置

数据类型

Redis键命令

持久化

事务

安全

Java 使用 Redis（Jedis）

Spring使用Redis（SpringDataRedis）

---

Redis简介

Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)等类型。

安装教程

Windows安装

在https://github.com/MSOpenTech/redis/releases地址下载后解压，打开命令行进入解压目录运行

redis-server.exe redis.conf（省略则使用默认）

出现下图服务就已经启动成功了

Linux安装

在https://redis.io/地址下载最新版

解压

$ tar -xzf redis-4.0.11.tar.gz

进入解压后目录

$ cd redis-4.0.11

编译

$ make

进入src目录启动服务器

$ cd src
$ ./redis-server

配置

Redis 的配置文件位于 Redis 安装目录下，文件名为 redis.conf。

可以通过 CONFIG 命令查看或设置配置项。

redis 127.0.0.1:6379> CONFIG GET CONFIG_SETTING_NAME

数据类型

String（字符串）

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

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

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

redis 127.0.0.1:6379> SET name "123"
OK
redis 127.0.0.1:6379> GET name
"123"

相关命令

SET key value                   设置key=value
GET key                         或者键key对应的值
GETRANGE key start end          得到字符串的子字符串存放在一个键
GETSET key value                设置键的字符串值，并返回旧值
GETBIT key offset               返回存储在键位值的字符串值的偏移
MGET key1 [key2..]              得到所有的给定键的值
SETBIT key offset value         设置或清除该位在存储在键的字符串值偏移
SETEX key seconds value         键到期时设置值
SETNX key value                 设置键的值，只有当该键不存在
SETRANGE key offset value       覆盖字符串的一部分从指定键的偏移
STRLEN key                      得到存储在键的值的长度
MSET key value [key value...]   设置多个键和多个值
MSETNX key value [key value...] 设置多个键多个值，只有在当没有按键的存在时
PSETEX key milliseconds value   设置键的毫秒值和到期时间
INCR key                        增加键的整数值一次
INCRBY key increment            由给定的数量递增键的整数值
INCRBYFLOAT key increment       由给定的数量递增键的浮点值
DECR key                        递减键一次的整数值
DECRBY key decrement            由给定数目递减键的整数值
APPEND key value                追加值到一个键

Hash（哈希）

Redis hash 是一个键值(key=>value)对集合。

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

redis> HMSET myhash field1 "Hello" field2 "World"
"OK"
redis> HGET myhash field1
"Hello"
redis> HGET myhash field2
"World"

相关命令

HDEL key field[field...] 		删除对象的一个或几个属性域，不存在的属性将被忽略

HEXISTS key field 			查看对象是否存在该属性域

HGET key field 				获取对象中该field属性域的值

HGETALL key 				获取对象的所有属性域和值

HINCRBY key field value 		将该对象中指定域的值增加给定的value，原子自增操作，只能是integer的属性值可以使用

HINCRBYFLOAT key field increment 	将该对象中指定域的值增加给定的浮点数

HKEYS key 				获取对象的所有属性字段

HVALS key 				获取对象的所有属性值

HLEN key 				获取对象的所有属性字段的总数

HMGET key field[field...] 		获取对象的一个或多个指定字段的值

HSET key field value 			设置对象指定字段的值

HMSET key field value [field value ...] 同时设置对象中一个或多个字段的值

HSETNX key field value 			只在对象不存在指定的字段时才设置字段的值

HSTRLEN key field 			返回对象指定field的value的字符串长度，如果该对象或者field不存在，返回0.

HSCAN key cursor [MATCH pattern] [COUNT count] 	类似SCAN命令

List（列表）

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

redis 127.0.0.1:6379> lpush test redis
(integer) 1
redis 127.0.0.1:6379> lpush test mongodb
(integer) 2
redis 127.0.0.1:6379> lpush test rabitmq
(integer) 3
redis 127.0.0.1:6379> lrange test 0 10
1) "rabitmq"
2) "mongodb"
3) "redis"
redis 127.0.0.1:6379>

相关命令

BLPOP key1 [key2 ] timeout 取出并获取列表中的第一个元素，或阻塞，直到有可用

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                 修剪列表到指定的范围内

RPOP key                             取出并获取列表中的最后一个元素

RPOPLPUSH source destination         删除最后一个元素的列表，将其附加到另一个列表并返回它

RPUSH key value1 [value2]            添加一个或多个值到列表

RPUSHX key value                     添加一个值列表，仅当列表中存在

Set（集合）

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

添加一个 string 元素到 key 对应的 set 集合中，成功返回1，如果元素已经在集合中返回 0，如果 key 对应的 set 不存在则返回错误。

redis 127.0.0.1:6379> sadd test redis
(integer) 1
redis 127.0.0.1:6379> sadd test mongodb
(integer) 1
redis 127.0.0.1:6379> sadd test rabitmq
(integer) 1
redis 127.0.0.1:6379> sadd test rabitmq
(integer) 0
redis 127.0.0.1:6379> smembers test 1) "redis"
2) "rabitmq"
3) "mongodb"

相关命令

SADD key member [member ...]                 添加一个或者多个元素到集合(set)里

SCARD key                                    获取集合里面的元素数量

SDIFF key [key ...]                          获得队列不存在的元素

SDIFFSTORE destination key [key ...]         获得队列不存在的元素，并存储在一个关键的结果集

SINTER key [key ...]                         获得两个集合的交集

SINTERSTORE destination key [key ...]        获得两个集合的交集，并存储在一个集合中

SISMEMBER key member                         确定一个给定的值是一个集合的成员

SMEMBERS key                                 获取集合里面的所有key

SMOVE source destination member              移动集合里面的一个key到另一个集合

SPOP key [count]                             获取并删除一个集合里面的元素

SRANDMEMBER key [count]                      从集合里面随机获取一个元素

SREM key member [member ...]                 从集合里删除一个或多个元素，不存在的元素会被忽略

SUNION key [key ...]                         添加多个set元素

SUNIONSTORE destination key [key ...]        合并set元素，并将结果存入新的set里面

SSCAN key cursor [MATCH pattern] [COUNT count]迭代set里面的元素

ZSet(有序集合)

Redis zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

添加元素到集合，元素在集合中存在则更新对应score

redis 127.0.0.1:6379> zadd test 0 redis
(integer) 1
redis 127.0.0.1:6379> zadd test 0 mongodb
(integer) 1
redis 127.0.0.1:6379> zadd test 0 rabitmq
(integer) 1
redis 127.0.0.1:6379> zadd test 0 rabitmq
(integer) 0
redis 127.0.0.1:6379> > ZRANGEBYSCORE test 0 1000
1) "mongodb"
2) "rabitmq"
3) "redis"

相关命令

ZADD key score1 member1 [score2 member2]     添加一个或多个成员到有序集合，或者如果它已经存在更新其分数

ZCARD key                                    得到的有序集合成员的数量

ZCOUNT key min max                           计算一个有序集合成员与给定值范围内的分数

ZINCRBY key increment member                 在有序集合增加成员的分数

ZINTERSTORE destination numkeys key [key ...]多重交叉排序集合，并存储生成一个新的键有序集合。

ZLEXCOUNT key min max                        计算一个给定的字典范围之间的有序集合成员的数量

ZRANGE key start stop [WITHSCORES]           由索引返回一个成员范围的有序集合（从低到高）

ZRANGEBYLEX key min max [LIMIT offset count] 返回一个成员范围的有序集合（由字典范围）

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]返回有序集key中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员，有序集成员按 score 值递增(从小到大)次序排列

ZRANK key member                              确定成员的索引中有序集合

ZREM key member [member ...]                  从有序集合中删除一个或多个成员，不存在的成员将被忽略

ZREMRANGEBYLEX key min max                    删除所有成员在给定的字典范围之间的有序集合

ZREMRANGEBYRANK key start stop                在给定的索引之内删除所有成员的有序集合

ZREMRANGEBYSCORE key min max                  在给定的分数之内删除所有成员的有序集合

ZREVRANGE key start stop [WITHSCORES]         返回一个成员范围的有序集合，通过索引，以分数排序，从高分到低分

ZREVRANGEBYSCORE key max min [WITHSCORES]     返回一个成员范围的有序集合，以socre排序从高到低

ZREVRANK key member                           确定一个有序集合成员的索引，以分数排序，从高分到低分

ZSCORE key member                             获取给定成员相关联的分数在一个有序集合

ZUNIONSTORE destination numkeys key [key ...] 添加多个集排序，所得排序集合存储在一个新的键

ZSCAN key cursor [MATCH pattern] [COUNT count]增量迭代排序元素集和相关的分数

Redis键命令

DEL key_name	删除键
DUMP key_name	序列化键，并返回序列化后的值
EXISTS key_name	是否存在键
EXPIPE key_name seconds	设置键过期时间（秒为单位）
EXPIPE key_name timestamp	接受的时间参数是 UNIX 时间戳(unix timestamp)。
PEXPIPE  key_name millseconds	设置键过期时间（豪秒为单位）
PEXPIPE  key_name timestrap	接受的时间参数是 UNIX 时间戳(unix timestamp，毫秒计)。
KEYS pattern	查找所有符合给定模式( pattern)的 key 。
MOVE KEY_NAME DESTINATION_DATABASE	将当前数据库的 key 移动到给定的数据库 db 当中。
PERSIST KEY_NAME	移除给定 key 的过期时间，使得 key 永不过期。
PTTL KEY_NAME	以毫秒为单位返回 key 的剩余过期时间。
TTL KEY_NAME	以秒为单位返回 key 的剩余过期时间。
RANDOMKEY	从当前数据库中随机返回一个 key 。
RENAME OLD_KEY_NAME NEW_KEY_NAME	用于修改 key 的名称 。
RENAMENX OLD_KEY_NAME NEW_KEY_NAME	用于在新的 key 不存在时修改 key 的名称 。
TYPE KEY_NAME	用于返回 key 所储存的值的类型。

持久化

Redis提供了两种持久化方法，一种叫快照（snapshotting），它可以将存在于某一时刻的所有数据都写入硬盘。另一种是只追加文件（append-only file）它会将所有写命令记录在硬盘里。两者可以同时使用。

持久化配置选项

###快照持久化选项

save 60 1000 ###自动快照间隔时长
stop-write-on-bgsave-error ###创建快照失败后是否仍然继续执行写命令
rdbcompression yes ###是否对快照进行压缩
dbfilename dump。rdb ###快照命名


###AOF持久化选项
appendonly no ###是否进行AOF持久化
appendfaync everysec ###自动AOF间隔时长
no-appendfaync-on-rewrite no ###压缩时能否进行同步操作
auto-aof-rewrite-percentage 100 ###相比上一次重写之后体积大于一倍（100%）执行压缩操作
auto-aof-rewrite-min-size 64mb ###体积大于64mb时执行压缩操作


dir ./ ###快照文件和AOF文件保存位置

手动快照的方法

1. 客户端发送BGSAVE命令，Redis会调用fork来创建一个子进程负责写快照，主进程继续处理请求
2. 客户端发送SAVE命令，主进程响应操作，快照创建完毕之前不再响应其它命令，Redis收到SHUTDOWN关闭服务器命令或者接收到标准TERM信号时，也会执行SAVE命令
3. 当一个Redis连接另一个Redis服务器，并向对方发送SYNC命令来开始一次复制操作时，如果主服务器目前没有在执行BGSAVE操作，或者主服务器并非刚刚执行完BGSAVE，那么主服务器会执行BGSAVE命令。

重写/压缩AOF文件

随着Redis不断运行，AOF文件会非常大，这可能会占满硬盘空间和使还原操作执行时间非常长。可以向Redsi发送BGREWRITEAOF命令重写AOF文件。也可以设置auto-aof-rewrite-percentage和auto-aof-rewrite-min-size来自动执行BGREWRITEAOF

复制

复制可以让其他服务器拥有一个不断更新的数据副本，从而使拥有数据副本的服务器可以用于处理客户端发送的读请求。
在启动Redis服务器时，指定一个包含slaveof host port选项的配置文件，Redis服务器就可以根据指定的IP地址和端口号来连接主服务器；需要注意的一点是：在进行同步时，从服务器会清空自己的所有数据而对于一个正在运行的Redis服务器，可以通过发送SLAVEOF no one命令终止复制操作
主从链

从服务器也可以拥有自己的从服务器，形成主从链。
负载不断上升，主服务器可能会无法快速更新所有从服务器，可以创建一个由Redis主从节点组成的中间层来承担主服务器的复制工作

用户首先需要为主服务器设置多个从服务器，然后对每个从服务器设置appendonly yes选项和append everysec选项，这样的话，就可以让多台服务器以每秒一次的频率将数据同步到硬盘上。
验证快照文件和AOF文件
Redis提供了两个命令行程序redis-check-aof和redis-check-dump，故障发生之后，检查AOF文件和快照文件的状态，并在有需要的情况下对文件进行修复。

如果给定--fix参数，将对AOF文件进行修复，扫描AOF文件，发现第一个出错命令时，则删除出错命令及之后的所有命令。而快照文件无法修复，因为经过压缩操作。

事务

Redis 事务可以一次执行多个命令， 并且带有以下三个重要的保证：

1.批量操作在发送 EXEC 命令前被放入队列缓存。

2.收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行。

3.在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。

一个事务从开始到执行会经历以下三个阶段：

1.开始事务。

2.命令入队。

3.执行事务。

redis 127.0.0.1:6379> MULTI
OK

redis 127.0.0.1:6379> SET book-name "Mastering C++ in 21 days"
QUEUED

redis 127.0.0.1:6379> GET book-name
QUEUED

redis 127.0.0.1:6379> SADD tag "C++" "Programming" "Mastering Series"
QUEUED

redis 127.0.0.1:6379> SMEMBERS tag
QUEUED

redis 127.0.0.1:6379> EXEC
1) OK
2) "Mastering C++ in 21 days"
3) (integer) 3
4) 1) "Mastering Series"
   2) "C++"
   3) "Programming"

安全

通过 redis 的配置文件设置密码参数，这样客户端连接到 redis 服务就需要密码验证。默认情况下 requirepass 参数是空的，这就意味着你无需通过密码验证就可以连接到 redis 服务。可以通过以下命令来修改该参数：

127.0.0.1:6379> CONFIG set requirepass "test"
OK

Java 使用 Redis（Jedis）

配置类

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

public class JedisUtils {
	//创建连接池
	private static JedisPoolConfig config;
	private static JedisPool pool;
	
	static{
	config=new JedisPoolConfig();
	//最大连接数, 默认8个
	config.setMaxTotal(30);
	//控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值是8。
	config.setMaxIdle(2);
	//连接超时时是否阻塞，false时报异常,ture阻塞直到超时, 默认true
        config.setBlockWhenExhausted(true);
        //逐出策略（默认DefaultEvictionPolicy(当连接超过最大空闲时间,或连接数超过最大空闲连接数)）
        config.setEvictionPolicyClassName("org.apache.commons.pool2.impl.DefaultEvictionPolicy");
        //获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
        config.setMaxWaitMillis(-1);
        //逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
        config.setMinEvictableIdleTimeMillis(1800000);
        //最小空闲连接数, 默认0
        config.setMinIdle(0);
        //每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
        config.setNumTestsPerEvictionRun(3);
        //对象空闲多久后逐出, 当空闲时间>该值 且 空闲连接>最大空闲数 时直接逐出,不再根据MinEvictableIdleTimeMillis判断  (默认逐出策略)   
        config.setSoftMinEvictableIdleTimeMillis(1800000);
        // 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,
        // 默认-1
        config.setMaxWaitMillis(100);
        //对拿到的connection进行validateObject校验
        config.setTestOnBorrow(true);
        //在进行returnObject对返回的connection进行validateObject校验
        config.setTestOnReturn(true);
        //定时对线程池中空闲的链接进行validateObject校验
        config.setTestWhileIdle(true);

        pool=new JedisPool(config, "127.0.0.1", 6379);
	}
	
	
	//获取连接的方法
	public static Jedis getJedis(){
		return pool.getResource();
	}
	
	
	//释放连接
	public static void closeJedis(Jedis j){
		j.close();
	}
}

测试类

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

import redis.clients.jedis.Jedis;

public class TestRedis {

	public static void main(String[] args) {
		Jedis jedis = JedisUtils.getJedis();
		// redis存储字符串
		// -----添加数据----------
		jedis.set("name", "a");// 向key-->name中放入了value-->xinxin
		System.out.println(jedis.get("name"));// 执行结果：xinxin
		jedis.append("name", " b"); // 拼接
		System.out.println(jedis.get("name"));
		jedis.del("name"); // 删除某个键
		System.out.println(jedis.get("name"));
		// 设置多个键值对
		jedis.mset("name", "zhangsan", "age", "23", "qq", "xxxxxxxxxxx");
		jedis.incr("age"); // 进行加1操作
		System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-" + jedis.get("qq"));

		// redis操作Map
		// -----添加数据----------
		Map map = new HashMap();
		map.put("name", "a");
		map.put("age", "22");
		map.put("qq", "xxxxx");
		jedis.hmset("user", map);
		// 取出user中的name，注意结果是一个泛型的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));
		}

		// jedis操作List
		// 开始前，先移除所有的内容
		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));

		// jedis操作Set
		// 清空数据
		System.out.println(jedis.flushDB());
		// 添加
		jedis.sadd("name", "a");
		jedis.sadd("name", "b");
		jedis.sadd("name", "c");
		jedis.sadd("name", "d");
		jedis.sadd("name", "e");
		// 移除noname
		jedis.srem("name", "c");
		System.out.println(jedis.smembers("name"));// 获取所有加入的value
		System.out.println(jedis.sismember("name", "c"));// 判断 c 是否是user集合的元素
		System.out.println(jedis.srandmember("name")); // 返回集合中的一个随机元素
		System.out.println(jedis.scard("name"));// 返回集合的元素个数

		//// jedis操作ZSet
		jedis.zadd("hackers", 1940, "Alan Kay");
		jedis.zadd("hackers", 1953, "Richard Stallman");
		jedis.zadd("hackers", 1965, "Yukihiro Matsumoto");
		jedis.zadd("hackers", 1916, "Claude Shannon");
		jedis.zadd("hackers", 1969, "Linus Torvalds");
		jedis.zadd("hackers", 1912, "Alan Turing");
		Set setValues = jedis.zrange("hackers", 0, -1);//zset中的所有元素
		System.out.println(setValues);
		Set setValues2 = jedis.zrevrange("hackers", 0, -1);//按分数值递减(从大到小)来排列
		System.out.println(setValues2);
		// 清空数据
		System.out.println(jedis.flushDB());
		// 添加数据
		jedis.zadd("zset", 10.1, "hello");
		jedis.zadd("zset", 10.0, ":");
		jedis.zadd("zset", 9.0, "zset");
		jedis.zadd("zset", 11.0, "zset!");
		// 元素个数
		System.out.println(jedis.zcard("zset"));
		// 元素下标
		System.out.println(jedis.zscore("zset", "zset"));
		// 集合子集
		System.out.println(jedis.zrange("zset", 0, -1));
		// 删除元素
		System.out.println(jedis.zrem("zset", "zset!"));
		System.out.println(jedis.zcount("zset", 9.5, 10.5));
		// 整个集合值
		System.out.println(jedis.zrange("zset", 0, -1));

		JedisUtils.closeJedis(jedis);
	}

}

Spring使用Redis（SpringDataRedis）

配置文件

测试类

package springdataredis;

import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;

public class SpringDataRedisTest {

	static ApplicationContext context;

	public static void main(String[] args) {
		// 加载配置文件
		context = new ClassPathXmlApplicationContext("classpath:application-redis.xml");
		RedisTemplate redisTemplate = (RedisTemplate) context.getBean("redisTemplate");

		// -----------------String类型数据操作 start--------------------
		// String类型数据存储，不设置过期时间，永久性保存
		redisTemplate.boundValueOps("name").set("a");
		// 取值
		String str = (String) redisTemplate.boundValueOps("name").get();
		System.out.println(str);
		// String类型数据存储，设置过期时间为80秒，采用TimeUnit控制时间单位
		redisTemplate.boundValueOps("name").set("a", 80, TimeUnit.SECONDS);
		// 判断key值是否存在，存在则不存储，不存在则存储
		ValueOperations stringOperations = redisTemplate.opsForValue();
		stringOperations.setIfAbsent("string1", "c");
		stringOperations.setIfAbsent("string3", "d");
		String value1 = (String) stringOperations.get("string1");
		String value2 = (String) stringOperations.get("string3");
		System.out.println(value1);
		System.out.println(value2);
		// -----------------String类型数据操作 end--------------------

		// -----------------List数据类型操作 start------------------
		// 右压栈 : 后添加的元素排在后边
		redisTemplate.boundListOps("namelist1").rightPush("刘备");
		redisTemplate.boundListOps("namelist1").rightPush("关羽");
		redisTemplate.boundListOps("namelist1").rightPush("张飞");
		// 显示右压栈的值
		List list = redisTemplate.boundListOps("namelist1").range(0, 10);
		System.out.println(list);
		// 删除键
		redisTemplate.delete("namelist1");
		// 删除键
		redisTemplate.delete("namelist2");
		// 左压栈
		redisTemplate.boundListOps("namelist2").leftPush("刘备");
		redisTemplate.boundListOps("namelist2").leftPush("关羽");
		redisTemplate.boundListOps("namelist2").leftPush("张飞");
		// 删除值
		redisTemplate.boundListOps("namelist2").remove(0, "刘备");
		// 显示左压栈的值
		List list1 = redisTemplate.boundListOps("namelist2").range(0, 10);
		System.out.println(list1);
		// -----------------List数据类型操作 end------------------

		// -----------------set数据类型操作 start------------------
		redisTemplate.boundSetOps("nameset").add("曹操");
		redisTemplate.boundSetOps("nameset").add("刘备");
		redisTemplate.boundSetOps("nameset").add("孙权");
		redisTemplate.boundSetOps("nameset").remove("孙权");
		Set set = redisTemplate.boundSetOps("nameset").members();
		System.out.println(set);
		redisTemplate.delete("nameset");
		// -----------------set数据类型操作 end------------------

		// -----------------zset数据类型操作 start------------------
		ZSetOperations zSetOperations = redisTemplate.opsForZSet();
		zSetOperations.add("zset", "刘备", 0);
		zSetOperations.add("zset", "关羽", 1);
		System.out.println(zSetOperations.rangeByScore("zset", 0, 1));
		// -----------------zset数据类型操作 end------------------

		// -----------------hash数据类型操作 start------------------
		// 存值
		redisTemplate.boundHashOps("namehash").put("a", "唐僧");
		redisTemplate.boundHashOps("namehash").put("b", "悟空");
		redisTemplate.boundHashOps("namehash").put("c", "八戒");
		redisTemplate.boundHashOps("namehash").put("d", "沙僧");
		// 根据KEY取值
		String str1 = (String) redisTemplate.boundHashOps("namehash").get("b");
		System.out.println(str1);
		// 移除某个小key的值
		redisTemplate.boundHashOps("namehash").delete("c");
		// 获取所有的key
		Set keys = redisTemplate.boundHashOps("namehash").keys();
		System.out.println(keys);
		// 获取所有的值
		List list11 = redisTemplate.boundHashOps("namehash").values();
		System.out.println(list11);
		// -----------------hash数据类型操作 start------------------
	}

}