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

Marvin-Fox

已于 2023-01-09 09:53:02 修改

阅读量850

点赞数

分类专栏：分布式、微服务系列 Tools 文章标签： redis 数据库 java

于 2019-09-11 23:45:31 首次发布

本文链接：https://blog.csdn.net/fox_bert/article/details/100752982

版权

分布式、微服务系列同时被 2 个专栏收录

26 篇文章 7 订阅

订阅专栏

Tools

19 篇文章 0 订阅

订阅专栏

1、序列化，反序列化来进行数据的存取（不方便）

2、使用json工具转换 (string<--->pojo) 进行存取（推荐使用）

分布式锁的实现：

方法一：使用setnx来实现（不推荐，不能保证原子性）

方法二：使用set实现（推荐，单条执行语句，可以保证原子性）

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

七、列表类型（List）

八、集合类型（Set）

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

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

一、Redis基本特性

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

为什么说redis能够快速执行？

(1) redis是基于内存的，内存的读写速度非常快（非常快速）

(2) redis采用单线程,避免了不必要的上下文切换线程的时间和竞争条件

(3) redis使用多路复用技术（非阻塞IO - IO多路复用），可以处理并发的连接。非阻塞IO 内部实现采用epoll，采用了epoll+自己实现的简单的事件框架。epoll中的读、写、关闭、连接都转化成了事件，然后利用epoll的多路复用特性，绝不在io上浪费一点时间。

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

Redis 命令参考 — Redis 命令参考

Redis 教程 | 菜鸟教程

基于键值对的数据结构

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();
    }
}

Marvin-Fox

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Redis（二）数据类型及基本用法

一、Redis基本特性Redis是基于内存的Key-Value型高性能的NoSQL数据库。为什么说redis能够快速执行？(1) redis是基于内存的，内存的读写速度非常快（非常快速）(2) redis采用单线程,避免了不必要的上下文切换线程的时间和竞争条件(3) redis使用多路复用技术（非阻塞IO - IO多路复用），可以处理并发的连接。非阻塞IO 内部实现采用epo...
复制链接

扫一扫