NOSQL数据库-Redis

学习目标

1. 能够理解nosql的概念

2. 能够说出redis的常用数据类型

3. 能够使用redis的string操作命令

4. 能够使用redis的hash操作命令

5. 能够使用redis的list操作命令

6. 能够使用redis的set操作命令

7. 能够说出redis的两种持久化机制

8. 能够使用jedis对redis进行操作

NOSQL概述

什么是NOSQL

NoSQL(NoSQL = Not Only SQL)，意即“不仅仅是SQL”，是一项全新的数据库理念，泛指非关系型的数据库。

关系型，表与表之间的关系，一个表中字段与字段之间的关系。mysql，主子表关系，数据之间是有关系。

非关系型，数据之间没有任何关系。

那么，非关系数据库存储什么样的数据呢？

答案：用户经常查询的数据，因为经常查询的数据放到缓存中查询速度会大大提高。由于缓存数据库数据不安全，所以缓存数据库会从mysql数据库获取数据存储到缓存中。

这样可以保证，mysql数据是安全，不会丢，mysql中的数据是第一份缓存数据库中的数据是第二份，丢了无所谓。

为什么需要NOSQL

随着互联网的高速崛起，网站的用户群的增加，访问量的上升，传统数据库上都开始出现了性能瓶颈，web程序不再仅仅专注在功能上，同时也在追求性能。所以NOSQL数据库应运而上，具体表现为对如下三高问题的解决：

• High performance - 对数据库高并发读写的需求

web2.0网站要根据用户个性化信息来实时生成动态页面和提供动态信息，所以基本上无法使用动态页面静态化技术，因此数据库并发负载非常高，往往要达到每秒上万次读写请求。关系数据库应付上万次SQL查询还勉强顶得住，但是应付上万次SQL写数据请求，硬盘IO就已经无法承受了。其实对于普通的BBS网站，往往也存在对高并发写请求的需求，例如网站的实时统计在线用户状态，记录热门帖子的点击次数，投票计数等，因此这是一个相当普遍的需求。

• Huge Storage - 对海量数据的高效率存储和访问的需求

类似Facebook，twitter，Friendfeed这样的SNS网站，每天用户产生海量的用户动态，以Friendfeed为例，一个月就达到了2.5亿条用户动态，对于关系数据库来说，在一张2.5亿条记录的表里面进行SQL查询，效率是极其低下乃至不可忍受的。再例如大型web网站的用户登录系统，例如腾讯，盛大，动辄数以亿计的帐号，关系数据库也很难应付。

• High Scalability && High Availability- 对数据库的高可扩展性和高可用性的需求

在基于web的架构当中，数据库是最难进行横向扩展的，当一个应用系统的用户量和访问量与日俱增的时候，你的数据库却没有办法像web server和app server那样简单的通过添加更多的硬件和服务节点来扩展性能和负载能力。对于很多需要提供24小时不间断服务的网站来说，对数据库系统进行升级和扩展是非常痛苦的事情，往往需要停机维护和数据迁移。

主流的NOSQL产品

• 键值(Key-Value)存储数据库

相关产品： Tokyo Cabinet/Tyrant、Redis、Voldemort、Berkeley DB

典型应用： 内容缓存，主要用于处理大量数据的高访问负载。

数据模型： 一系列键值对

优势： 快速查询

劣势： 存储的数据缺少结构化

• 列存储数据库

相关产品：Cassandra, HBase, Riak

典型应用：分布式的文件系统

数据模型：以列簇式存储，将同一列数据存在一起

优势：查找速度快，可扩展性强，更容易进行分布式扩展

劣势：功能相对局限

• 文档型数据库

相关产品：CouchDB、MongoDB

典型应用：Web应用（与Key-Value类似，Value是结构化的）

数据模型： 一系列键值对

优势：数据结构要求不严格

劣势： 查询性能不高，而且缺乏统一的查询语法

• 图形(Graph)数据库

相关数据库：Neo4J、InfoGrid、Infinite Graph

典型应用：社交网络

数据模型：图结构

优势：利用图结构相关算法。

劣势：需要对整个图做计算才能得出结果，不容易做分布式的集群方案。

Redis概述

