Windows下安装Redis和常用命令介绍以及Jedis

非原创，转自https://blog.csdn.net/noaman_wgs/article/details/59501400

Redis

---

Windows中安装Redis

Redis官网所给的Redis安装包只是基于linux系统的去操作的，所以想在windows系统中使用Redis服务，需要去下面的网址去下载对应的版本： 
https://github.com/MSOpenTech/redis/releases/tag/win-3.2.100 
下载最新版本即可，如Redis-x64-3.2.100.zip。

下载完成后解压，查看文件夹中是否有以下三个文件： 

打开cmd窗口，进入到Redis所在文件夹。 
执行redis-server.exe redis.windows.conf命令，如出现Redis的LOGO，代表开启Redis服务成功。 

安装成功后，此窗口不要关闭 ，再新开一个cmd窗口，输入redis-cli.exe命令，即可进行Redis命令的操作。 
测试是否连接成功：输入PING，如果显示PONG，即成功。 

再来个Redis的HelloWorld: 
输入命令：set age 22, 显示OK后，再输入命令：get age 即可得到age 的值：“22”。 
 
是不是很简单呢?下面将介绍Redis的基础知识。

---

Redis的五大数据类型

Redis是完全开源免费的，用C语言编写的，遵守BSD协议， 
是一个高性能的(key/value)分布式内存数据库，基于内存运行 
并支持持久化的NoSQL数据库，是当前最热门的NoSql数据库之一,也被人们称为数据结构服务器。

Redis主要有五种数据类型，下面将一 一进行介绍以及每种数据类型的常用命令。

在介绍数据类型之前先介绍下Redis的键key的几个常用命令。 

以上是常用的几个key的命令，在以下的范例中都会用到这些命令。

1. String字符串

String是Redis最基本的类型 . 
特点:是一个key对应一个value。

String类型时二进制安全的，可以包含任何数据，比如jpg图片或者系列化的对象。一个Redis字符串value最多可以是512M。

String的常用命令如下图： 

2. List列表

特点：单值多value。可理解为一个集合中存储多个数。

List是一个字符串链表，链表左右端都可以插入添加； 
如果键不存在，创建新的链表； 
如果键已存在，新增内容； 
如果值全移除，对应的键也就消失了。 
链表的操作无论是头和尾效率都极高，但假如是对中间元素进行操作，效率就很惨淡了。

List的常用命令如下图： 
 

3. Set集合 
特点：单值多value。如Java中Set集合类似。

Redis的Set是string类型的无序集合。它是通过HashTable实现实现的

Set的常用命令如下图： 

4. Zset(Sorted set)-有序集合 
特点：Zset是在set基础上，加一个score值。

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

比如说之前set是k1 v1 v2 v3， 
现在zset是k1 score1 v1 score2 v2 score3 v3 
在游戏中经常用到这种概念，比如在打怪的时候，每个人的排名是依据每个玩家所得分数进行排名的。这个分数就是score。

Zset的常用命令如下图： 

5. Hash哈希 
特点：键值KV模式不变，不同的是V是一个键值对。

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

Hash的常用命令如下： 

---

Redis的Java客户端Jedis的操作

Redis支持的客户端操作语言非常丰富，达到40多种。就Java来说，最常用的还是客户端Jedis。Jedis使用简单，基本和Redis命令行语法相似。

本节主要是介绍Java中如何操作Redis。因为在Java中真正操作Redis并不是很多，所以本节只做一些了解性的介绍。

操作之前的准备： 
1. Jedis需要添加两个JAR包：

Commons-pool-1.6.jar 
Jedis-2.1.0.jar

如果是使用了MAVEN，就需要在pom.xml中加上依赖：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

若在Spring中配置，还需加上依赖：

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
</dependency>

2 . 本次操作环节既然是Windows， 
需要在cmd窗口在中开启Redis服务，才可进行下面的测试操作。 

测试 
1. 连接测试

import redis.clients.jedis.Jedis;
/**
 * 连接测试
 * @author wanggenshen_sx
 *
 */
public class TestRedisConnection {

    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        System.out.println(jedis.ping());

    }
}

输出PONG，即为连接成功。

2. Redis五大数据类型测试 
String

import redis.clients.jedis.Jedis;

/**
 * 测试Redis五大数据类型---String
 * @author wanggenshen_sx
 *
 */
public class TestRedisAPIString {

    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();

