目录
2、使用json工具转换 (string<--->pojo) 进行存取（推荐使用）
方法二：使用set实现（推荐，单条执行语句，可以保证原子性）
一、Redis基本特性
Redis是基于内存的Key-Value型高性能的NoSQL数据库。
为什么说redis能够快速执行？
(1) redis是基于内存的，内存的读写速度非常快（非常快速）
(2) redis采用单线程,避免了不必要的上下文切换线程的时间和竞争条件
(3) redis使用多路复用技术（非阻塞IO - IO多路复用），可以处理并发的连接。非阻塞IO 内部实现采用epoll，采用了epoll+自己实现的简单的事件框架。epoll中的读、写、关闭、连接都转化成了事件，然后利用epoll的多路复用特性，绝不在io上浪费一点时间。
常用命令请参考下列中文手册：
基于键值对的数据结构
Redis的 key 只能是字符串类型
Redis的 value 主要提供了5种数据结构（即5种不同类型的值value）：
- 字符串类型（String）常用
- 散列类型（Hash）常用
- 列表类型（List）
- 集合类型（Set）
- 有序集合类型（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 依赖包：
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.5.0</version>
</dependency>引入后为我们添加了 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只能是字符串类型
详细命令可以查阅：Redis 键(key) | 菜鸟教程
| 命令 | 描述 |
|---|---|
| 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<String> keys = jedis.keys("*");
keys.stream().forEach(System.out::println);
System.out.println("======================");
/**
* 示例2： 相当于执行 keys k?
*/
Set<String> 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
详细命令可以查阅：Redis 字符串(String) | 菜鸟教程
下面是常用命令
| 命令 | 描述 |
|---|---|
| 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 |
Redis存取 Java POJO对象
实现方式有两种：序列化 和 json
个人推荐使用 json 进行传递，因为有很多成熟的 json 依赖包支持（我使用的是fastjson）
1、序列化，反序列化来进行数据的存取（不方便）
写一个序列化反序列化工具：
//对象转byte数组
public static byte [] serializableUtil(Object obj) {
byte[] bytes=null;
try {
ByteArrayOutputStream bais = new ByteArrayOutputStream();
ObjectOutputStream ois = new ObjectOutputStream(bais);
ois.writeObject(obj);
bytes = bais.toByteArray();
ois.close();
bais.close();
return bytes;
} catch (IOException e) {
System.out.print("序列化失败");
}
return bytes;
}
//byte数组转对象
public static Object unSerialzableUtil(byte []bytes){
Object obj=null;
try {
ByteArrayInputStream bais=new ByteArrayInputStream(bytes);
ObjectInputStream ois=new ObjectInputStream(bais);
obj=(Object)ois.readObject();
}catch(Exception e){
e.printStackTrace();
}
return obj;
}
2、使用json工具转换 (string<--->pojo) 进行存取（推荐使用）
通过gson，fastjson这些工具将java对象转换为json字符串,利用json与java对象之间可以相互转换的方式进行存值和取值
我这里使用的是fastjson，详细使用方法可参阅我的另一篇博文：JSON之FastJson开发库
package com.redis.using.pojo;
import com.alibaba.fastjson.JSON;
import com.redis.util.RedisUtil;
import redis.clients.jedis.Jedis;
public class DemoPOJO_JSON {
private final static String REDIS_KEY="users1";
public static void main(String[] args) {
//pojo 对象，初始化的时候已经进行了赋值
UserBean userBean=new UserBean();
Jedis jedis=RedisUtil.getJedis();
jedis.select(2);
//将pojo对象转换为JSON
String s=JSON.toJSONString(userBean);
//存储到Redis
jedis.set(REDIS_KEY, s);
//获取Redis数据
String gString=jedis.get(REDIS_KEY);
//将数据转换为pojo对象
UserBean uBean=JSON.parseObject(gString,UserBean.class);
System.out.println(uBean);
}
}
分布式锁的实现：
分布式锁需要解决的问题
- 互斥性：任意时刻只能有一个客户端拥有锁，不能同时多个客户端获取
- 安全性：锁只能被持有该锁的用户删除，而不能被其他用户删除
- 死锁：获取锁的客户端因为某些原因而宕机，而未能释放锁，其他客户端无法获取此锁，需要有机制来避免该类问题的发生
- 容错：当部分节点宕机，客户端仍能获取锁或者释放锁
Redis因为是单线程的所以有分布式锁的概念
安全性问题
1、设置一个随机字符串
my_random_value是很有必要的，它保证了一个客户端释放的锁必须是自己持有的那个锁。假如获取锁时SET的不是一个随机字符串，而是一个固定值，那么可能会发生下面的执行序列：
- 客户端1获取锁成功。
- 客户端1在某个操作上阻塞了很长时间。
- 过期时间到了，锁自动释放了。
- 客户端2获取到了对应同一个资源的锁。
- 客户端1从阻塞中恢复过来，释放掉了客户端2持有的锁。
之后，客户端2在访问共享资源的时候，就没有锁为它提供保护了。
2、释放锁的操作必须使用Lua脚本来实现。释放锁其实包含三步操作：’GET’、判断和’DEL’，用Lua脚本来实现能保证这三步的原子性。否则，如果把这三步操作放到客户端逻辑中去执行的话，就有可能发生与前面第三个问题类似的执行序列：
- 客户端1获取锁成功。
- 客户端1访问共享资源。
- 客户端1为了释放锁，先执行’GET’操作获取随机字符串的值。
- 客户端1判断随机字符串的值，与预期的值相等。
- 客户端1由于某个原因阻塞住了很长时间。
- 过期时间到了，锁自动释放了。
- 客户端2获取到了对应同一个资源的锁。
- 客户端1从阻塞中恢复过来，执行
DEL操纵，释放掉了客户端2持有的锁。
方法一：使用setnx来实现（不推荐，不能保证原子性）
SETNX key value :如果key不存在,则创建并赋值
- 时间复杂度: 0(1)
- 返回值:设置成功,返回1;设置失败,返回0。
但是此时我们获取的key是长期有效的，所以我们应该如何解决长期有效的问题呢？
如何解决SETNX长期有效的问题
EXPIRE key seconds
- 设置key的生存时间,当key过期时(生存时间为0) ,会被自动删除
- 缺点：原子性得不到满足
//该程序存在危险，如果执行到第二行就崩溃了，则此时key会被一直占用而无法被释放
RedisService redisService = SpringUtils.getBean(Redi sService.class);
long status = redisService.setnx(key, "1");
if(status == 1) {
redisService.expire(key, expire);
//执行独占资源逻辑
doOcuppiedWork();
}
不推荐的原因：
因为这种方式是使用了两条语句，如果在setnx后和expire前，服务宕机了，那么就没有设置失效时间，从而会导致这个KEY一直 处于锁定的状态，这是非原子性的操作
方法二：使用set实现（推荐，单条执行语句，可以保证原子性）
SET key value [EX seconds] [PX milliseconds] [NX|XX]
- EX second :设置键的过期时间为second秒
- PX millisecond :设置键的过期时间为millisecond毫秒
- NX :只在键不存在时,才对键进行设置操作
- XX:只在键已经存在时,才对键进行设置操作
- SET操作成功完成时,返回OK ,否则返回nil
我们可以通过redis的 set(key,value,NX,EX,timeout) 合并普通的 set() 和 expire() 操作，使其具有原子性。
下面是set源码
/**
* Set the string value as value of the key. The string can't be longer than 1073741824 bytes (1
* GB).
* @param key
* @param value
* @param nxxx NX|XX, NX -- Only set the key if it does not already exist. XX -- Only set the key
* if it already exist.
* @param expx EX|PX, expire time units: EX = seconds; PX = milliseconds
* @param time expire time in the units of <code>expx</code>
* @return Status code reply
*/
public String set(final String key, final String value, final String nxxx, final String expx,
final long time) {
checkIsInMultiOrPipeline();
client.set(key, value, nxxx, expx, time);
return client.getStatusCodeReply();
}通过set(key,value,NX,EX,timeout)方法，我们就可以轻松实现分布式锁。值得注意的是这里的value作为客户端锁的唯一标识，不能重复。
public boolean lock1(KeyPrefix prefix, String key, String value, Long lockExpireTimeOut,
Long lockWaitTimeOut) {
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
String realKey = prefix.getPrefix() + key;
Long deadTimeLine = System.currentTimeMillis() + lockWaitTimeOut;
for (;;) {
String result = jedis.set(realKey, value, "NX", "PX", lockExpireTimeOut);
if ("OK".equals(result)) {
return true;
}
lockWaitTimeOut = deadTimeLine - System.currentTimeMillis();
if (lockWaitTimeOut <= 0L) {
return false;
}
}
} catch (Exception ex) {
log.info("lock error");
} finally {
returnToPool(jedis);
}
return false;
}我们可以使用lua脚本合并get()和del()操作，使其具有原子性。一切大功告成。
（个人具体还没有研究 lua 脚本，此处先记录下来）
public boolean unlock1(KeyPrefix prefix, String key, String value) {
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
String realKey = prefix.getPrefix() + key;
String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
Object result = jedis.eval(luaScript, Collections.singletonList(realKey),
Collections.singletonList(value));
if ("1".equals(result)) {
return true;
}
} catch (Exception ex) {
log.info("unlock error");
} finally {
returnToPool(jedis);
}
return false;
}六、散列类型（Hash）（重要）
Hash（哈希）
格式: hmset name key1 value1 key2 value2
Redis hash 是一个键值(key=>value)对集合，KV模式不变，但V是一个键值对（可以想象为：String key,Map<key,value> value）
如果哈希表不存在，一个新的哈希表被创建并进行 HSET 操作。如果字段已经存在于哈希表中，旧值将被覆盖。
Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。
详细命令可以查阅：Redis 哈希(Hash) | 菜鸟教程
下面是常用命令（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 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）
详细命令可以查阅：Redis 列表(List) | 菜鸟教程
格式: 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)。
详细命令可以查阅：Redis 集合(Set) | 菜鸟教程
九、有序集合（SortedSet，简称Zset）
zset(sorted set：有序集合)
格式: zadd name score value
Redis zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。
不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
zset的成员是唯一的,但分数(score)却可以重复。
详细命令可以查阅：Redis 有序集合(sorted set) | 菜鸟教程
十、Java连接Redis增删改查案例
该案例使用了上面的连接池获取 jedis 对象 对数据进行操作
包含了
- 操作字符串
- 操作map集合
- 操作List集合
- 操作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<String,String> map = new HashMap<String,String>();
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<String> 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<String> 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();
}
}
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