什么是Redis

Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库，官方提供测试数据，50个并发执行100000个请求,读的速度是110000次/s,写的速度是81000次/s，且Redis通过提供多种键值数据类型来适应不同场景下的存储需求，目前为止Redis支持的键值数据类型如下：

• 字符串类型 string

• 散列类型 hash

• 列表类型 list

• 集合类型 set

• 有序集合类型 sortedset

redis的应用场景

• 缓存（数据查询、短连接、新闻内容、商品内容等等）

• 聊天室的在线好友列表

• 任务队列。（秒杀、抢购、12306等等）

• 应用排行榜

• 网站访问统计

• 数据过期处理（可以精确到毫秒

• 分布式集群架构中的session分离

总结，只要希望查询快就可以使用redis，但是mysql中的数据如果频繁的更新，就不建议使用redis了，否则redis会频繁的从mysql不断更新数据，会导致redis慢了。redis适合存储经常查询又不经常更新的数据。（更新的频率不要太高。）

window版Redis的安装与使用

windows版Redis的下载

官方提倡使用Linux版的Redis，所以官网值提供了Linux版的Redis下载，我们可以从GitHub上下载window版的Redis，具体链接地址如下：

• 官网下载地址：http://redis.io/download

• github下载地址：https://github.com/MSOpenTech/redis/tags

在今天的资料中提供的下载完毕的window版本的Redis：

window版Redis的目录结构

解压Redis压缩包后，见到如下目录机构：

目录或文件	作用
redis-benchmark	性能测试工具
redis-check-aof	AOF文件修复工具
redis-check-dump	RDB文件检查工具（快照持久化文件）
redis-cli	命令行客户端
redis-server	redis服务器启动命令
redis.windows.conf	redis核心配置文件

window版Redis的安装与启动

window版Redis的安装

window版的安装及其简单，解压Redis压缩包完成即安装完毕

window版Redis的启动与关闭

双击Redis目录中redis-server.exe可以启动redis服务，Redis服务占用的端口是6379

关闭Redis的控制台窗口就可以关闭Redis服务

window版Redis的使用

双击Redis目录中redis-cli.exe可以启动redis客户端

redis解压到非中文目录里面，目录结构不要太深。注意事项redis所在的硬盘位置的盘符，硬盘空间必须有20G以上，否则会发生不可预知的错误。

Redis的数据类型

Redis的5种数据类型

redis是一种高级的key-value的存储系统，其中value支持五种数据类型：

• 字符串（String）

• 哈希（hash）

• 字符串列表（list）

• 字符串集合（set）

• 有序字符串集合（sorted set）

在日常开发中主要使用比较多的有字符串、哈希、字符串列表、字符串集合四种类型，其中最为常用的是字符串类型。

关于key的定义，注意如下几点：

• key不要太长，最好不要超过1024个字节，这不仅会消耗内存还会降低查找效率

• key不要太短，如果太短会降低key的可读性

• 在项目中，key最好有一个统一的命名规范（见名知意）

字符串类型string

字符串类型string概述

字符串类型是Redis中最为基础的数据存储类型，它在Redis中是二进制安全的，这便意味着该类型存入和获取的数据相同。在Redis中字符串类型的Value最多可以容纳的数据长度是512M。

字符串类型string常用命令

• set key value

设定key持有指定的字符串value，如果该key存在则进行覆盖操作。总是返回”OK”

127.0.0.1:6379> set company "itcast"
OK
127.0.0.1:6379>

• get key

获取key的value。如果与该key关联的value不是String类型，redis将返回错误信息，因为get命令只能用于获取String
value；如果该key不存在，返回(nil)。

127.0.0.1:6379> set name "itcast"
OK
127.0.0.1:6379> get name
"itcast"

• del key

删除指定key

127.0.0.1:6379> del name
(integer) 1
127.0.0.1:6379> get name
(nil)

哈希类型hash

哈希类型hash概述

Redis中的Hash类型可以看成具有String Key和String Value的map容器。所以该类型非常适合于存储值对象的信息。如Username、Password和Age等。如果Hash中包含很少的字段，那么该类型的数据也将仅占用很少的内存空间。每一个Hash可以存储4294967295个键值对。

哈希类型hash常用命令

• hset key field value

为指定的key设定field/value对（键值对）。

127.0.0.1:6379> hset myhash username haohao
(integer) 1
127.0.0.1:6379>

