学习地址：黑马最新JavaWeb入门到入土（idea版）day22-23的课程
配套资源：Ajax&Json基础学习和redis基础学习.zip
压缩包文件内容：
一、Ajax
1、Ajax 是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。
2、实现方式：
（1）原生的JS实现方式（了解，用得不多）
1）页面：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>01-原生JS实现ajax </title>
<script>
function fun() {
// 发送异步请求
// 1. 创建和新对象
var xmlhttp;
if(window.XMLHttpRequest)
{ // code for IE7+, Firefox, Chrome, Opera, Safari
xmlhttp = new XMLHttpRequest();
}
else
{ // code for IE6, IE5
xmlhttp = new ActiveXObject("Mircosoft.XMLHTTP");
}
// 2.建立连接
/*
参数：
1. 请求方式：GET、POST
* get方式，请求参数在URL后边拼接。send方法为空参
* post方式，请求参数在send方法中定义
2. 请求的URL：
3. 同步或异步请求：true（异步）或 false（同步）
*/
xmlhttp.open("GET","ajaxServlet?username=tom",true); // 异步请求
// 3.发送请求
xmlhttp.send();
//4.接受并处理来自服务器的响应结果
//获取方式 ：xmlhttp.responseText
//什么时候获取？当服务器响应成功后再获取
//当xmlhttp对象的就绪状态改变时，触发事件onreadystatechange。
xmlhttp.onreadystatechange = function () {
//判断readyState就绪状态是否为4，判断status响应状态码是否为200
if(xmlhttp.readyState == 4 && xmlhttp.status == 200)
{
// 获取服务器的响应结果
var responseText = xmlhttp.responseText;
alert(responseText);
}
}
}
</script>
</head>
<body>
<input type="button" value="发送异步请求" onclick="fun();">
<input>
</body>
</html>
2）创建对应Servlet：
package cn.itcast.web.servlet;
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;
/**
* @author huan
* @create 2020-07-05 23:29
*/
@WebServlet("/ajaxServlet")
public class AjaxServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 1. 获取请求参数
String username = request.getParameter("username");
// 处理业务逻辑，耗时
try {
Thread.sleep(5000); //处理5秒钟
} catch (InterruptedException e) {
e.printStackTrace();
}
// 2.打印username
System.out.println(username);
// 3.响应
response.getWriter().write("hello:"+username);
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.doPost(request, response);
}
}
3）运行：
当页面中没有文本框时，点击页面的“发送异步请求”按钮后，5秒后可以在控制台看到输出语句username “tom”，在页面弹出框中显示“hello tom”。
有文本框后，若点击整体刷新，则输入在文本框中的内容就会消失。但若只是点击按钮“发送异步请求”，文本框内容还在，即实现了局部刷新。
（2）JQeury实现方式
1）$.ajax()
Servlet没有改变，页面代码：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>01-原生JS实现ajax </title>
<script src="js/jquery-3.3.1.min.js"></script>
<script>
function fun() {
//使用$.ajax()发送异步请求
$.ajax({
url:"ajaxServlet", // 请求路径
type:"POST", //请求方式,默认是GET
//data: "username=jack&age=23", //请求参数
data:{"username":"jack","age":23}, //请求参数，JSON的数据格式
//响应成功后的回调函数
success:function (data) {
alert(data);
},
//表示如果请求响应出现错误，会执行的回调函数，请求路径错误等等
error:function () {
alert("出错了。。。")
},
//设置接受到的响应数据的格式
dataType:"text"
});
}
</script>
</head>
<body>
<input type="button" value="发送异步请求" onclick="fun();">
<input>
</body>
</html>
2） $.get()：发送get请求
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>03-JQuery实现方式2_get </title>
<script src="js/jquery-3.3.1.min.js"></script>
<script>
function fun() {
$.get("ajaxServlet",{username:"rose"},function (data) {
alert(data);
},"text");
}
</script>
</head>
<body>
<input type="button" value="发送异步请求" onclick="fun();">
<input>
</body>
</html>
3）$.post()：发送post请求
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>04-JQuery实现方式3_post </title>
<script src="js/jquery-3.3.1.min.js"></script>
<script>
function fun() {
$.post("ajaxServlet",{username:"rose"},function (data) {
alert(data);
},"text");
}
</script>
</head>
<body>
<input type="button" value="发送异步请求" onclick="fun();">
<input>
</body>
</html>
二、JSON
（1）获取数据
1）json对象.键名
2） json对象[“键名”]
3） 数组对象[索引]
4）遍历
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>05-json数据语法</title>
</head>
<body>
<script>
var person = {"name": "张三", age: 23, 'gender': true};
var ps = [{"name": "张三", "age": 23, "gender": true},
{"name": "李四", "age": 24, "gender": true},
{"name": "王五", "age": 25, "gender": false}];
//获取person对象中所有的键和值
//for in 循环
/* for(var key in person){
//alert(key + ":" + person.key); //这样的方式获取不行。因为相当于 person."name"
console.log(key+":"+person[key]);
}*/
//获取ps中的所有值
for (var i = 0; i < ps.length; i++) {
var p = ps[i];
for(var key in p){
console.log(key+":"+p[key]);
console.log("循环一次");
}
}
</script>
</body>
</html>
（2）JSON数据和Java对象的相互转换
package cn.itcast.test;
import cn.itcast.domain.Person;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Test;
import java.io.File;
import java.io.FileWriter;
import java.util.*;
/**
* @author huan
* @create 2020-07-06 17:47
*/
public class JacksonTest {
//Java对象转为JSON字符串
@Test
public void test1() throws Exception {
// 创建Person对象
Person p = new Person();
p.setName("张三");
p.setAge(23);
p.setGender("男");
// 2.创建Jackson的和新对象， ObjectMapper
ObjectMapper mapper = new ObjectMapper();
// 3.调用方法转换
/*
转换方法：
writeValue(参数1，obj):
参数1：
File：将obj对象转换为JSON字符串，并保存到指定的文件中
Writer：将obj对象转换为JSON字符串，并将json数据填充到字符输出流中
OutputStream：将obj对象转换为JSON字符串，并将json数据填充到字节输出流中
writeValueAsString(obj):将对象转为json字符串
*/
String json = mapper.writeValueAsString(p);
//JSON格式：{"name":"张三","age":23,"gender":"男"}
//System.out.println(json);//{"name":"张三","age":23,"gender":"男"}
//writeValue，将数据写到a.txt文件中
// mapper.writeValue(new File("a.txt"),p);
//writeValue.将数据关联到Writer中
mapper.writeValue(new FileWriter("b.txt"),p);
}
// 测试 @JsonFormat(pattern = "yyyy-MM-dd") 和 @JsonIgnore // 忽略该属性
@Test
public void test2() throws Exception {
//1.创建Person对象
Person p = new Person();
p.setName("张三");
p.setAge(23);
p.setGender("男");
p.setBirthday(new Date());
//2.转换
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(p);
System.out.println(json);//{"name":"张三","age":23,"gender":"男","birthday":1530958029263}
//{"name":"张三","age":23,"gender":"男","birthday":"2018-07-07"}
}
// 测试3. 复杂java对象转换
//1. List：数组
@Test
public void test3() throws Exception {
//1.创建Person对象
Person p = new Person();
p.setName("张三");
p.setAge(23);
p.setGender("男");
p.setBirthday(new Date());
Person p1 = new Person();
p1.setName("张三");
p1.setAge(23);
p1.setGender("男");
p1.setBirthday(new Date());
Person p2 = new Person();
p2.setName("张三");
p2.setAge(23);
p2.setGender("男");
p2.setBirthday(new Date());
//创建List集合
List<Person> ps = new ArrayList<Person>();
ps.add(p);
ps.add(p1);
ps.add(p2);
//2.转换
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(ps);
// [{},{},{}]
//[{"name":"张三","age":23,"gender":"男","birthday":"2018-07-07"},{"name":"张三","age":23,"gender":"男","birthday":"2018-07-07"},{"name":"张三","age":23,"gender":"男","birthday":"2018-07-07"}]
System.out.println(json);
}
// 测试3. 复杂java对象转换
//2. Map：对象格式一致
@Test
public void test4() throws Exception {
//1.创建map对象
Map<String,Object> map = new HashMap<String,Object>();
map.put("name","张三");
map.put("age",23);
map.put("gender","男");
//2.转换
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(map);
//{"name":"张三","age":23,"gender":"男"}
System.out.println(json);//{"gender":"男","name":"张三","age":23}
}
//演示 JSON字符串转为Java对象
@Test
public void test5() throws Exception {
//1.初始化JSON字符串
String json = "{\"gender\":\"男\",\"name\":\"张三\",\"age\":23}";
//2.创建ObjectMapper对象
ObjectMapper mapper = new ObjectMapper();
//3.转换为Java对象 Person对象
Person person = mapper.readValue(json, Person.class);
System.out.println(person);
}
}
三、案例：校验用户名是否存在
（1）需求：校验用户名是否存在，当鼠标离焦时，查询该用户名是否已经注册
（2）服务器响应的数据，在客户端使用时，要想当做json数据格式使用。有两种解决方案：
- $.get(type):将最后一个参数type指定为"json"
- 在服务器端设置MIME类型
response.setContentType(“application/json;charset=utf-8”);
（3）代码实现：
1）前端页面：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<script src="js/jquery-3.3.1.min.js"></script>
<script>
//在页面加载完成后
$(function () {
// 给username绑定事件
$("#username").blur(function () {
// 获取文本框输入的值
var username = $(this).val();
/*期望服务器响应回的数据格式：{"userExsit":true,"msg":"此用户名太受欢迎,请更换一个"}
* {"userExsit":false,"msg":"用户名可用"}*/
$.get("findUserServlet",{username:username},function (data) {
// 判断userExsit键的值是否是true
//alert(data);
var span = $("#s_username");
if(data.userExsit){
// 用户名存在
span.css("color","red");
span.html(data.msg);
}else{
// 用户名不存在
span.css("color","green");
span.html(data.msg);
}
});
});
});
</script>
</head>
<body>
<form>
<input type="text" id="username" name="username" placeholder="请输入用户名">
<span id="s_username"></span><br>
<input type="password" name="password" placeholder="请输入密码"><br>
<input type="submit" value="注册"><br>
</form>
</body>
</html>
2）对应Servlet：
package cn.itcast.web.servlet;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.sun.xml.internal.ws.runtime.config.TubelineFeatureReader;
import javafx.beans.binding.ObjectExpression;
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.HashMap;
import java.util.Map;
/**
* @author huan
* @create 2020-07-07 0:17
*/
@WebServlet("/findUserServlet")
public class FindUserServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 1.获取用户名
String username = request.getParameter("username");
//2.调用service层判断用户名是否存在
//期望服务器响应回的数据格式：{"userExsit":true,"msg":"此用户名太受欢迎,请更换一个"}
// {"userExsit":false,"msg":"用户名可用"}
//设置响应的数据格式为json
response.setContentType("application/json;charset=utf-8");
Map<String,Object> map = new HashMap<String, Object>();
if("tom".equals(username)){ //假设service查询到的名字是tom
// 存在
map.put("userExsit", true);
map.put("msg","此用户太受欢迎，请更换一个");
}else {
// 不存在
map.put("userExit",false);
map.put("msg","此用户名可用");
}
// 将map转为json，并且传递给客户端
// 将map转为json
ObjectMapper mapper = new ObjectMapper();
// 并且传递给客户端
mapper.writeValue(response.getWriter(),map);
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.doPost(request, response);
}
}
3）运行效果：
从Network可以看出，鼠标离开input后，即向后台发送请求。
四、Redis
1、概念
-
概念： redis是一款高性能的NOSQL系列的非关系型数据库。
-
Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库，官方提供测试数
据，50个并发执行100000个请求,读的速度是110000次/s,写的速度是81000次/s ，且Redis通过
提供多种键值数据类型来适应不同场景下的存储需求，目前为止Redis支持的键值数据类型如下：
1） 字符串类型 string
2）哈希类型 hash
3）列表类型 list
4）集合类型 set
5）有序集合类型 sortedset -
redis的应用场景
• 缓存（数据查询、短连接、新闻内容、商品内容等等）
• 聊天室的在线好友列表
• 任务队列。（秒杀、抢购、12306等等）
• 应用排行榜
• 网站访问统计
• 数据过期处理（可以精确到毫秒
• 分布式集群架构中的session分离
2、NOSQL和关系型数据库比较
优点：
1）成本：nosql数据库简单易部署，基本都是开源软件，不需要像使用oracle那样花费大量成本购买使用，相比关系型数据库价格便宜。
2）查询速度：nosql数据库将数据存储于缓存之中，关系型数据库将数据存储在硬盘中，自然查询速度远不及nosql数据库。 速度快
3）存储数据的格式：nosql的存储格式是key,value形式、文档形式、图片形式等等，所以可以存储基础类型以及对象或者是集合等各种格式，而数据库则只支持基础类型。 格式更丰富
4）扩展性：关系型数据库有类似join这样的多表查询机制的限制导致扩展很艰难。
缺点：
1）维护的工具和资料有限，因为nosql是属于新的技术，不能和关系型数据库10几年的技术同日而语。
2）不提供对sql的支持，如果不支持sql这样的工业标准，将产生一定用户的学习和使用成本。
3）不提供关系型数据库对事务的处理。
3、Redis的使用
（1）下载安装：
- 官网：https://redis.io
- 中文网：http://www.redis.net.cn/
- 解压直接可以使用：
1）redis.windows.conf：配置文件
2）redis-cli.exe：redis的客户端
3）redis-server.exe：redis服务器端
使用的时候，一般都是部署在Linux的操作系统上。
（2）redis的数据结构：
redis的数据结构：
-
redis存储的是：key,value格式的数据，其中key都是字符串，value有5种不同的数据结构
-
value的数据结构：
1）字符串类型 string
2）哈希类型 hash ： map格式
3）列表类型 list ： linkedlist格式。支持重复元素
4）集合类型 set ： 不允许重复元素
5）有序集合类型 sortedset：不允许重复元素，且元素有顺序
（3）字符串类型 string
- 存储： set key value
127.0.0.1:6379> set username zhangsan
OK
- 获取： get key
127.0.0.1:6379> get username
"zhangsan"
- 删除： del key
127.0.0.1:6379> del age
(integer) 1
（4）哈希类型hash
- 存储： 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
- 获取：
- 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"
- 删除： hdel key field
127.0.0.1:6379> hdel myhash username
(integer) 1
（5）列表类型 list:可以添加一个元素到列表的头部（左边）或者尾部（右边）
- 添加：
- lpush key value: 将元素加入列表左表
- 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
- 获取：
- lrange key start end ：范围获取
127.0.0.1:6379> lrange myList 0 -1
1) "b"
2) "a"
3) "c"
- 删除：
- lpop key： 删除列表最左边的元素，并将元素返回
- rpop key： 删除列表最右边的元素，并将元素返回
（6）集合类型set：不允许重复元素
- 存储：sadd key value
127.0.0.1:6379> sadd myset a
(integer) 1
127.0.0.1:6379> sadd myset a
(integer) 0
- 获取：smembers key:获取set集合中所有元素
127.0.0.1:6379> smembers myset
1) "a"
- 删除：srem key value:删除set集合中的某个元素
127.0.0.1:6379> srem myset a
(integer) 1
（7）有序集合类型 sortedset：不允许重复元素，且元素有顺序.每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
- 存储：zadd key score value
127.0.0.1:6379> zadd mysort 60 zhangsan
(integer) 1
127.0.0.1:6379> zadd mysort 50 lisi
(integer) 1
127.0.0.1:6379> zadd mysort 80 wangwu
(integer) 1
- 获取：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"
- 删除：zrem key value
127.0.0.1:6379> zrem mysort lisi
(integer) 1
（8）通用命令
- keys * : 查询所有的键
- type key ： 获取键对应的value的类型
- del key：删除指定的key value
（9）练习
（1）启动服务端
（2）练习
截图上有一个地方写错了，list是列表类型
4、持久化
1. redis是一个内存数据库，当redis服务器重启，获取电脑重启，数据会丢失，我们可以将redis内存中的数据持久化保存到硬盘的文件中。
2. redis持久化机制：
1. RDB：默认方式，不需要进行配置，默认就使用这种机制
* 在一定的间隔时间中，检测key的变化情况，然后持久化数据
1. 编辑redis.windwos.conf文件
# after 900 sec (15 min) if at least 1 key changed
save 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. 重新启动redis服务器，并指定配置文件名称
D:\JavaWeb2018\day23_redis\资料\redis\windows-64\redis-2.8.9>redis-server.exe redis.windows.conf
2. AOF：日志记录的方式，可以记录每一条命令的操作。可以每一次命令操作后，持久化数据
1. 编辑redis.windwos.conf文件
appendonly no（关闭aof） --> appendonly yes （开启aof）
# appendfsync always ： 每一次操作都进行持久化
appendfsync everysec ： 每隔一秒进行一次持久化
# appendfsync no ： 不进行持久化
5、Java客户端 Jedis
1. Jedis的测试类
（1）新建一个module，将jedis的依赖包导入。
（2）新建一个测试类JedisTest
快速入门：
// Jedis的测试类
public class JedisTest {
/*
* 快速入门
* */
@Test
public void test1(){
// 1.获取连接
Jedis jedis = new Jedis("localhost",6379);
// 2. 操作
jedis.set("username","haha");
// 3.关闭连接
jedis.close();
}
}
运行前需要启动Redis的服务端。
运行后，可以在Redis客户端查看username：
（3）其他数据类型的测试：
// Jedis的测试类
public class JedisTest {
/*
* 快速入门
* */
@Test
public void test1(){
// 1.获取连接
Jedis jedis = new Jedis("localhost",6379);
// 2. 操作
jedis.set("username","haha");
// 3.关闭连接
jedis.close();
}
/*
* string 数据结构操作
* 存储： set key value
* 获取： get key
* 删除： del key
* */
@Test
public void test2(){
// 1.获取连接
Jedis jedis = new Jedis("localhost",6379);
// 2. 操作
// 存储
jedis.set("username","haha");
// 获取
String username = jedis.get("username");
System.out.println("username:"+username);
// 可以使用setex()方法存储，可以指定过期时间的key value
// 可以用来保存一些有时限的激活码
jedis.setex("activecode",20,"hehe"); //将activecode：hehe键值对存入redis，并且20秒后自动删除该键值对
// 3.关闭连接
jedis.close();
}
/*
* hash 数据结构操作
* 存储： hset key field value
* 获取：hget key field: 获取指定的field对应的值; hgetall key：获取所有的field和value
* 删除： hdel key field
* */
@Test
public void test3(){
// 1.获取连接
Jedis jedis = new Jedis(); //如果使用空参构造，默认值 "localhost",6379端口
// 2. 操作
// 存储hash
jedis.hset("user","name","zhangsan");
jedis.hset("user","age","23"); //若再次存储不一样的值，之前的会被覆盖掉
jedis.hset("user","gender","female");
// 获取hash
String name = jedis.hget("user","name");
System.out.println("name:"+ name);
// 获取hash的所有map中的数据
Map<String,String> user = jedis.hgetAll("user");
// keyset
Set<String> keySet = user.keySet();
for (String key:keySet) {
// 获取value
String value = user.get(key);
System.out.println(key + ":"+ value);
}
// 3.关闭连接
jedis.close();
}
/*
* list 数据结构操作
* 添加: lpush key value: 将元素加入列表左表; rpush key value：将元素加入列表右边
* 获取：lrange key start end ：范围获取
* 删除： lpop key： 删除列表最左边的元素，并将元素返回; rpop key： 删除列表最右边的元素，并将元素返回
* */
@Test
public void test4(){
// 1.获取连接
Jedis jedis = new Jedis(); //如果使用空参构造，默认值 "localhost",6379端口
// 2. 操作
// list存储
jedis.lpush("mylist","a","b","c"); //从左边存
jedis.rpush("mylist","a","b","c"); //从右边存
// list 范围获取
List<String> mylist = jedis.lrange("mylist",0,-1);
System.out.println("mylist:"+ mylist);
// list 弹出
String element1 = jedis.lpop("mylist");
System.out.println("element1:"+ element1);
String element2 = jedis.rpop("mylist");
System.out.println(element2);
// list范围获取
List<String> mylist2 = jedis.lrange("mylist",0,-1);
System.out.println(mylist2);
// 3.关闭连接
jedis.close();
}
/*
* set 数据结构操作，不允许重复元素
* 存储：sadd key value
* 获取：smembers key:获取set集合中所有元素
* 删除：srem key value:删除set集合中的某个元素
* */
@Test
public void test5(){
// 1.获取连接
Jedis jedis = new Jedis(); //如果使用空参构造，默认值 "localhost",6379端口
// 2. 操作
// set存储
jedis.sadd("myset","java","php","c++","java","c");
// set获取
Set<String> myset = jedis.smembers("myset");
System.out.println(myset);
// 3.关闭连接
jedis.close();
}
/*
* sortedset 数据结构操作
* 存储：zadd key score value
* 获取：zrange key start end [withscores]
* 删除：zrem key value
* */
@Test
public void test6(){
// 1.获取连接
Jedis jedis = new Jedis(); //如果使用空参构造，默认值 "localhost",6379端口
// 2. 操作
// sortedset 存储
jedis.zadd("mysortedset",3,"哥哥");
jedis.zadd("mysortedset",30,"姐姐");
jedis.zadd("mysortedset",55,"小姨");
jedis.zadd("mysortedset",2,"11");
// sortedset 获取
Set<String> mysortedset = jedis.zrange("mysortedset",0,-1);
System.out.println("mysortedset:"+mysortedset);
// 3.关闭连接
jedis.close();
}
}
2. jedis连接池使用
jedis连接池： JedisPool，自带的有。
使用：
1. 创建JedisPool连接池对象，一般会指定配置
2. 调用方法 getResource()方法获取Jedis连接
/*
* jedis 连接池使用
* */
@Test
public void test7(){
// 0. 创建一个配置对象
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(50);
config.setMaxIdle(10);
// 1. 创建Jedis连接池对象
JedisPool jedisPool = new JedisPool(config,"localhost",6379);
// 2.获取连接
Jedis jedis = jedisPool.getResource();
//3.使用
jedis.set("hehe","hahah");
System.out.println("hehe:"+jedis.get("hehe")); // 打印效果：hehe:hahah
// 4. 关闭，归还到连接池中
jedis.close();
}
其他配置：
#最大活动对象数
redis.pool.maxTotal=1000
#最大能够保持idel状态的对象数
redis.pool.maxIdle=100
#最小能够保持idel状态的对象数
redis.pool.minIdle=50
#当池内没有返回对象时，最大等待时间
redis.pool.maxWaitMillis=10000
#当调用borrow Object方法时，是否进行有效性检查
redis.pool.testOnBorrow=true
#当调用return Object方法时，是否进行有效性检查
redis.pool.testOnReturn=true
#“空闲链接”检测线程，检测的周期，毫秒数。如果为负值，表示不运行“检测线程”。默认为-1.
redis.pool.timeBetweenEvictionRunsMillis=30000
#向调用者输出“链接”对象时，是否检测它的空闲超时；
redis.pool.testWhileIdle=true
# 对于“空闲链接”检测线程而言，每次检测的链接资源的个数。默认为3.
redis.pool.numTestsPerEvictionRun=50
#redis服务器的IP
redis.ip=xxxxxx
#redis服务器的Port
redis1.port=6379
3. jedis连接池工具类
导入jedis.properties。
工具类：
package cn.itcast.jedis.util;
/**
* @author huan
* @create 2020-07-08 17:21
*/
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 {
// 读取配置文件
InputStream is = JedisPoolUtils.class.getClassLoader().getResourceAsStream("jedis.properties");
// 创建Properties对象
Properties pro = new Properties();
// 关联文件
try {
pro.load(is);
} catch (IOException e) {
e.printStackTrace();
}
// 获取数据，设置到JedisPoolConfig中
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(Integer.parseInt(pro.getProperty("maxTotal")));
config.setMaxIdle(Integer.parseInt(pro.getProperty("maxIdle")));
// 初始化JedisPool
jedisPool = new JedisPool(config, pro.getProperty("host"),Integer.parseInt(pro.getProperty("port")));
}
/*
* 获取连接方法
* */
public static Jedis getJedis(){
return jedisPool.getResource();
}
}
测试：
/*
* jedis 连接池工具类使用
* */
@Test
public void test8(){
// 通过连接池工具类获取
Jedis jedis = JedisPoolUtils.getJedis();
// 使用
jedis.set("hello","world");
System.out.println(""+jedis.get("hello"));
// 关闭归还到连接池
jedis.close();
}
五、案例：省份下拉列表，使用缓存，通过ajax加载所有省份
1、案例需求
- 提供index.html页面，页面中有一个省份 下拉列表
- 当 页面加载完成后 发送ajax请求，加载所有省份
- 使用缓存
注意： 使用redis缓存一些不经常发生变化的数据。
- 数据库的数据一旦发生改变，则需要更新缓存。
- 数据库的表执行 增删改的相关操作，需要将redis缓存数据情况，再次存入
- 在service对应的增删改方法中，将redis数据删除。
2、分析
3、实现
运行前需要导入相应的jar包和JS文件，还有连接池配置文件。
最后的文件目录：
（1）创建数据库
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,'陕西');
（2）实体类
在domain下新建实体类Province：
package cn.itcast.domain;
/**
* @author huan
* @create 2020-07-08 22:58
*/
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;
}
}
（3）dao层
接口：
package cn.itcast.dao.impl;
import cn.itcast.domain.Province;
import java.util.List;
/**
* @author huan
* @create 2020-07-08 23:13
*/
public interface ProvinceDao {
public List<Province> findAll();
}
实现类：
package cn.itcast.dao;
import cn.itcast.dao.impl.ProvinceDao;
import cn.itcast.domain.Province;
import cn.itcast.utils.JDBCUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.List;
/**
* @author huan
* @create 2020-07-08 23:14
*/
public class ProvinceDaoImpl implements ProvinceDao{
// 1.声明成员变量jdbctemplement
private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
@Override
public List<Province> findAll() {
// 定义sql
String sql = "select * from province";
//执行sql
List<Province> list = template.query(sql,new BeanPropertyRowMapper<Province>(Province.class));
return list;
}
}
（4）service
接口：
package cn.itcast.service;
import cn.itcast.domain.Province;
import java.util.List;
/**
* @author huan
* @create 2020-07-08 23:26
*/
public interface ProvinceService {
public List<Province> findAll();
public String findAllJson();
}
实现类：
package cn.itcast.service.impl;
import cn.itcast.dao.impl.ProvinceDaoImpl;
import cn.itcast.dao.ProvinceDao;
import cn.itcast.domain.Province;
import cn.itcast.jedis.util.JedisPoolUtils;
import cn.itcast.service.ProvinceService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import redis.clients.jedis.Jedis;
import java.util.List;
/**
* @author huan
* @create 2020-07-08 23:27
*/
public class ProvinceServiceImpl implements ProvinceService{
// 声明dao
private ProvinceDao dao = new ProvinceDaoImpl();
@Override
public List<Province> findAll() {
return dao.findAll();
}
/*
* 使用Redis缓存
* */
@Override
public String findAllJson() {
//1. 先从Redis中查询数据
// 1.1获取Redis客户端连接
Jedis jedis = JedisPoolUtils.getJedis();
String province_json = jedis.get("province");
// 2.判断province_json 数据是否为null
if(province_json == null || province_json.length() == 0){
// redis中没有数据
System.out.println("redis中没有数据，查询数据库...");
// 2.1 从数据中查询
List<Province> ps = dao.findAll();
// 2.2 将List序列化为json
ObjectMapper mapper = new ObjectMapper();
try {
province_json = mapper.writeValueAsString(ps);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
// 2.3 将json数据存入Redis
jedis.set("province",province_json);
// 归还连接
jedis.close();
}else {
System.out.println("Redis 中有数据，查询缓存...");
}
return province_json;
}
}
（5）连接数据库
package cn.itcast.utils;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
/**
* @author huan
* @create 2020-07-08 23:16
*/
// JDBC工具类 使用Durid连接池
public class JDBCUtils {
private static DataSource ds;
static {
try {
// 1.加载配置文件
Properties pro = new Properties();
// 使用ClassLoader加载配置文件，获取字节输入流
InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
pro.load(is);
// 2.初始化连接池对象
ds = DruidDataSourceFactory.createDataSource(pro);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取连接池对象
*/
public static DataSource getDataSource(){
return ds;
}
/**
* 获取连接Connection对象
*/
public static Connection getConnection() throws SQLException {
return ds.getConnection();
}
}
（6）servlet
package cn.itcast.web.servlet;
import cn.itcast.service.ProvinceService;
import cn.itcast.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 javax.sound.midi.Soundbank;
import java.io.IOException;
/**
* @author huan
* @create 2020-07-08 23:51
*/
@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 mapper = new ObjectMapper();
String json = mapper.writeValueAsString(list);
*/
// 使用缓存
// 1.使用service查询
ProvinceService service = new ProvinceServiceImpl();
String json = service.findAllJson();
System.out.println("json:"+json);
// 3.响应结果
response.setContentType("application/json;charset=utf-8");
response.getWriter().write(json);
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.doPost(request, response);
}
}
（7）运行效果：
要先启动Redis服务器，再启动Tomcat服务器，运行项目。
页面运行后，select已经加载了省份。
查看控制台，可以看到语句：
redis中没有数据，查询数据库…
json:[{“id”:1,“name”:“北京”},{“id”:2,“name”:“上海”},{“id”:3,“name”:“广州”},{“id”:4,“name”:“陕西”}]。
再刷新页面后，因为缓存中已经有数据了，则不需要再访问数据库。
若此时将Redis中的province删除，则又需要访问数据库了。
671
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