        //set k1 AA k2 BB k3 CC
        jedis.set("k1", "AA");
        jedis.set("k2", "BB");
        jedis.set("k3", "CC");
        jedis.set("k4", "DD");
        jedis.set("k5", "EE");

        //查：get k2
        System.out.println(jedis.get("k2"));
        //查全部：keys * 
        System.out.println(jedis.keys("*"));
        //删：del k2
        jedis.del("k1");
        System.out.println(jedis.keys("*"));

    }
}

输出： 
BB 
[k3, k4, k5, k1, k2] 
[k3, k4, k5, k2]

List

import redis.clients.jedis.Jedis;

/**
 * 测试Redis五大数据类型---List
 * @author wanggenshen_sx
 *
 */
public class TestRedisAPIList {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        //清空数据库：flush db
        jedis.flushDB();

        //增：lpush list1 v1
        //   rpush list1 v3
        jedis.lpush("list1", "v1");
        jedis.lpush("list1", "v2");
        jedis.rpush("list1", "v3");

        //查：lrange list1
        // llen list1 ：集合list1的大小
        System.out.println(jedis.lrange("list1", 0, jedis.llen("list1")));

        //删除元素：lrem list1 1 v2
        // 从left往right删除2个值等于v1的元素，返回的值为实际删除的数量
        jedis.lrem("list1", 1, "v2");
        System.out.println(jedis.lrange("list1", 0, jedis.llen("list1")));
    }
}

输出： 
[v2, v1, v3] 
[v1, v3]

HashMap

import java.util.HashMap;

import redis.clients.jedis.Jedis;

/**
 * 测试Redis五大数据类型---HashMap
 * K不变，V是键值对
 * @author wanggenshen_sx
 *
 */
public class TestRedisAPIHashMap {


    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        //清空数据库：flush db
        jedis.flushDB();

        //增：hset hash1 k1 v1  k2 v3
        jedis.hset("hash1", "k1", "v1");
        jedis.hset("hash1", "k2", "v2");

        //批量添加：hmset hash1 k3 v3 k4 v4 k5 v5
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("k3", "v3");
        map.put("k4", "v4");
        map.put("k5", "v5");
        jedis.hmset("hash1", map);

        //查：hget hash1 k2
        System.out.println(jedis.hget("hash1", "k2"));
        //批量查询：hmget hash1 k1 k2 k3
        System.out.println(jedis.hmget("hash1", "k1", "k2", "k3"));

        //删除元素：hdel hash1 k4
        jedis.hdel("hash1", "k4");
        //获取全部
        System.out.println(jedis.hgetAll("hash1"));
    }

}

输出： 
v2 
[v1, v2, v3] 
{k1=v1, k2=v2, k3=v3, k5=v5}

Set

import redis.clients.jedis.Jedis;

/**
 * 测试Redis五大数据类型---Set
 * @author wanggenshen_sx
 *
 */
public class TestRedisAPISet {


    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();

        //增：sadd set1 v1 v2 v3
        jedis.sadd("set1", "v1");
        jedis.sadd("set1", "v2");
        jedis.sadd("set1", "v3");
        jedis.sadd("set1", "v4");
        jedis.sadd("set1", "v5");

        //查：smemebers set1
        System.out.println(jedis.smembers("set1"));

        //删除元素：srem set1 v2
        jedis.srem("set1", "v3");
        System.out.println(jedis.smembers("set1"));

    }

}

输出： 
[v1, v2, v3, v4, v5] 
[v1, v2, v4, v5]

ZSet

import java.util.HashMap;
import java.util.Map;

import redis.clients.jedis.Jedis;

/**
 * 测试Redis五大数据类型---ZSet
 * @author wanggenshen_sx
 *
 */
public class TestRedisAPIZSet {


    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();

        //增：zadd zset1 60 v1 70 v2 80 v3 90 v4 100 v5
        jedis.zadd("zset1", 60, "v1");
        jedis.zadd("zset1", 70, "v2");
        Map<Double, String> map = new HashMap<>();
        map.put(80.00, "v3");
        map.put(90.00, "v4");
        map.put(100.00, "v5");
        jedis.zadd("zset1", map);

        //查：zrange zset1 0 -1 
        System.out.println(jedis.zrange("zset1", 0, -1));
        //查：zrange zset1 0 -1  with scores
        System.out.println(jedis.zrangeWithScores("zset1", 0, -1));