• hget key field

返回指定的key中的field的值

127.0.0.1:6379> hset myhash username haohao
(integer) 1
127.0.0.1:6379> hget myhash username
"haohao"

• hmset key field value [field2 value2 …]：设置key中的多个filed/value

• hmget key fileds：获取key中的多个filed的值

一次获取key的所有map的key和value：hgetall key

hgetall myhash

• hdel key field [field … ]

可以删除一个或多个字段，返回值是被删除的字段个数

127.0.0.1:6379> hdel myhash username
(integer) 1
127.0.0.1:6379> hget myhash username
(nil)
127.0.0.1:6379>

列表类型list

列表类型list概述

在Redis中，List类型是按照插入顺序排序的字符串链表（java中的linkedlist）。和数据结构中的普通链表一样，我们可以在其头部(left)和尾部(right)添加新的元素。在插入时，如果该键并不存在，Redis将为该键创建一个新的链表。与此相反，如果链表中所有的元素均被移除，那么该键也将会被从数据库中删除。List中可以包含的最大元素数量是4294967295

列表类型list

• lpush key value1 value2 …

在指定的key所关联的list的头部插入所有的values，如果该key不存在，该命令在插入的之前创建一个与该key关联的空链表，之后再向该链表的头部插入数据。插入成功，返回元素的个数。

127.0.0.1:6379> lpush mylist a b c
(integer) 3
127.0.0.1:6379>

• rpush key value value value

rpush key value value value : 在指定的key对应的list的尾部插入所有的value，如果该key不存在，该命令在插入之前创建一个与该key对应的空链表，再从尾部插入数据。插入成功，返回元素的个数。

right

rpush key one two three

• 查看列表

lrange key start end : 获取链表中从start到end的元素的值，start和end从0开

始计数，如果为负数，-1表示倒数第一个元素，-2表示倒数第二个元素，以此类推。

list

代码：

lrange key 0 3
lrange key 0 -1

删除list中的元素数据，通过两端弹出

• lpop key，从头部弹出元素

返回并弹出指定的key关联的链表中的第一个元素，即头部元素。如果该key不存在，返回nil；若key存在，则返回链表的头部元素。

127.0.0.1:6379> lpush mylist a b c
(integer) 3
127.0.0.1:6379> lpop mylist
"c"
127.0.0.1:6379> lpop mylist
"b"

• rpop key，从尾部弹出元素

从尾部弹出元素。

127.0.0.1:6379> lpush mylist a b c
(integer) 3
127.0.0.1:6379> rpop mylist
"a"

• 获取列表中元素的个数

llen key : 返回指定key对应链表中元素的个数

代码：

llen key

集合类型set

集合类型set

在Redis中，我们可以将Set类型看作为没有排序的字符集合，和List类型一样，我们也可以在该类型的数据值上执行添加、删除或判断某一元素是否存在等操作。Set可包含的最大元素数量是4294967295，和List类型不同的是，Set集合中不允许出现重复的元素。

集合类型set的常用命令

• sadd key values[value1 value2 …]

向set中添加数据，如果该key的值已有则不会重复添加

127.0.0.1:6379> sadd myset a b c
(integer) 3

• smembers key

获取set中所有的成员

127.0.0.1:6379> sadd myset a b c
(integer) 3
127.0.0.1:6379> smembers myset
1) "c"
2) "a"
3) "b"

• srem key members[member1、member2…]

删除set中指定的成员

127.0.0.1:6379> srem myset a b
(integer) 2
127.0.0.1:6379> smembers myset
1) "c"
127.0.0.1:6379>

Redis的通用命令（扩展的）

• keys pattern

获取所有与pattern匹配的key，返回所有与该key匹配的keys。*表示任意一个或多个字符，?表示任意一个字符

127.0.0.1:6379> keys *
1) "company"
2) "mylist"
3) "myhash"
4) "myset"

• del key1 key2…

删除指定的key

127.0.0.1:6379> del company
(integer) 1

• exists key

判断该key是否存在，1代表存在，0代表不存在

127.0.0.1:6379> exists compnay
(integer) 0
127.0.0.1:6379> exists mylist
(integer) 1
127.0.0.1:6379>

• type key

