黑马就业班（02.JavaWeb+项目实战\14.Redis数据库）
- 本文参考自己的项目：myday14
今日内容
1. redis
1. 概念
2. 下载安装
3. 命令操作
1. 数据结构
4. 持久化操作
5. 使用Java客户端操作redis
1、Redis概念
redis是一款高性能的NOSQL系列的非关系型数据库。
1.什么是NOSQL
NoSQL(NoSQL = Not Only SQL)，意即“不仅仅是SQL”，是一项全新的数据库理念，泛指非关系型的数据库。
随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。
1.1.NOSQL和关系型数据库比较
优点：
1）成本：nosql数据库简单易部署，基本都是开源软件，不需要像使用oracle那样花费大量成本购买使用，相比关系型数据库价格便宜。
2）查询速度：nosql数据库将数据存储于缓存之中，关系型数据库将数据存储在硬盘中，自然查询速度远不及nosql数据库。
3）存储数据的格式：nosql的存储格式是key,value形式、文档形式、图片形式等等，所以可以存储基础类型以及对象或者是集合等各种格式，而数据库则只支持基础类型。
4）扩展性：关系型数据库有类似join这样的多表查询机制的限制导致扩展很艰难。
缺点：
1）维护的工具和资料有限，因为nosql是属于新的技术，不能和关系型数据库10几年的技术同日而语。
2）不提供对sql的支持，如果不支持sql这样的工业标准，将产生一定用户的学习和使用成本。
3）不提供关系型数据库对事务的处理。（Redis支持事务）
1.2.非关系型数据库的优势：
1）性能NOSQL是基于键值对的，可以想象成表中的主键和值的对应关系，而且不需要经过SQL层的解析，所以性能非常高。
2）可扩展性同样也是因为基于键值对，数据之间没有耦合性，所以非常容易水平扩展。
1.3. 关系型数据库的优势：
1）复杂查询可以用SQL语句方便的在一个表以及多个表之间做非常复杂的数据查询。
2）事务支持使得对于安全性能很高的数据访问要求得以实现。对于这两类数据库，对方的优势就是自己的弱势，反之亦然。
1.4. 总结
关系型数据库与NoSQL数据库并非对立而是互补的关系，即通常情况下使用关系型数据库，在适合使用NoSQL的时候使用NoSQL数据库，
让NoSQL数据库对关系型数据库的不足进行弥补。
一般会将数据存储在关系型数据库中，在nosql数据库中备份存储关系型数据库的数据（如缓存的应用）
-----------------------------------------------------------
2.主流的NOSQL产品
• 键值(Key-Value)存储数据库
相关产品： Tokyo Cabinet/Tyrant、Redis、Voldemort、Berkeley DB
典型应用： 内容缓存，主要用于处理大量数据的高访问负载。
数据模型： 一系列键值对
优势： 快速查询
劣势： 存储的数据缺少结构化
• 列存储数据库
相关产品：Cassandra, HBase, Riak
典型应用：分布式的文件系统
数据模型：以列簇式存储，将同一列数据存在一起
优势：查找速度快，可扩展性强，更容易进行分布式扩展
劣势：功能相对局限
• 文档型数据库
相关产品：CouchDB、MongoDB
典型应用：Web应用（与Key-Value类似，Value是结构化的）
数据模型： 一系列键值对
优势：数据结构要求不严格
劣势： 查询性能不高，而且缺乏统一的查询语法
• 图形(Graph)数据库
相关数据库：Neo4J、InfoGrid、Infinite Graph
典型应用：社交网络
数据模型：图结构
优势：利用图结构相关算法。
劣势：需要对整个图做计算才能得出结果，不容易做分布式的集群方案。
--------------------------------------------------------------------------
3 什么是Redis
Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库，官方提供测试数据，50个并发执行100000个请求,读的速度是110000次/s,写的速度是81000次/s ，且Redis通过提供多种键值数据类型来适应不同场景下的存储需求，目前为止Redis支持的键值数据类型如下：
1) 字符串类型 string
2) 哈希类型 hash
3) 列表类型 list
4) 集合类型 set
5) 有序集合类型 sortedset
1.3.1 redis的应用场景
• 缓存（数据查询、短连接、新闻内容、商品内容等等）
• 聊天室的在线好友列表
• 任务队列。（秒杀、抢购、12306等等）
• 应用排行榜
• 网站访问统计
• 数据过期处理（可以精确到毫秒
• 分布式集群架构中的session分离
2、下载安装
1. 官网：https://redis.io
2. 中文网：http://www.redis.net.cn/
3. 解压直接可以使用：解压后有一些文件，下面是几个重要文件的涵义
* redis.windows.conf：配置文件
* redis-cli.exe：redis的客户端
* redis-server.exe：redis服务器端
我们直接双击开启服务器端，随后再双击开启客户端，这样客户端就连接到服务器端，我们就可以在客户端输入命令进行数据的操作。
将来在使用Redis的时候，一般是部属在Linus操作系统上，现在先使用Windows，Redis在Windows与Linus中命令是相同的。
3、命令操作
3.1 redis的数据结构（重要）
* redis存储的是：key,value格式的数据，其中key都是字符串，value有5种不同的数据结构
* value的数据结构：
1) 字符串类型 string
2) 哈希类型 hash ： map格式
3) 列表（链表）类型 list ： 相当于linkedlist格式。支持重复元素，元素有顺序
4) 集合类型 set ： 相当于HashSet格式不允许重复元素
5) 有序集合类型 sortedset：不允许重复元素，且元素有顺序
关于上面的各种类型的数据结构，参考数据结构的内容。
- 各类数据类型的命令参考在线文档：Redis教程
- 技巧：在Redis客户端中，按键盘上下键就可以获取上一次输入的命令
3.2 字符串类型 string
1. 存储： set key value
127.0.0.1:6379> set username zhangsan
OK
2. 获取： get key
127.0.0.1:6379> get username
"zhangsan"
3. 删除： del key
127.0.0.1:6379> del age
(integer) 1
给同一个键多次赋值，后面的值会将前面的值覆盖。
3.3 哈希类型 hash
1. 存储： hset key field value
127.0.0.1:6379> hset myhash username lisi
(integer) 1
127.0.0.1:6379> hset myhash password 123
(integer) 1 （给myhash哈希表或者说是Map集合存储2个键值对）
2. 获取：
* hget key field: 获取指定的field对应的值
127.0.0.1:6379> hget myhash username （获取单个的时候要指定操作的哈希表与键）
"lisi"
* hgetall key：获取所有的field和value
127.0.0.1:6379> hgetall myhash
1) "username"
2) "lisi"
3) "password"
4) "123"
3. 删除： hdel key field
127.0.0.1:6379> hdel myhash username （删除单个的时候要指定操作的哈希表与键）
(integer) 1 （当然也可以删除整个哈希Map集合）
3.4 列表（链表）类型 list
Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）
1. 添加：list允许重复添加
1. lpush key value: 将元素加入列表左表
2. rpush key value：将元素加入列表右边
127.0.0.1:6379> lpush myList a
(integer) 1
127.0.0.1:6379> lpush myList b
(integer) 2
127.0.0.1:6379> rpush myList c
(integer) 3
2. 获取：
* lrange key start end ：范围获取
127.0.0.1:6379> lrange myList 0 -1（注意，获取所有是0到-1）
1) "b"
2) "a"
3) "c"
3. 删除：
* lpop key： 删除列表最左边的元素，并将元素返回（这两种也相当于获取一个元素）
* rpop key： 删除列表最右边的元素，并将元素返回
3.5 集合类型 set ： 不允许重复元素，没有顺序
1. 存储：sadd key value
127.0.0.1:6379> sadd myset a b c（可以一次性添加多个元素）
(integer) 1
127.0.0.1:6379> sadd myset a（如果添加重复的元素，会失败）
(integer) 0
2. 获取：smembers key:获取set集合中所有元素
127.0.0.1:6379> smembers myset
1) "a"
3. 删除：srem key value:删除set集合中的某个元素（如果删除的元素不存在则删除失败）
127.0.0.1:6379> srem myset a
(integer) 1
3.6 有序集合类型 sortedset
不允许重复元素，且元素有顺序。每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
1. 存储：zadd key score value
127.0.0.1:6379> zadd mysort 60 zhangsan（在设置值的时候先设置一个double类型的分数）
(integer) 1
127.0.0.1:6379> zadd mysort 50 lisi
(integer) 1
127.0.0.1:6379> zadd mysort 80 wangwu
(integer) 1
2. 获取：zrange key start end [withscores]
127.0.0.1:6379> zrange mysort 0 -1
1) "lisi"
2) "zhangsan"
3) "wangwu"
127.0.0.1:6379> zrange mysort 0 -1 withscores
1) "zhangsan"
2) "60"
3) "wangwu"
4) "80"
5) "lisi"
6) "500"
3. 删除：zrem key value
127.0.0.1:6379> zrem mysort lisi
(integer) 1
有序的查询使用range（如List、sortedset），无序的查询使用members（如set）。
3.7 通用命令
1. keys * : 查询所有的键
2. type key ： 获取键对应的value的类型
3. del key：删除指定的key value
4、持久化
redis是一个内存数据库，当redis服务器重启，获取电脑重启，数据会丢失，我们可以将redis内存中的数据持久化保存到硬盘的文件中。这样Redis数据库重启的时候，它会自动加载硬盘中的数据到内存中。
redis持久化机制：
RDB
1. RDB：默认方式，不需要进行配置，默认就使用这种机制（对性能影响较小）
* 在一定的间隔时间中，检测key的变化情况，然后持久化数据
1. 编辑redis.windwos.conf文件
# after 900 sec (15 min) if at least 1 key changed
save 900 1 （在900秒内如果键值修改过1次就将数据保存到硬盘）
# after 300 sec (5 min) if at least 10 keys changed
save 300 10
# after 60 sec if at least 10000 keys changed
save 60 10000
2. 修改RDB配置后，必须在当前页面打开cmd命令行，重新启动redis服务器，并指定配置文件名称
redis-server.exe redis.windows.conf
这样才能使得修改生效
我们修改“redis.windows.conf”文件中的配置为如下并保存。
save 900 1
save 300 10
save 15 3 （15秒内如果有超过3个数据发生变化就将数据存储到硬盘）
这个时候关闭Redis客户端和服务器，这个时候之前的Redis数据会被清除。这个时候不能直接启动服务器，用“按住shift-右键-打开命令行”，打开Redis解压页面的命令行后，然后找到客户端以及相应的配置文件的名称“.\redis-server.exe redis.windows.conf”（加“.\”表示信任此命令），这样就启动了服务器，并且执行了RDB持久化修改的操作。接下来就可以点击启动客户端。
我们在15秒内实现3个数据的变化，发现Redis的路径下出现一个“dump.rdb”的文件，这个文件就是RDB方式将Redis的数据持久化存储到硬盘。我们关闭服务器和客户端浏览器，再双击重启服务器和客户端，还是可以找到之前存储的数据。
当然，我们可以根据自己的需求修改这些数据，但是目前先不要修改。其实我们不修改，根据之前的设定，5min中有10次改变、15min中有1次改变，60sec中有10000次改变，且中间我们不关闭浏览器和服务器，数据也会被保存到硬盘的dump.rdb。
- 注意，我们测试后要将设置还原，按前面那种方法，进入Redis解压页面的命令行并指定配置文件打开服务器：“.\redis-server.exe redis.windows.conf”，这样配置才生效。之后就可以正常双击打开服务器和客户端。
AOF
2. AOF：日志记录的方式，可以记录每一条命令的操作。可以每一次命令操作后，持久化数据（对性能影响较大）
编辑redis.windwos.conf文件，找到如下命令并修改
appendonly no（关闭aof） --> appendonly yes （开启aof）
随后，往下找到下面三个参数
# appendfsync always ： 每一次操作都进行持久化
appendfsync everysec ： 每隔一秒进行一次持久化
# appendfsync no ： 不进行持久化
测试：进入Redis解压页面的命令行并指定配置文件打开服务器：“.\redis-server.exe redis.windows.conf”，使得配置文件生效并打开服务器，随后双击打开客户端。
我们关闭服务器和客户端浏览器，再双击重启服务器和客户端，发现这样普通双击打开的方式无法找到之前存储的数据。我们还是进入Redis解压页面的命令行并指定配置文件打开服务器：“.\redis-server.exe redis.windows.conf”，使得配置文件生效并打开服务器。发现可以找到之前存储的数据。
注意测试后按前面的方式将参数修改“appendonly no”。
- 注意：RDB的方式修改后，双击服务器和客户端重新打开，可以找到前一次设置的数据；但是AOF修改后关闭服务器客户端，双击重启无法找到之前设置的数据，必须进入Redis解压页面的命令行并指定配置文件打开服务器：“.\redis-server.exe redis.windows.conf”，再双击打开客户端，这样才能找到之前设置的数据。（2中方式操作不同）。
5、Java客户端 Jedis
Jedis: 一款java操作redis数据库的工具。（类似于之前的JDBC，同样是在java项目中导入相应的包，在java中获取链接数据库并操作数据库 ）
使用步骤：
1. 下载jedis的jar包，并导入项目web.WEB-INF.lib目录下
commons-pool2-2.3.jar：redis连接池
jedis-2.7.0.jar：redis对应的jar包
2. 使用
//1. 获取连接
Jedis jedis = new Jedis("localhost",6379);
//2. 操作
jedis.set("username","zhangsan");
//3. 关闭连接
jedis.close();
测试（只贴核心代码）：
/**
* 快速入门：使用java代码操作数据库
*/
@Test
public void test1()
{
/*
注意，必须先在Redis的解压目录下开启服务器，我们才可以获取连接并操作
*/
//1. 获取连接
Jedis je = new Jedis("localhost" , 6379);//第一个参数指定访问主机的主机或者IP地址（可以是本地也可以是远程），第二个参数是访问的端口（默认Jedis端口是6379）
//2.使用java操作jedis
je.set("name" , "zhangsan");//与之前介绍的Jedis客户端中的操作类似
//3.关闭连接
je.close();
/*
Jedis客户端先查询“keys *”，没有数据，执行test1()后再查询：1) "name"
*/
}
Jedis操作各种redis中的数据结构
- 更多的方法请查询Jedis中文网文档
1、字符串类型 string
测试（只贴核心代码）
/**
* string 数据结构操作
*/
@Test
public void test2()
{
//1. 获取连接
Jedis je = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
//2. 操作
je.set("username" , "lisi");//存储
String username = je.get("username");//获取
System.out.println(username);
//可以使用setex()方法存储可以指定过期时间的 key value
je.setex("activecode" , 30 , "haha");//将activecode：hehe键值对存入redis，并且30秒后自动删除该键值对
//3. 关闭连接
je.close();
}
**2、哈希类型 hash ： map格式 **
测试（只贴核心代码）
/**
* hash 数据结构操作
*/
@Test
public void test3()
{
//1. 获取连接
Jedis je = new Jedis();
//2. 操作
//存储键值对
je.hset("user" , "name" , "lisi");
je.hset("user" , "age" , "23");//注意Redis存储的数据都是以字符串存储，因此设置的时候，即使是数字也应该当做字符串处理
je.hset("user" , "sex" , "male");
//获取
String age = je.hget("user", "age");
System.out.println(age);//23
Map<String, String> user = je.hgetAll("user");
Set<String> keys = user.keySet();
for (String key : keys)
{
String value = user.get(key);
System.out.println(key+":"+value);
}
//3. 关闭连接
je.close();
}
3、列表类型 list ： linkedlist格式。支持重复元素
测试（只贴核心代码）
/**
* list 数据结构操作
*/
@Test
public void test4()
{
//1. 获取连接
Jedis je = new Jedis();
//2. 操作
//存储数据
je.lpush("mylist" , "a","b","c");//从左侧存储进入，一次可以存储多个值，且值可以重复
je.rpush("mylist" , "a","b","c");//从右侧存储进入
//查询全部数据
List<String> mylist = je.lrange("mylist", 0, -1);
System.out.println(mylist);//[c, b, a, a, b, c]
//清除数据
je.lpop("mylist");//c
je.rpop("mylist");//c
List<String> mylist1 = je.lrange("mylist", 0, -1);
System.out.println(mylist1);[b, a, a, b]
//3. 关闭连接
je.close();
}
4、集合类型 set ： 不允许重复元素
测试（只贴核心代码）
/**
* set 数据结构操作
*/
@Test
public void test5()
{
//1. 获取连接
Jedis je = new Jedis();
//2. 操作
je.sadd("set" ,"a","b","c","d");//存储数据
Set<String> myset = je.smembers("set");
System.out.println(myset);
je.srem("set","b");
Set<String> myset1 = je.smembers("set");//set没有顺序，取出的时候获取全部，不能指定从哪里到哪里获取
System.out.println(myset1);
//3. 关闭连接
je.close();
}
5、有序集合类型 sortedset：不允许重复元素，且元素有顺序
测试（只贴核心代码）
/**
* sortedset 数据结构操作
*/
@Test
public void test6()
{
//1. 获取连接
Jedis je = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
//2. 操作
// sortedset 存储
je.zadd("sort", 12, "aa");
je.zadd("sort", -2, "bb");
je.zadd("sort", 122, "cc");
//获取
Set<String> sort = je.zrange("sort", 0, -1);//sortedset元素不可重复但是有顺序，可以使用range指定从哪个到哪个获取
System.out.println(sort);//[bb, aa, cc]
//3. 关闭连接
je.close();
}
jedis连接池： JedisPool
Jedis连接池的使用步骤如下：
1. 创建JedisPool连接池对象
2. 调用方法 getResource()方法获取Jedis连接
Jedis的连接池Jedis开发方就有提供，就是导入之前的“commons-pool2-2.3.jar：redis连接池”包。而JDBC的连接池开发方并没有提供，都是第三方开发的连接池。
关于连接池配置对象参数的设定，参考文章：添加链接描述
另外，也可以参考自己电脑：D:\资源\黑马就业班\00.讲义+笔记+资料\JavaWeb\27.会员版(2.0)-就业课(2.0)-Redis\day14_redis\资料\jedis 路径下的文件：jedis详细配置.properties
测试代码
/**
* jedis连接池使用
*/
@Test
public void test7()
{
//1.创建一个配置对象
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(50);//设置整个连接池最大连接数
config.setMaxIdle(10);//设置最多维持的空闲连接数
//2.创建连接池对象
JedisPool jp = new JedisPool(config , "localhost" , 6379);//我们也可以使用空参的方式创建连接池对象
//参数：连接池配置对象、连接主机的名或IP，端口（默认6379）
//3.获取Jedis数据库连接
Jedis je = jp.getResource();
//4.使用
je.set("gender" , "male");
//5. 关闭 归还到连接池中
je.close();;
}
连接池工具类的抽取
src下创建lkj.jedis.util包，下面放Jedis连接池工具类：JedisPoolUtils.java ，同时创建jedis连接池的配置文件jedis.properties，放在src下就可以。
//工具类JedisPoolUtil.java
package lkj.jedis.util;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
JedisPool工具类
加载配置文件，配置连接池的参数
提供获取连接的方法
*/
public class JedisPoolUtils
{
//为了下面方法可以使用，先在外面创建一个空的连接池对象
private static JedisPool jedispool;
//首先，同样通过静态代码块来加载配置连接池对象
static
{
//首先，获取配置文件jedis.properties的读取流
InputStream resourceAsStream = JedisPoolUtils.class.getClassLoader().getResourceAsStream("jedis.properties");
//其次，创建Properties对象
Properties pro = new Properties();
//将文件jedis.properties的读取流放入Properties对象加载，关联文件
try
{
pro.load(resourceAsStream);
}
catch (IOException e)
{
e.printStackTrace();
}
//1、获取Jedis连接池配置对象
JedisPoolConfig config = new JedisPoolConfig();
//设置参数
config.setMaxTotal(Integer.parseInt(pro.getProperty("maxTotal")));//将Properties对象读取的jedis.properties文件的maxTotal值转换为int类型
config.setMaxIdle(Integer.parseInt(pro.getProperty("maxIdle")));
//2、创建连接池对象
jedispool = new JedisPool(config , pro.getProperty("host") , Integer.parseInt(pro.getProperty("port")));//host不需要转换为int，port需要转换为int
}
/**
* 获取连接方法
*/
public static Jedis getJedis()
{
return jedispool.getResource();
}
}
//测试代码
/**
* jedis连接池工具类使用
*/
@Test
public void test8()
{
//通过连接池工具类获取Jedis数据库连接
Jedis jedis = JedisPoolUtils.getJedis();//通过类名直接调用静态方法
//使用
jedis.set("hello","world");
//关闭 归还到连接池中
jedis.close();;
}
案例
案例需求：
1. 提供index.html页面，页面中有一个省份 下拉列表
2. 当 页面加载完成后 发送ajax请求，加载所有省份
* 注意：使用redis缓存一些不经常发生变化的数据，数据库的数据一旦发生改变，则需要更新缓存。既数据库的表执行 增删改的相关操作，需要将redis缓存数据清空并再次存入。因此，在service调用dao的增删改方法的时候，将redis数据删除重新加载。
step1
首先，在SQLyog中创建MYSQL数据库day23，创建表province，并插入数据，相应的SQL代码如下：
CREATE DATABASE day23; -- 创建数据库
USE day23; -- 使用数据库
CREATE TABLE province( -- 创建表
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL
);
-- 插入数据
INSERT INTO province VALUES(NULL,'北京');
INSERT INTO province VALUES(NULL,'上海');
INSERT INTO province VALUES(NULL,'广州');
INSERT INTO province VALUES(NULL,'陕西');
SELECT * FROM province;
step2
搭建环境，将所需jar包放入项目。当然，Redis相关的2个包我们之前导入。同时，将druid的配置文件druid.properties放到src目录下，注意将数据库修改为我们使用的数据库。另外，我们的HTML页面需要使用JQuery来简化JS的使用，需要在web下创建一个js文件，放入JQuery相关的文件（注意这两个是JS的JQuery框架文件，不是jar包，不能放到lib下）。
随后我们创建相应的各层的包，用于放置各类文件，包的设置与之前所说的三层架构的包的设置相同。
理清各种工具的使用逻辑：我们需要在HTML页面使用Ajax来发送异步请求给Servlet并接收JSON封装的数据，我们需要使用JQuery的方式来实现Ajax（使用JS原生代码的方式实现Ajax太麻烦）。因为页面中需要使用JS来操作页面的标签，我们需要使用JQuery可以简化JS对象的操作。而在Servlet中，我们使用ObjectMapper类，将java的List集合抓换为JSON并发送回页面。
step3
首先，编写后台代码。我们创建一个对应数据库province表的domain类Province.java，编写service层的方法以及dao层的方法，包括接口和实现方法。然后我们创建Servlet。（我们只贴实现类的方法）
----Province
package lkj.domain;
public class Province
{
private int id;
private String name;
public int getId()
{
return id;
}
public void setId(int id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
@Override
public String toString()
{
return "Province{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
----ProvinceServiceImpl
package lkj.service.impl;
import lkj.dao.ProvinceDao;
import lkj.dao.impl.ProvinceDaoImpl;
import lkj.domain.Province;
import lkj.service.ProvinceService;
import java.util.List;
public class ProvinceServiceImpl implements ProvinceService
{
//创建ProvinceDaoImpl对象，使用这个对象调用dao的findAll()方法
private ProvinceDao dao = new ProvinceDaoImpl();
@Override
public List<Province> findAll()
{
return dao.findAll();
}
}
----ProvinceDaoImpl
package lkj.dao.impl;
import lkj.dao.ProvinceDao;
import lkj.domain.Province;
import lkj.util.JDBCUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.List;
public class ProvinceDaoImpl implements ProvinceDao
{
//1.声明成员变量 jdbctemplement
private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
@Override
public List<Province> findAll()
{
//1、创建查询所有province表数据的SQL语句
String sql = "select * from province ";
//查询
List<Province> list = template.query(sql, new BeanPropertyRowMapper<Province>(Province.class));
return list;
}
}
----ProvinceServlet
package lkj.web.servlet;
import com.fasterxml.jackson.databind.ObjectMapper;
import lkj.domain.Province;
import lkj.service.ProvinceService;
import lkj.service.impl.ProvinceServiceImpl;
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;
import java.util.List;
@WebServlet("/provinceServlet")
public class ProvinceServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//1.调用service查询
ProvinceService service = new ProvinceServiceImpl();
List<Province> list = service.findAll();
//2.序列化list为json
ObjectMapper om = new ObjectMapper();
String json = om.writeValueAsString(list);
//3.响应结果
response.setContentType("application/json;charset=utf-8");//注意，设置响应消息的MIME类型与字符集
response.getWriter().write(json);
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.doPost(request, response);
}
}
step4
首先，编写前台代码。我们创建一个index.html页面。
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Titletitle>
<script src="js/jquery-3.3.1.min.js">script>
<script>
$(function () {
//发送ajax请求，加载所有省份数据（使用JQuery的方式创建Ajax）
//不需要发送请求数据，请求参数写{}，Ajax中请求url前面不需要加“/”
$.get("provinceServlet",{},function (data) {
//获取的数据的格式：[{"id":1,"name":"北京"},{"id":2,"name":"上海"},{"id":3,"name":"广州"},{"id":4,"name":"陕西"}]
//1.获取select的JQ对象
var province = $("#province");
//2.遍历json数组
/*
注意，JSON对象既可以使用for..in..与普通的for循环来遍历，也可以使用JQuery的each方法来遍历。
如果我们的JSON数据想使用JQuery的方法，必须将JSON数据转换为JQuery数据！
注意，JSON是JS对象的表示法，既它也是JS，那么我们也可以将JSON转换为JQ对象并使用JQ的方法！
*/
$(data).each(function () {
//3.创建
var option = "+this.name+"";//此处的this代表当前遍历到的JSON对象
//4.调用select的append追加option
province.append(option);
});
});
});
script>
head>
<body>
<select id="province">
<option>--请选择省份--option>
select>
body>
html>
随后我们访问：http://localhost/index.html，发现下拉列表的数据已经加载进来。
我们发现每一次刷新都要访问数据库，十分耗时。而省份的数据又不是经常变化的，我们可以设置一个Redis缓存，每次ProvinceService查询的时候都先去查询缓存，没有再查询数据库。（注意，是在service层判断，因为service层处理复杂逻辑）。
我们在service层创建一个findAllJson()的方法，这个方法返回字符串形式的JSON数据，然后再ProvinceServlet中调用findAllJson方法，返回一个String类型的JSON数据，再对数据进行处理。
我们需要修改2处代码，ProvinceServlet与ProvinceServiceImpl。
—ProvinceServiceImpl
package lkj.service.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lkj.dao.ProvinceDao;
import lkj.dao.impl.ProvinceDaoImpl;
import lkj.domain.Province;
import lkj.jedis.util.JedisPoolUtils;
import lkj.service.ProvinceService;
import redis.clients.jedis.Jedis;
import java.util.List;
public class ProvinceServiceImpl implements ProvinceService
{
//创建ProvinceDaoImpl对象，使用这个对象调用dao的findAll()方法
private ProvinceDao dao = new ProvinceDaoImpl();
@Override
public List<Province> findAll()
{
return dao.findAll();
}
@Override
public String findAllJson()
{
//1.先从redis中查询数据
Jedis jedis = JedisPoolUtils.getJedis();//先获取Jedis数据库连接
String province_json = jedis.get("province");//获取Jedis数据库中的JSON数据
//2判断 province_json 数据是否为null
if(province_json == null || province_json.length() == 0)
{
System.out.println("redis中没数据，请查询数据库...");//redis中没有数据
//调用findAll方法查询数据库
List<Province> list = dao.findAll();
//将list转换为JSON
ObjectMapper om = new ObjectMapper();
try
{
province_json = om.writeValueAsString(list);//将list转换的JSON存储到province_json
}
catch (JsonProcessingException e)
{
e.printStackTrace();
}
//将list转换的json存储到Redis
jedis.set("province", province_json);
//归还连接
jedis.close();
}
else
{
System.out.println("redis中有数据，查询缓存...");
}
return province_json;//将获取到的Jedis数据库中的JSON数据直接返回
}
}
—ProvinceServlet
package lkj.web.servlet;
import com.fasterxml.jackson.databind.ObjectMapper;
import lkj.domain.Province;
import lkj.service.ProvinceService;
import lkj.service.impl.ProvinceServiceImpl;
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;
import java.util.List;
@WebServlet("/provinceServlet")
public class ProvinceServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//1.调用service查询JSON
ProvinceService service = new ProvinceServiceImpl();
String json = service.findAllJson();
//2.响应结果
response.setContentType("application/json;charset=utf-8");//注意，设置响应消息的MIME类型与字符集
response.getWriter().write(json);
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.doPost(request, response);
}
}