        //删除元素：zrem zset1 v2
        jedis.zrem("zset1", "v2");
        System.out.println(jedis.zrangeWithScores("zset1", 0, -1));

    }

}

输出： 
[v1, v2, v3, v4, v5] 
[[[118, 49],60.0], [[118, 50],70.0], [[118, 51],80.0], [[118, 52],90.0], [[118, 53],100.0]] 
[[[118, 49],60.0], [[118, 51],80.0], [[118, 52],90.0], [[118, 53],100.0]]

3.JedisPool 
JedisPool的概念类似于线程池，即获取Jedis实例需要从JedisPool中获取，用完Jedis实例也需要还给JedisPool。 
并且需要在finally中去关闭。

如下，先写个操作JedisPool的工具类：

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

/**
 * 使用单例模式获取JedisPool实例
 *
 */
public class JedisPoolUtil {

    private static volatile JedisPool jedisPool = null;

    public static JedisPool getJedisPoolInstance(){
        if(null == jedisPool){
            synchronized(JedisPoolUtil.class){
                JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
                //控制一个pool可分配多少个jedis实例
                jedisPoolConfig.setMaxActive(1000);
                //控制一个pool最多有多少个状态为idle(空闲)的jedis实例
                jedisPoolConfig.setMaxIdle(32);
                //表示当borrow一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛JedisConnectionException；
                jedisPoolConfig.setMaxWait(100*1000);
                //获得一个jedis实例的时候是否检查连接可用性（ping()）
                jedisPoolConfig.setTestOnBorrow(true);

                jedisPool =  new JedisPool("127.0.0.1", 6379);
            }
        }
        return jedisPool;
    }


    public static void release(JedisPool jedisPool,Jedis jedis){
        if(jedis != null){
            jedisPool.returnResourceObject(jedis);
        }
    }

    public JedisPoolUtil(){}
}

测试：

JedisPool的配置参数大部分是由JedisPoolConfig的对应项来赋值的。

Jedis的配置介绍： 
- maxActive：控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted。 
- maxIdle：控制一个pool最多有多少个状态为idle(空闲)的jedis实例； 
whenExhaustedAction：表示当pool中的jedis实例都被allocated完时，pool要采取的操作；默认有三种。 
WHEN_EXHAUSTED_FAIL –> 表示无jedis实例时，直接抛出NoSuchElementException； 
WHEN_EXHAUSTED_BLOCK –> 则表示阻塞住，或者达到maxWait时抛出JedisConnectionException； 
WHEN_EXHAUSTED_GROW –> 则表示新建一个jedis实例，也就说设置的maxActive无用； 
- maxWait：表示当borrow一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛JedisConnectionException； 
- testOnBorrow：获得一个jedis实例的时候是否检查连接可用性（ping()）；如果为true，则得到的jedis实例均是可用的； 
- testOnReturn：return 一个jedis实例给pool时，是否检查连接可用性（ping()）； 
- testWhileIdle：如果为true，表示有一个idle object evitor线程对idle object进行扫描，如果validate失败，此object会被从pool中drop掉；这一项只有在 timeBetweenEvictionRunsMillis大于0时才有意义； 
- timeBetweenEvictionRunsMillis：表示idle object evitor两次扫描之间要sleep的毫秒数； 
- numTestsPerEvictionRun：表示idle object evitor每次扫描的最多的对象数； 
- minEvictableIdleTimeMillis：表示一个对象至少停留在idle状态的最短时间，然后才能被idle object evitor扫描并驱逐；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义 
- softMinEvictableIdleTimeMillis：在minEvictableIdleTimeMillis基础上，加入了至少minIdle个对象已经在pool里面了。如果为-1，evicted不会根据idle time驱逐任何对象。如果minEvictableIdleTimeMillis>0，则此项设置无意义，且只有在timeBetweenEvictionRunsMillis大于0时才有意义； 
- lifo：borrowObject返回对象时，是采用DEFAULT_LIFO（last in first out，即类似cache的最频繁使用队列），如果为False，则表示FIFO队列；

================================================ 
其中JedisPoolConfig对一些参数的默认设置如下：

testWhileIdle=true 
minEvictableIdleTimeMills=60000 
timeBetweenEvictionRunsMillis=30000 
numTestsPerEvictionRun=-1

(此处CSDN格式有问题，强迫症实在受不鸟)