获取指定key的类型。该命令将以字符串的格式返回。
返回的字符串为string、list、set、hash，如果key不存在返回none

127.0.0.1:6379> type company
string
127.0.0.1:6379> type mylist
list
127.0.0.1:6379> type myset
set
127.0.0.1:6379> type myhash
hash
127.0.0.1:6379>

• select切换数据库

选择数据库

一个Redis服务器可以包括多个数据库，客户端可以指连接Redis中的的哪个数据库，就好比一个mysql服务器中创建多个数据库，客户端连接时指定连接到哪个数据库。一个Redis实例最多可提供16个数据库，下标为0到15，客户端默认连接第0个数据库，也可以通过select命令选择哪个数据库。

• move移key到其他数据库

将key移到某个数据库

move key 1 : 将当前数据库中的key移到1号数据库中

代码：

set username zhaojun
move username 15
select 15
Keys *

客户端工具连接

Redis的持久化（了解）

持久化概述

Redis的高性能是由于其将所有数据都存储在了内存中，为了使Redis在重启之后仍能保证数据不丢失，需要将数据从内存中同步到硬盘中，这一过程就是持久化。Redis支持两种方式的持久化，一种是RDB方式，一种是AOF方式。可以单独使用其中一种或将二者结合使用。

• RDB持久化（默认支持，无需配置）

该机制是指在指定的时间间隔内将内存中的数据集快照写入磁盘。

• AOF持久化

该机制将以日志的形式记录服务器所处理的每一个写操作，在Redis服务器启动之初会读取该文件来重新构建数据库，以保证启动后数据库中的数据是完整的。

• 无持久化

我们可以通过配置的方式禁用Redis服务器的持久化功能，这样我们就可以将Redis视为一个功能加强版的memcached了。

• redis可以同时使用RDB和AOF

RDB持久化机制

RDB持久化机制优点

• 一旦采用该方式，那么你的整个Redis数据库将只包含一个文件（rdb文件），这对于文件备份而言是非常完美的。比如，你可能打算每个小时归档一次最近24小时的数据，同时还要每天归档一次最近30天的数据。通过这样的备份策略，一旦系统出现灾难性故障，我们可以非常容易的进行恢复。

• 对于灾难恢复而言，RDB是非常不错的选择。因为我们可以非常轻松的将一个单独的文件压缩后再转移到其它存储介质上

• 性能最大化。对于Redis的服务进程而言，在开始持久化时，它唯一需要做的只是fork（分叉）出子进程，之后再由子进程完成这些持久化的工作，这样就可以极大的避免服务进程执行IO操作了。

相比于AOF机制，如果数据集很大，RDB的启动效率会更高

RDB持久化机制缺点

• 如果你想保证数据的高可用性（就是内存数据不丢失），即最大限度的避免数据丢失，那么RDB将不是一个很好的选择。因为系统一旦在定时持久化之前出现宕机现象，此前没有来得及写入磁盘的数据都将丢失。

• 由于RDB是通过fork子进程来协助完成数据持久化工作的，因此，如果当数据集较大时，可能会导致整个服务器停止服务几百毫秒，甚至是1秒钟

RDB持久化机制的配置

在redis.windows.conf配置文件中有如下配置：

################################ SNAPSHOTTING  #################################
#
# Save the DB on disk:
#
#   save <seconds> <changes>
#
#   Will save the DB if both the given number of seconds and the given
#   number of write operations against the DB occurred.
#
#   In the example below the behaviour will be to save:
#   after 900 sec (15 min) if at least 1 key changed
#   after 300 sec (5 min) if at least 10 keys changed
#   after 60 sec if at least 10000 keys changed
#
#   Note: you can disable saving at all commenting all the "save" lines.
#
#   It is also possible to remove all the previously configured save
#   points by adding a save directive with a single empty string argument
#   like in the following example:
#
#   save ""

save 900 1
save 300 10
save 60 10000

其中，上面配置的是RDB方式数据持久化时机：

关键字	时间(秒)	key修改数量	解释
save	900	1	每900秒(15分钟)至少有1个key发生变化，则dump内存快照
save	300	10	每300秒(5分钟)至少有10个key发生变化，则dump内存快照
save	60	10000	每60秒(1分钟)至少有10000个key发生变化，则dump内存快照

AOF持久化机制

AOF持久化机制优点

• 该机制可以带来更高的数据安全性，即数据持久性。Redis中提供了3中同步策略，即每秒同步、每修改同步和不同步。事实上，每秒同步也是异步完成的，其效率也是非常高的，所差的是一旦系统出现宕机现象，那么这一秒钟之内修改的数据将会丢失。而每修改同步，我们可以将其视为同步持久化，即每次发生的数据变化都会被立即记录到磁盘中。可以预见，这种方式在效率上是最低的。至于无同步，无需多言，我想大家都能正确的理解它。

• 由于该机制对日志文件的写入操作采用的是append模式，因此在写入过程中即使出现宕机现象，也不会破坏日志文件中已经存在的内容。然而如果我们本次操作只是写入了一半数据就出现了系统崩溃问题，不用担心，在Redis下一次启动之前，我们可以通过redis-check-aof工具来帮助我们解决数据一致性的问题。

• 如果日志过大，Redis可以自动启用rewrite机制。即Redis以append模式不断的将修改数据写入到老的磁盘文件中，同时Redis还会创建一个新的文件用于记录此期间有哪些修改命令被执行。因此在进行rewrite切换时可以更好的保证数据安全性。

• AOF包含一个格式清晰、易于理解的日志文件用于记录所有的修改操作。事实上，我们也可以通过该文件完成数据的重建

AOF持久化机制缺点

对于相同数量的数据集而言，AOF文件通常要大于RDB文件

根据同步策略的不同，AOF在运行效率上往往会慢于RDB。

AOF持久化机制配置

手动开启AOF持久化

############################## APPEND ONLY MODE ###############################

# By default Redis asynchronously dumps the dataset on disk. This mode is
# good enough in many applications, but an issue with the Redis process or
# a power outage may result into a few minutes of writes lost (depending on
# the configured save points).
#
# The Append Only File is an alternative persistence mode that provides
# much better durability. For instance using the default data fsync policy
# (see later in the config file) Redis can lose just one second of writes in a
# dramatic event like a server power outage, or a single write if something
# wrong with the Redis process itself happens, but the operating system is
# still running correctly.
#
# AOF and RDB persistence can be enabled at the same time without problems.
# If the AOF is enabled on startup Redis will load the AOF, that is the file
# with the better durability guarantees.
#
# Please check http://redis.io/topics/persistence for more information.

appendonly no

将appendonly修改为yes，开启aof持久化机制，默认会在目录下产生一个appendonly.aof文件修改效果为

appendonly yes

启动需要指定配置文件

效果

AOF持久化时机

# appendfsync always
appendfsync everysec
# appendfsync no

上述配置为aof持久化的时机，解释如下：

关键字	持久化时机	解释
appendfsync	always	每执行一次更新命令，持久化一次
appendfsync	everysec	每秒钟持久化一次
appendfsync	no	不持久化

Jedis的基本使用

jedis的介绍

Redis不仅是使用命令来操作，现在基本上主流的语言都有客户端支持，比如java、C、C#、C++、php、Node.js、Go等。在官方网站里列一些Java的客户端，有Jedis、Redisson、Jredis、JDBC-Redis、等其中官方推荐使用Jedis和Redisson。在企业中用的最多的就是Jedis，Jedis同样也是托管在github上，地址：https://github.com/xetorthio/jedis。

jedis的基本操作

jedis常用API

方法	解释
new Jedis(host, port)	创建jedis对象，参数host是redis服务器地址，参数port是redis服务端口
set(key,value)	设置字符串类型的数据
get(key)	获得字符串类型的数据
hset(key,field,value)	设置哈希类型的数据
hget(key,field)	获得哈希类型的数据
lpush(key,values)	设置列表类型的数据
lpop(key)	列表左面弹栈
rpop(key)	列表右面弹栈
del(key)	删除指定的key

jedis的基本操作

package com.itheima.test;

import redis.clients.jedis.Jedis;

import java.util.List;

public class JedisTest1 {

    public static void main(String[] args) {
        /*
        * 使用Jedis操作Redis
        *    操作redis刚才使用都是命令，刚才的命令变成了jedis里面的方法
        *    set key value ====>java中的方法  set(String key,String value);
        * */

        //1.创建Jedis对象，用于连接Redis
        // new Jedis(String host,int port);
        // host，指定redis服务器的地址
        // port，指定redis服务器占用端口号
        Jedis jedis = new Jedis("localhost",6379);
        //2.操作字符串类型数据
        //写入
        jedis.set("itheima92","hello world");
        //读取
        String value = jedis.get("itheima92");
        //打印
        System.out.println("itheima92:"+value);
        //3.操作list类型数据（以后不用）
        //写入
        jedis.lpush("myList2","one","two","three");
        //读取
        List<String> myList2 =  jedis.lrange("myList2",0,-1);
        //打印
        System.out.println("myList2:"+myList2);
        //4.关闭连接
        jedis.close();
    }
}

jedis连接池的使用

jedis连接池的基本概念

jedis连接资源的创建与销毁是很消耗程序性能，所以jedis为我们提供了jedis的池化技术，jedisPool在创建时初始化一些连接资源存储到连接池中，使用jedis连接资源时不需要创建，而是从连接池中获取一个资源进行redis的操作，使用完毕后，不需要销毁该jedis连接资源，而是将该资源归还给连接池，供其他请求使用。

jedisPool的基本使用

package com.itheima.test;

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

import java.util.List;

public class JedisTest2_Pool {

    public static void main(String[] args) {

        //1.创建jedis连接池,并从连接池里面获取连接
        //创建配置对象
        JedisPoolConfig config= new JedisPoolConfig();
        config.setMaxTotal(10);//最大连接数
        config.setMaxWaitMillis(30000);//用户最大等待超时时间，单位毫秒数
        //创建连接池对象
        //public JedisPool(GenericObjectPoolConfig poolConfig, String host, int port)
        JedisPool jedisPool = new JedisPool(config,"localhost",6379);
        //从连接池里面获取连接对象jedis
        Jedis jedis = jedisPool.getResource();
        //2.操作字符串类型数据
        //写入
        jedis.set("itheima92","hello world");
        //读取
        String value = jedis.get("itheima92");
        //打印
        System.out.println("itheima92:"+value);
        //3.操作list类型数据（以后不用）
        //写入
        jedis.lpush("myList2","one","two","three");
        //读取
        List<String> myList2 =  jedis.lrange("myList2",0,-1);
        //打印
        System.out.println("myList2:"+myList2);
        //4.关闭连接(将连接返回连接池中)
        jedis.close();
        //关闭连接池
        jedisPool.close();//以后不关闭
    }
}

案例-编写jedis连接池工具类

jedis.properties

#最大连接数
maxTotal=10
#用户超时时间
maxWaitMillis=30000
#redis服务器地址
host=localhost
#端口号
port=6379

JedisUtils.java

package com.itheima.util;

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

import java.util.ResourceBundle;

public class JedisUtil {

    private static JedisPool jedisPool;

    //静态代码块初始化
    static{
        //读取jedis.properties配置文件解析里面的数据
        //ResourceBundle,专门用于解析properties文件，可以根据文件的名字就可以解析文件
        ResourceBundle resourceBundle = ResourceBundle.getBundle("jedis");//会自动读取类路径里面的文件
        //读取里面的数据
        int maxTotal = Integer.parseInt(resourceBundle.getString("maxTotal"));
        int maxWaitMillis = Integer.parseInt(resourceBundle.getString("maxWaitMillis"));
        String host = resourceBundle.getString("host");
        int port = Integer.parseInt(resourceBundle.getString("port"));

        //创建配置对象
        JedisPoolConfig config= new JedisPoolConfig();
        config.setMaxTotal(maxTotal);//最大连接数
        config.setMaxWaitMillis(maxWaitMillis);//用户最大等待超时时间，单位毫秒数
        //创建连接池对象
        //public JedisPool(GenericObjectPoolConfig poolConfig, String host, int port)
        jedisPool = new JedisPool(config,host,port);
    }


    //方便用户获取一个连接对象
    public static Jedis getJedis(){
        return jedisPool.getResource();
    }
}

测试代码

package com.itheima.test;

import com.itheima.util.JedisUtil;
import redis.clients.jedis.Jedis;

import java.util.List;

public class JedisTest3_util {

    public static void main(String[] args) {

        //1.使用工具类获取jedis连接对象
        Jedis jedis = JedisUtil.getJedis();
        //2.操作字符串类型数据
        //写入
        jedis.set("itheima92","hello world");
        //读取
        String value = jedis.get("itheima92");
        //打印
        System.out.println("itheima92:"+value);
        //3.操作list类型数据（以后不用）
        //写入
        jedis.lpush("myList2","one","two","three");
        //读取
        List<String> myList2 =  jedis.lrange("myList2",0,-1);
        //打印
        System.out.println("myList2:"+myList2);
        //4.关闭连接(将连接返回连接池中)
        jedis.close();
    }
}

案例：Redis实战之查询所有省份（重点）

需求：访问index.jsp页面，使用ajax请求加载省份列表，用户第一次访问数据库获取，以后都从redis里面获取。

数据库表province

写入测试数据

insert  into `province`(`pid`,`pname`) values (1,'广东省'),(2,'湖南省'),(3,'吉林省'),(4,'广西省');

需要导入的内容

分析

代码结构

jedis.properties

maxTotal=100
maxWaitMillis=3000
host=localhost
port=6379

index.jsp代码：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  省份列表：
  <select id="province">
    <option>=请选择=</option>
  </select>
  <%--导入jquery--%>
  <script type="text/javascript" src="js/jquery-3.3.1.min.js"></script>
  <script type="text/javascript">
    //发送异步ajax请求
    $.ajax({
        url:"SearchProviceListServlet",
        dataType:"json",
        type:"post",
        success:function (json) {
           //json=[{pid=xx,pname=xx},{pid=xx,pname=xx},...]
            if(json.length>0){
                //遍历数据，更新到页面上
                $(json).each(function (i,province) {
                    //将每个省份数据添加到下拉框中
                    var pid= province.pid;
                    var pname = province.pname;
                    $("#province").append("<option value='"+pid+"'>"+pname+"</option>");
                });
            }
        },
        error:function () {
            alert("服务器忙。。。");
        }
    });
  </script>
  </body>
</html>

SelectProvinceServelt

package com.itheima.web;

import com.itheima.service.ProvinceService;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(name = "SearchProviceListServlet", urlPatterns = "/SearchProviceListServlet")
public class SearchProviceListServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    //实例业务
    private ProvinceService provinceService = new ProvinceService();
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        try {
            //1.调用业务获取省份列表数据（返回字符串）
            String jsonData =provinceService.findAllProvince();
            //2.返回给前端
            response.getWriter().write(jsonData);
        } catch (Exception e) {
            e.printStackTrace();

        }
    }
}

ProvinceService

package com.itheima.service;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.itheima.dao.ProvinceDao;
import com.itheima.model.Province;
import com.itheima.util.JedisUtil;
import redis.clients.jedis.Jedis;

import java.util.List;

public class ProvinceService {


    //实例dao
    private ProvinceDao provinceDao = new ProvinceDao();

    /**
     * 获取省份列表json数据
     * @return  String
     * @throws Exception
     */
    public String findAllProvince()throws Exception {
        //1.从redis里面获取json数据
        //获取jedis连接对象
        Jedis jedis = JedisUtil.getJedis();
        //获取json
        String jsonData = jedis.get("provinceList");
        //2.判断json数据有效性
        if(jsonData==null) {
            //2.1 如果json为空，去数据库获取省份列表数据List集合
            List<Province> provinceList =  provinceDao.findAllProvince();
            //2.2 判断List集合是否为空，不为空转换为json
            if(provinceList!=null && provinceList.size()>0) {
                jsonData = new ObjectMapper().writeValueAsString(provinceList);
                //2.3 将json写入redis
                jedis.set("provinceList",jsonData);
            }
        }
        jedis.close();//关闭连接，返回连接池
        //3.返回json
        return jsonData;
    }
}

ProvinceDao

package com.itheima.dao;

import com.itheima.model.Province;
import com.itheima.util.JDBCUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

import java.sql.SQLException;
import java.util.List;

public class ProvinceDao {

    private JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());


    /**
     * 获取数据库省份列表
     * @return List<Province>
     * @throws SQLException
     */
    public List<Province> findAllProvince()throws SQLException {
        String sql="select * from province";
        return jdbcTemplate.query(sql,new BeanPropertyRowMapper<Province>(Province.class));
    }
}