JavaWeb

Servlet一、Servlet 技术1、什么是 Servlet1、Servlet 是 JavaEE 规范之一。规范就是接口2、Servlet 就 JavaWeb 三大组件之一。三大组件分别是：Servlet 程序、Filter 过滤器、Listener 监听器。3、Servlet 是运行在服务器上的一个 java 小程序，它可以接收客户端发送过来的请求，并响应数据给客户端。url 地址到程序的访

ok~~

220人浏览 · 2021-09-06 09:46:55

ok~~ · 2021-09-06 09:46:55 发布

Servlet

一、Servlet 技术

1、什么是 Servlet

1、Servlet 是 JavaEE 规范之一。规范就是接口
2、Servlet 就 JavaWeb 三大组件之一。三大组件分别是：Servlet 程序、Filter 过滤器、Listener 监听器。
3、Servlet 是运行在服务器上的一个 java 小程序，
它可以接收客户端发送过来的请求，并响应数据给客户端。

url 地址到程序的访问

在这里插入图片描述

2、Servlet 程序的生命周期

1、执行 servlet 构造器方法

2、执行 init 初始化方法

第一、二步，是在第一次访问，的时候创建 servlet 程序会调用。

3、执行 service 方法

第三步，每次访问都会调用。

4、执行 destroy 销毁方法

第四步，在 web 工程停止的时候调用。

3、通过继承 HttpServlet 实现 Servlet 程序

一般在实际项目开发中，都是使用继承 HttpServlet 类的方式去实现 Servlet 程序。

1、编写一个类去继承 HttpServlet 类

2、根据业务需要重写 doGet 或 doPost 方法

3、到 web.xml 中的配置 Servlet 程序的访问地址

Servlet 类的继承体系

二、ServletConfig 类

ServletConfig 类从类名上来看，就知道是 Servlet 程序的配置信息类。Servlet 程序和 ServletConfig 对象都是由 Tomcat 负责创建，我们负责使用。Servlet 程序默认是第一次访问的时候创建，ServletConfig 是每个 Servlet 程序创建时，就创建一个对应的 ServletConfig 对象。

ServletConfig 类的三大作用

1、可以获取Servlet程序的别名 servlet-name 的值
2、获取初始化参数 init-param
3、获取 ServletContext 对象

三、ServletContext 类

1、什么是 ServletContext ?

1、ServletContext 是一个接口，它表示 Servlet 上下文对象
2、一个web工程，只有一个 ServletContext 对象实例。
3、ServletContext 对象是一个域对象。
4、ServletContext 是在web工程部署启动的时候创建。在 web 工程停止的时候销毁
什么是域对象?
域对象，是可以像 Map 一样存取数据的对象，叫域对象。
这里的域指的是存取数据的操作范围，整个 web 工程。

类型	存数据	取数据	删除数据
Map	put()	get()	remove()
域对象	setAttribute()	getAttribute()	removeAttribut

2、ServletContext类的四个作用

1、获取 web.xml 中配置的上下文参数 context-param
2、获取当前的工程路径，格式：/工程路径
3、获取工程部署后在服务器硬盘上的绝对路径
4、像 Map 一样存取数据

四、HTTP 协议

1、什么是 HTTP 协议

协议是指双方或多方，相互约定好，大家都需要遵守的规则就叫做协议。
所谓 HTTP 协议，就是指客户端和服务器之间通信时，发送的数据，需要遵守的规则，叫 HTTP 协议。HTTP 协议中的数据又叫报文。

2、请求的 HTTP 协议格式

客户端给服务器发送数据叫请求。
服务器给客户端回传数据叫响应。
请求又分为 GET 请求，和 POST 请求两种

GET 请求

1、请求行
(1) 请求的方式 GET
(2) 请求的资源路径[+?+请求参数]
(3) 请求的协议的版本号 HTTP/1.1
2、请求头
key : value 组成不同的键值对，表示不同的含义。

GET 请求的HTTP内容的图解

GET请求的HTTP内容的图解

POST 请求

1、请求行
(1) 请求的方式 POST
(2) 请求的资源路径[+?+请求参数]
(3) 请求的协议的版本号 HTTP/1.1
2、请求头
(1) key : value 不同的请求头，有不同的含义
空行
3、请求体 ----> 就是发送给服务器的数据

POST 请求的HTTP内容的图解

POST请求的HTTP内容的图解

常用请求头的说明

Accept：表示客户端可以接收的数据类型
Accpet-Languege：表示客户端可以接收的语言类型
User-Agent：表示客户端浏览器的信息
Host：服务器 ip 和端口号

哪些是 GET 请求，哪些是 POST 请求?

GET 请求有哪些：
1、form 标签 method=get
2、a 标签
3、link 标签引入 css
4、script 标签引入 js 文件
5、img 标签引入图片
6、iframe 引入 html 页面
7、在浏览器地址栏中输入地址后敲回车

POST 请求有哪些：
1、form 标签 method=post

3、响应的 HTTP 协议格式

1、响应行
(1) 响应的协议和版本号
(2) 响应状态码
(3) 响应状态描述符
2、响应头
(1) key : value 不同的响应头，有其不同含义
空行
3、响应体 —> 就是回传给客户端的数据

响应的 HTTP 格式

HTTP协议

4、常用的响应码说明

200 表示请求成功
302 表示请求重定向
404 表示请求服务器已经收到了，但是你要的数据不存在（请求地址错误）
500 表示服务器已经收到请求，但是服务器内部错误（代码错误）

五、HttpServletRequest 类

1、HttpServletRequest 类的作用

每次只要有请求进入 Tomcat 服务器，Tomcat 服务器就会把请求过来的 HTTP 协议信息解析好封装到 Request 对象中。然后传递到 service 方法（doGet 和 doPost）中给我们使用。我们可以通过 HttpServletRequest 对象，获取到所有请求的信息。

2、HttpServletRequest 类的常用方法

i. getRequestURI() 获取请求的资源路径
ii. getRequestURL() 获取请求的统一资源定位符（绝对路径）
iii. getRemoteHost() 获取客户端的 ip 地址
iv. getHeader() 获取请求头
v. getParameter() 获取请求的参数
vi. getParameterValues() 获取请求的参数（多个值的时候使用）
vii. getMethod() 获取请求的方式 GET 或 POST
viii. setAttribute(key, value); 设置域数据
ix. getAttribute(key); 获取域数据
x. getRequestDispatcher() 获取请求转发对象

3、如何获取请求参数

表单：
<body>
    <form action="http://localhost:8080/07_servlet/parameterServlet" method="get">  
        用户名：<input type="text" name="username"><br/>
        密码：<input type="password" name="password"><br/> 
        兴趣爱好：<input type="checkbox" name="hobby" value="cpp">C++
        <input type="checkbox" name="hobby" value="java">Java   
        <input type="checkbox" name="hobby" value="js">JavaScript<br/>
        <input type="submit"> 
    </form> 
</body>

java：
public class ParameterServlet extends HttpServlet { 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取请求参数
        String username = req.getParameter("username"); 
        String password = req.getParameter("password");
        String[] hobby = req.getParameterValues("hobby"); 
        System.out.println("用户名：" + username);
        System.out.println("密码：" + password); 
        System.out.println("兴趣爱好：" + Arrays.asList(hobby));
    } 
}

doGet 请求的中文乱码解决方式

// 获取请求参数 
String username = req.getParameter("username");
//1 先以 iso8859-1 进行编码 
//2 再以 utf-8 进行解码 
username = new String(username.getBytes("iso-8859-1"), "UTF-8");

doPost 请求的中文乱码解决方式

@Override 
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
    // 设置请求体的字符集为 UTF-8，从而解决 post 请求的中文乱码问题 
    req.setCharacterEncoding("UTF-8");
    System.out.println("-------------doPost------------"); 
    // 获取请求参数
    String username = req.getParameter("username"); 
    String password = req.getParameter("password");
    String[] hobby = req.getParameterValues("hobby");
    System.out.println("用户名：" + username); 
    System.out.println("密码：" + password); 
    System.out.println("兴趣爱好：" + Arrays.asList(hobby));
}

请求转发

什么是请求的转发?
请求转发是指，服务器收到请求后，从一次资源跳转到另一个资源的操作叫请求转发。

请求转发图解

请求转发

base 标签的作用

<!DOCTYPE html>  
<html lang="zh_CN">  
<head>  
    <meta charset="UTF-8">  
    <title>Title</title>   
    <!--base 标签设置页面相对路径工作时参照的地址 href 属性就是参数的地址值 -->    
    <base href="http://localhost:8080/07_servlet/a/b/">  
</head>    
<body>   
    这是 a 下的 b 下的 c.html 页面<br/>    
    <a href="../../index.html">跳回首页</a><br/>   
</body>     
</html>

Web 中的相对路径和绝对路径

在 javaWeb 中，路径分为相对路径和绝对路径两种：
相对路径是：
. 表示当前目录
… 表示上一级目录
资源名表示当前目录/资源名
绝对路径： http://ip:port/工程路径/资源路径
在实际开发中，路径都使用绝对路径，而不简单的使用相对路径。
1、绝对路径
2、base+相对

web 中 / 斜杠的不同意义

在 web 中 / 斜杠是一种绝对路径。
/ 斜杠如果被浏览器解析，得到的地址是：http://ip:port/
<a href="/">斜杠</a>
/ 斜杠如果被服务器解析，得到的地址是：http://ip:port/工程路径
1、/servlet1
2、servletContext.getRealPath(“/”);
3、request.getRequestDispatcher(“/”);
特殊情况： response.sendRediect(“/”); 把斜杠发送给浏览器解析。得到 http://ip:port/

六、HttpServletResponse 类

HttpServletResponse 类的作用

HttpServletResponse 类和 HttpServletRequest 类一样。每次请求进来，Tomcat 服务器都会创建一个 Response 对象传递给 Servlet 程序去使用。HttpServletRequest 表示请求过来的信息，HttpServletResponse 表示所有响应的信息，
我们如果需要设置返回给客户端的信息，都可以通过 HttpServletResponse 对象来进行设置

两个输出流的说明

字节流 getOutputStream(); 常用于下载（传递二进制数据）
字符流 getWriter(); 常用于回传字符串（常用）
两个流同时只能使用一个。使用了字节流，就不能再使用字符流，反之亦然，否则就会报错。

字节流冲突异常

如何往客户端回传数据

public class ResponseIOServlet extends HttpServlet {  
    @Override   
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {   
        // 要求 ： 往客户端回传 字符串 数据。   
        PrintWriter writer = resp.getWriter();   
        writer.write("response's content!!!");  
    }  
}

响应的乱码解决

解决响应中文乱码方案一（不推荐使用）：

// 设置服务器字符集为 UTF-8  
resp.setCharacterEncoding("UTF-8");  
// 通过响应头，设置浏览器也使用 UTF-8 字符集  
resp.setHeader("Content-Type", "text/html; charset=UTF-8");

解决响应中文乱码方案二（推荐）：

// 它会同时设置服务器和客户端都使用 UTF-8 字符集，还设置了响应头  
// 此方法一定要在获取流对象之前调用才有效     
resp.setContentType("text/html; charset=UTF-8");

请求重定向

请求重定向，是指客户端给服务器发请求，然后服务器告诉客户端说。我给你一些地址。你去新地址访问。叫请求重定向（因为之前的地址可能已经被废弃）。

请求重定向

请求重定向的第一种方案：

// 设置响应状态码 302 ，表示重定向，（已搬迁）  
resp.setStatus(302);  
// 设置响应头，说明新的地址在哪里  
resp.setHeader("Location", "http://localhost:8080");

请求重定向的第二种方案（推荐使用）：

resp.sendRedirect("http://localhost:8080");

JSP

一、什么是 jsp ，它有什么用?

jsp 的全称是 java server pages。Java 的服务器页面。
jsp 的主要作用是代替 Servlet 程序回传 html 页面的数据。
因为 Servlet 程序回传 html 页面数据是一件非常繁锁的事情。开发成本和维护成本都极高。

二、jsp 的本质是什么

jsp 页面本质上是一个 Servlet 程序。
JSP源码

我们跟踪原代码发现，HttpJspBase 类。它直接地继承了 HttpServlet 类。也就是说。jsp 翻译出来的 java 类，它间接了继承了 HttpServlet 类。也就是说，翻译出来的是一个 Servlet 程序
总结：通过翻译的 java 源代码我们就可以得到结果：jsp 就是 Servlet 程序。大家也可以去观察翻译出来的 Servlet 程序的源代码，不难发现。其底层实现，也是通过输出流。把 html 页面数据回传给客户端。（通过out.write()的方式）

三、jsp 的三种语法

jsp 头部的 page 指令

jsp 的 page 指令可以修改 jsp 页面中一些重要的属性，或者行为。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

language 属性表示 jsp 翻译后是什么语言文件。暂时只支持 java。
contentType 属性表示jsp返回的数据类型是什么。也是源码中response.setContentType()参数值
pageEncoding 属性表示当前 jsp 页面文件本身的字符集。
import 属性跟 java 源代码中一样。用于导包，导类。

-----------两个属性是给out输出流使用-----------

autoFlush 属性设置当 out 输出流缓冲区满了之后，是否自动刷新冲级区。默认值是 true。
buffer 属性设置 out 缓冲区的大小。默认是8kb。

缓冲区溢出错误

jsp 中的常用脚本

声明脚本(极少使用)

声明脚本的格式是： <%! 声明 java 代码 %>
声明脚本的作用是：可以给 jsp 翻译出来的 java 类定义属性和方法甚至是静态代码块。内部类等
例如：1、声明类属性 2、声明 static 静态代码块 3、声明类方法 4、声明内部类

表达式脚本（常用）

表达式脚本的格式是：<%=表达式%>
表达式脚本的作用是：到 jsp 页面上输出数据。
表达式脚本的特点是：
1、所有的表达式脚本都会被翻译到_jspService() 方法中
2、表达式脚本都会被翻译成为 out.print()输出到页面上
3、由于表达式脚本翻译的内容都在_jspService() 方法中,所以_jspService()方法中的对象都可以直接使用。
4、表达式脚本中的表达式不能以分号结束。
例如：1. 输出整型 2. 输出浮点型 3. 输出字符串 4. 输出对象

代码脚本

代码脚本的格式是： <% java 语句 %>
代码脚本的作用是：可以在 jsp 页面中，编写我们自己需要的功能（写的是 java 语句）。
代码脚本的特点是：
1、代码脚本翻译之后都在_jspService 方法中
2、代码脚本由于翻译到_jspService()方法中，所以在_jspService()方法中的现有对象都可以直接使用。
3、还可以由多个代码脚本块组合完成一个完整的 java 语句。
4、代码脚本还可以和表达式脚本一起组合使用，在 jsp 页面上输出数据
例如：1. 代码脚本----if 语句 2. 代码脚本----for 循环语句 3. 翻译后 java 文件中_jspService 方法内的代码都可以写

四、jsp 九大内置对象

jsp 中的内置对象，是指 Tomcat 在翻译 jsp 页面成为 Servlet 源代码后，内部提供的九大对象，叫内置对象。
JSP九大内置对象

五、jsp 四大域对象

四个域对象分别是：

域对象	所属类	作用
pageContext	PageContextImpl 类	当前 jsp 页面范围内有效
request	HttpServletRequest 类	一次请求内有效
session	HttpSession 类	一个会话范围内有效（打开浏览器访问服务器，直到关闭浏览器）
application	ServletContext 类	整个 web 工程范围内都有效（只要 web 工程不停止，数据都在）

域对象是可以像 Map 一样存取数据的对象。四个域对象功能一样。不同的是它们对数据的存取范围。虽然四个域对象都可以存取数据。在使用上它们是有优先顺序的。
四个域在使用的时候，优先顺序分别是，他们从小到大的范围的顺序。

pageContext ====>>> request ====>>> session ====>>> application

<body>  
	<% 
		// 往四个域中都分别保存了数据 
		pageContext.setAttribute("key", "pageContext");
		request.setAttribute("key", "request"); 
		session.setAttribute("key", "session"); 
		application.setAttribute("key", "application"); 
	 %>
	pageContext 域是否有值：<%=pageContext.getAttribute("key")%> <br> 
	request 域是否有值：<%=request.getAttribute("key")%> <br> 
	session 域是否有值：<%=session.getAttribute("key")%> <br> 
	application 域是否有值：<%=application.getAttribute("key")%> <br> 
 </body>

六、jsp 中的 out 输出和 response.getWriter 输出的区别

response 中表示响应，我们经常用于设置返回给客户端的内容（输出）
out 也是给用户做输出使用的。
out和response.getWriter 输出区别
由于 jsp 翻译之后，底层源代码都是使用 out 来进行输出，所以一般情况下。我们在 jsp 页面中统一使用 out 来进行输出。避免打乱页面输出内容的顺序。
out.write() 输出字符串没有问题
out.print() 输出任意数据都没有问题（都转换成为字符串后调用的 write 输出）
深入源码，浅出结论：在 jsp 页面中，可以统一使用 out.print()来进行输出

七、jsp 的常用标签

jsp 静态包含

<%@ include file=""%>

file 属性指定你要包含的 jsp 页面的路径
地址中第一个斜杠 / 表示为 http://ip:port/工程路径/ 映射到代码的 web 目录
静态包含的特点：
1、静态包含不会翻译被包含的 jsp 页面。
2、静态包含其实是把被包含的 jsp 页面的代码拷贝到包含的位置执行输出。

jsp 动态包含

<jsp:include page="/include/footer.jsp">  
	<jsp:param name="username" value="bbj"/>
	<jsp:param name="password" value="root"/> 
</jsp:include>

page 属性是指定你要包含的 jsp 页面的路径动态包含也可以像静态包含一样。把被包含的内容执行输出到包含位置
动态包含的特点：
1、动态包含会把包含的 jsp 页面也翻译成为 java 代码
2、动态包含底层代码使用如下代码去调用被包含的 jsp 页面执行输出。 JspRuntimeLibrary.include(request, response, “/include/footer.jsp”, out, false);
3、动态包含，还可以传递参数
动态包含的底层原理

jsp 标签-转发

<jsp:forward page="/scope2.jsp"></jsp:forward>

八、什么是 Listener 监听器？

1、Listener 监听器它是 JavaWeb 的三大组件之一。JavaWeb 的三大组件分别是：Servlet 程序、Filter 过滤器、Listener 监听器。
2、Listener 它是 JavaEE 的规范，就是接口
3、监听器的作用是，监听某种事物的变化。然后通过回调函数，反馈给客户（程序）去做一些相应的处理。

ServletContextListener 监听器

ServletContextListener 它可以监听 ServletContext 对象的创建和销毁。
ServletContext 对象在 web 工程启动的时候创建，在 web 工程停止的时候销毁。
监听到创建和销毁之后都会分别调用 ServletContextListener 监听器的方法反馈。

public interface ServletContextListener extends EventListener { 
	//在 ServletContext 对象创建之后马上调用，做初始化 
	public void contextInitialized(ServletContextEvent sce); 
	//在 ServletContext 对象销毁之后调用 
	public void contextDestroyed(ServletContextEvent sce); 
}

如何使用 ServletContextListener 监听器监听 ServletContext 对象。
使用步骤如下：
1、编写一个类去实现 ServletContextListener
2、实现其两个回调方法
3、到 web.xml 中去配置监听器

监听器实现类

public class MyServletContextListenerImpl implements ServletContextListener { 
	@Override 
	public void contextInitialized(ServletContextEvent sce) {
	System.out.println("ServletContext 对象被创建了"); 
	}
	@Override 
	public void contextDestroyed(ServletContextEvent sce) {
	System.out.println("ServletContext 对象被销毁了"); 
	} 
 }

web.xml 中的配置

//配置监听器
<listener> 
	<listener-class>com.atguigu.listener.MyServletContextListenerImpl</listener-class> 
</listener>

EL 表达式 & JSTL 标签库

一、EL 表达式

什么是 EL 表达式，EL 表达式的作用?

EL 表达式的全称是：Expression Language。是表达式语言。
EL 表达式的什么作用：EL 表达式主要是代替 jsp 页面中的表达式脚本在 jsp 页面中进行数据的输出。
因为 EL 表达式在输出数据的时候，要比 jsp 的表达式脚本要简洁很多。
EL 表达式的格式是：${表达式}
EL 表达式在输出 null 值的时候，输出的是空串。jsp 表达式脚本输出 null 值的时候，输出的是 null 字符串。

EL 表达式搜索域数据的顺序

EL 表达式主要是在 jsp 页面中输出数据。主要是输出域对象中的数据。当四个域中都有相同的 key 的数据的时候，EL 表达式会按照四个域的从小到大的顺序去进行搜索，找到就输出。

<body> 
	<% 
		//往四个域中都保存了相同的 key 的数据。 
		request.setAttribute("key", "request");
		session.setAttribute("key", "session"); 
		application.setAttribute("key", "application");
		pageContext.setAttribute("key", "pageContext"); 
	%>
	${ key } //输出request
</body>

EL 表达式输出 Bean 的普通属性，数组属性。List 集合属性，map 集合属性

需求——输出 Person 类中普通属性，数组属性。list 集合属性和 map 集合属性。

Person类

public class Person { 
	// i.需求——输出 Person 类中普通属性，数组属性。list 集合属性和 map 集合属性。 
	private String name; 
	private String[] phones; 
	private List<String> cities; 
	private Map<String,Object> map; 
	//get set方法省略...

输出的代码

<body> 
	<% 
		Person person = new Person(); 
		person.setName("国哥好帅！"); 
		person.setPhones(new String[]{"18610541354","18688886666","18699998888"}); 
		
		List<String> cities = new ArrayList<String>(); 
		cities.add("北京"); 
		cities.add("上海"); 
		cities.add("深圳"); 
		person.setCities(cities); 
		
		Map<String,Object>map = new HashMap<>(); 
		map.put("key1","value1"); 
		map.put("key2","value2"); 
		map.put("key3","value3"); 
		person.setMap(map);
		pageContext.setAttribute("p", person); 
	%>
	
	输出 Person：${ p }<br/> 
	输出 Person 的 name 属性：${p.name} <br> 
	输出 Person 的 pnones 数组属性值：${p.phones[2]} <br> 
	输出 Person 的 cities 集合中的元素值：${p.cities} <br> 
	输出 Person 的 List 集合中个别元素值：${p.cities[2]} <br> 
	输出 Person 的 Map 集合: ${p.map} <br> 
	输出 Person 的 Map 集合中某个 key 的值: ${p.map.key3} <br> 
	输出 Person 的 age 属性：${p.age} <br> //EL表达式会自动调用对应属性的get方法，即使没有这个属性
</body>

EL 表达式——运算

关系运算

略

逻辑运算

略

算数运算

略

empty 运算

语法 ${ empty key }
empty 运算可以判断一个数据是否为空，如果为空，则输出 true,不为空输出 false。
以下几种情况为空：
1、值为 null 值的时候，为空
2、值为空串的时候，为空
3、值是 Object 类型数组，长度为零的时候
4、list 集合，元素个数为零
5、map 集合，元素个数为零

三元运算

${ 12 != 12 ? "帅呆了":"又骗人啦" }

“.”点运算和 [] 中括号运算符

.点运算，可以输出 Bean 对象中某个属性的值。
[]中括号运算，可以输出有序集合中某个元素的值。
并且[]中括号运算，还可以输出 map 集合中 key 里含有特殊字符的 key 的值。

<body> 
	<% 
		Map<String,Object> map = new HashMap<String, Object>(); 
		map.put("a.a.a", "aaaValue"); 
		map.put("b+b+b", "bbbValue"); 
		map.put("c-c-c", "cccValue");
		
		request.setAttribute("map", map); 
	%> 
		${ map['a.a.a'] } <br> 
		${ map["b+b+b"] } <br> 
		${ map['c-c-c'] } <br> 
</body>

EL 表达式的 11 个隐含对象

EL 个达式中 11 个隐含对象，是 EL 表达式中自己定义的，可以直接使用。

变量	类型	作用
pageContext	PageContextImpl	它可以获取 jsp 中的九大内置对象
pageScope	Map<String,Object>	它可以获取 pageContext 域中的数据
requestScope	Map<String,Object>	它可以获取 Request 域中的数据
sessionScope	Map<String,Object>	它可以获取 Session 域中的数据
applicationScope	Map<String,Object>	它可以获取 ServletContext 域中的数据
param	Map<String,String>	它可以获取请求参数的值
paramValues	Map<String,String[]>	它也可以获取请求参数的值，获取多个值的时候使用。
header	Map<String,String>	它可以获取请求头的信息
headerValues	Map<String,String[]>	它可以获取请求头的信息，它可以获取多个值的情况
cookie	Map<String,Cookie>	它可以获取当前请求的 Cookie 信息
initParam	Map<String,String>	它可以获取在 web.xml 中配置的`<context-param>`上下文参数

EL 获取四个特定域中的属性

pageScope ------------------- pageContext 域
requestScope ------------------- Request 域
sessionScope ------------------- Session 域
applicationScope ------------------- ServletContext 域

<body> 
	<% 
		pageContext.setAttribute("key1", "pageContext1"); 
		pageContext.setAttribute("key2", "pageContext2"); 
		request.setAttribute("key2", "request"); 
		session.setAttribute("key2", "session"); 
		application.setAttribute("key2", "application"); 
	%>
	${ applicationScope.key2 } //输出application
</body>

pageContext 对象的使用

协议：
服务器 ip：
服务器端口：
获取工程路径：
获取请求方法：
获取客户端 ip 地址：
获取会话的 id 编号：

<body> 
	//request.getScheme() 它可以获取请求的协议 
	//request.getServerName() 获取请求的服务器 ip 或域名 
	//request.getServerPort() 获取请求的服务器端口号 
	//request.getContextPath() 获取当前工程路径 
	//request.getMethod() 获取请求的方式（GET 或 POST） 
	//request.getRemoteHost() 获取客户端的 ip 地址 
	//session.getId() 获取会话的唯一标识
	<% 
		pageContext.setAttribute("req", request); 
	%>
	<%=request.getScheme() %> <br>
	1.协议： ${ req.scheme }<br> 
	2.服务器 ip：${ pageContext.request.serverName }<br> 
	3.服务器端口：${ pageContext.request.serverPort }<br> 
	4.获取工程路径：${ pageContext.request.contextPath }<br> 
	5.获取请求方法：${ pageContext.request.method }<br> 
	6.获取客户端 ip 地址：${ pageContext.request.remoteHost }<br> 
	7.获取会话的 id 编号：${ pageContext.session.id }<br> 
</body>

EL 表达式其他隐含对象的使用

变量	类型	作用
param	Map<String,String>	它可以获取请求参数的值
paramValues	Map<String,String[]>	它也可以获取请求参数的值，获取多个值的时候使用。

示例代码

输出请求参数 username 的值：${ param.username } <br>   
输出请求参数 password 的值：${ param.password } <br>
输出请求参数 username 的值：${paramValues.username[0] } <br> 
输出请求参数 hobby 的值：${ paramValues.hobby[0] } <br> 
输出请求参数 hobby 的值：${ paramValues.hobby[1] } <br>

请求地址：http://localhost:8080/09_EL_JSTL/other_el_obj.jsp?username=wzg168&password=666666&hobby=java&hobby=cpp

变量	类型	作用
header	Map<String,String>	它可以获取请求头的信息
headerValues	Map<String,String[]>	它可以获取请求头的信息，它可以获取多个值的情况

输出请求头【User-Agent】的值：${ header['User-Agent'] } <br> 
输出请求头【Connection】的值：${ header.Connection } <br> 
输出请求头【User-Agent】的值：${ headerValues['User-Agent'][0] } <br>

变量	类型	作用
cookie	Map<String,Cookie>	它可以获取当前请求的 Cookie 信息

获取 Cookie 的名称：${ cookie.JSESSIONID.name } <br> 
获取 Cookie 的值：${ cookie.JSESSIONID.value } <br>

变量	类型	作用
initParam	Map<String,String>	它可以获取在 web.xml 中配置的`<context-param>`上下文参数

web.xml 中的配置

<context-param> 
	<param-name>username</param-name> 
	<param-value>root</param-value> 
</context-param> 
	<context-param> 
	<param-name>url</param-name> 
	<param-value>jdbc:mysql</param-value> 
</context-param>

示例代码

输出<Context-param>username 的值：${ initParam.username } <br> 
输出<Context-param>url 的值：${ initParam.url } <br>

Cookie 和 Session

一、Cookie

1.1、什么是 Cookie?

1、Cookie 翻译过来是饼干的意思。
2、Cookie 是服务器通知客户端保存键值对的一种技术。
3、客户端有了 Cookie 后，每次请求都发送给服务器。
4、每个 Cookie 的大小不能超过 4kb。

1.2、如何创建 Cookie

创建 Cookie 图解

在这里插入图片描述

Servlet 程序中的代码

protected void createCookie(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
	//1 创建 Cookie 对象
	Cookie cookie = new Cookie("key1", "value1"); 
	//2 通知客户端保存 
	Cookie resp.addCookie(cookie); 
	//1 创建 Cookie 对象 
	Cookie cookie1 = new Cookie("key2", "value2"); 
	//2 通知客户端保存 
	Cookie resp.addCookie(cookie1); 
	resp.getWriter().write("Cookie 创建成功"); 
}

1.3、服务器如何获取 Cookie

服务器获取客户端的 Cookie 只需要一行代码：req.getCookies():Cookie[]

获取 Cookie 图解

在这里插入图片描述

Cookie 的工具类

public class CookieUtils { 
	// 查找指定名称的 Cookie 对象 
	public static Cookie findCookie(String name , Cookie[] cookies){ 
		if (name == null || cookies == null || cookies.length == 0) { 
			return null; 
		}
		for (Cookie cookie : cookies) { 
			if (name.equals(cookie.getName())) { 
				return cookie;
			} 
		}
		return null; 
	} 
}

findCookie()中第一个参数代表想寻找的Cookie的name值( key )，第二个参数代表从req中得到的Cookie数组
找不到返回null

1.4、Cookie 值的修改

方案一：
1、先创建一个要修改的同名（指的就是 key）的 Cookie 对象
2、在构造器，同时赋于新的 Cookie 值。
3、调用 response.addCookie( Cookie );

	Cookie cookie = new Cookie("key1","newValue1"); 
	resp.addCookie(cookie);

方案二：
1、先查找到需要修改的 Cookie 对象
2、调用 setValue()方法赋于新的 Cookie 值。
3、调用 response.addCookie()通知客户端保存修改

	Cookie cookie = CookieUtils.findCookie("key2", req.getCookies()); 
	if (cookie != null) {  
		cookie.setValue("newValue2");
		resp.addCookie(cookie); 
	}

1.5、谷歌浏览器查看 Cookie

在这里插入图片描述

1.6、Cookie 生命控制

Cookie 的生命控制指的是如何管理 Cookie 什么时候被销毁（删除）
setMaxAge()
正数，表示在指定的秒数后过期
负数，表示浏览器一关，Cookie 就会被删除（默认值是-1）
零，表示马上删除 Cookie

1.7、Cookie 有效路径 Path 的设置

Cookie 的 path 属性可以有效的过滤哪些 Cookie 可以发送给服务器。哪些不发。
path 属性是通过请求的地址来进行有效的过滤。
CookieA path=/工程路径
CookieB path=/工程路径/abc
请求地址如下：
http://ip:port/工程路径/a.html
CookieA 发送
CookieB 不发送
http://ip:port/工程路径/abc/a.html
CookieA 发送
CookieB 发送

protected void testPath(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
	Cookie cookie = new Cookie("path1", "path1"); 
	// getContextPath() ===>>>> 得到工程路径 
	cookie.setPath( req.getContextPath() + "/abc" ); // ===>>>> /工程路径/abc 
	resp.addCookie(cookie); 
	resp.getWriter().write("创建了一个带有 Path 路径的 Cookie"); 
}

1.8、Cookie 练习—免输入用户名登录

在这里插入图片描述

login.jsp 页面

<form action="http://localhost:8080/13_cookie_session/loginServlet" method="get"> 
	用户名：<input type="text" name="username" value="${cookie.username.value}"> <br> 
	密码：<input type="password" name="password"> <br> 
	<input type="submit" value="登录"> 
</form>

注意点
action中的地址需要写出完整地址，由于没有加base标签

LoginServlet 程序

	@Override 
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
		String username = req.getParameter("username"); 
		String password = req.getParameter("password");
		if ("wzg168".equals(username) && "123456".equals(password)) { 
			//登录成功 
			Cookie cookie = new Cookie("username", username); 
			cookie.setMaxAge(60 * 60 * 24 * 7);//当前 Cookie 一周内有效
			resp.addCookie(cookie); 
			System.out.println("登录 成功"); 
		} else { 
			// 登录失败 
			System.out.println("登录 失败"); 
		} 
}

二、Session

2.1、什么是 Session 会话?

1、Session 就一个接口（HttpSession）。
2、Session 就是会话。它是用来维护一个客户端和服务器之间关联的一种技术。
3、每个客户端都有自己的一个 Session 会话。
4、Session 会话中，我们经常用来保存用户登录之后的信息。

2.2、如何创建和获取 Session (id 号,判断是否为新创建的)

如何创建和获取 Session。它和Cookie的 API 是一样的。

request.getSession()
第一次调用是：创建 Session 会话
之后调用都是：获取前面创建好的 Session 会话对象。

isNew() ：判断到底是不是刚创建出来的（新的）
true 表示刚创建
false 表示获取之前创建

getId() ：得到 Session 的会话 id 值。

每个会话都有一个身份证号。也就是 ID 值。而且这个 ID 是唯一的。

2.3、Session 域数据的存取

	//存储Session值
	req.getSession().setAttribute("key1", "value1");
	//通过Session的key获取Session值
	Object attribute = req.getSession().getAttribute("key1");

2.4、Session 生命周期控制

public void setMaxInactiveInterval(int interval) 设置 Session 的超时时间（以秒为单位），超过指定的时长，Session 就会被销毁。
值为正数的时候，设定 Session 的超时时长。
负数表示永不超时（极少使用）
public int getMaxInactiveInterval()获取 Session 的超时时间
public void invalidate() 让当前 Session 会话马上超时无效。

Session 默认的超时时长是多少？
Session 默认的超时时间长为 30 分钟。

因为在 Tomcat 服务器的配置文件 web.xml中默认有以下的配置，它就表示配置了当前 Tomcat 服务器下所有的 Session 超时配置默认时长为：30 分钟。

如果说。你希望你的 web 工程，默认的 Session 的超时时长为其他时长。你可以在你自己的 web.xml 配置文件中做以上相同的配置。就可以修改你的 web 工程所有 Seession 的默认超时时长。

<!--表示当前 web 工程。创建出来的所有 Session 默认是 20 分钟超时时长-->
<session-config> 
	<session-timeout>20</session-timeout>
</session-config>

如果你想只修改个别 Session 的超时时长。就可以使用上面的 API。setMaxInactiveInterval(int interval)来进行单独的设置。
session.setMaxInactiveInterval(int interval)单独设置超时时长。

Session 超时的概念介绍

在这里插入图片描述

设置超时时长代码

	protected void life3(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
		// 先获取 Session 对象 
		HttpSession session = req.getSession(); 
		// 设置当前 Session3 秒后超时 
		session.setMaxInactiveInterval(3); 
		resp.getWriter().write("当前 Session 已经设置为 3 秒后超时"); 
	}

Session 马上被超时示例

	protected void deleteNow(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
		// 先获取 Session 对象 
		HttpSession session = req.getSession(); 
		// 让 Session 会话马上超时 
		session.invalidate(); 
		resp.getWriter().write("Session 已经设置为超时（无效）"); 
	}

2.5、浏览器和 Session 之间关联的技术内幕

Session 技术，底层其实是基于 Cookie 技术来实现的。

在这里插入图片描述

Filter 过滤器

一、Filter 什么是过滤器

1、Filter 过滤器它是 JavaWeb 的三大组件之一。三大组件分别是：Servlet 程序、Listener 监听器、Filter 过滤器
2、Filter 过滤器它是 JavaEE 的规范。也就是接口
3、Filter 过滤器它的作用是：拦截请求，过滤响应。

拦截请求常见的应用场景有：
1、权限检查
2、日记操作
3、事务管理
……等等

二、Filter 的初体验

Filter 的工作流程图

在这里插入图片描述
要求：在你的 web 工程下，有一个 admin 目录。这个 admin 目录下的所有资源（html 页面、jpg 图片、jsp 文件、等等）都必须是用户登录之后才允许访问。

思考：根据之前我们学过内容。我们知道，用户登录之后都会把用户登录的信息保存到 Session 域中。所以要检查用户是否登录，可以判断 Session 中否包含有用户登录的信息即可！！！

<% 
	Object user = session.getAttribute("user"); 
	// 如果等于 null，说明还没有登录 
	if (user == null) { 
		request.getRequestDispatcher("/login.jsp").forward(request,response); 
		return; 
	} 
%>

Filter 的代码

public class AdminFilter implements Filter { 
	/*** doFilter 方法，专门用于拦截请求。可以做权限检查 */ 
	@Override 
	public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { 
		HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest; 
		HttpSession session = httpServletRequest.getSession(); 
		Object user = session.getAttribute("user"); 
		// 如果等于 null，说明还没有登录 
		if (user == null) { 
			servletRequest.getRequestDispatcher("/login.jsp").forward(servletRequest,servletResponse); 
			return; 
		} else { 
			// 让程序继续往下访问用户的目标资源 
			filterChain.doFilter(servletRequest,servletResponse); 
		} 
	} 
}

web.xml 中的配置

<!--filter 标签用于配置一个 Filter 过滤器--> 
<filter> 
<!--给 filter 起一个别名--> 
<filter-name>AdminFilter</filter-name> 
<!--配置 filter 的全类名--> 
<filter-class>com.atguigu.filter.AdminFilter</filter-class> 
</filter>
<!--filter-mapping 配置 Filter 过滤器的拦截路径--> 
<filter-mapping> 
<!--filter-name 表示当前的拦截路径给哪个 filter 使用--> 
<filter-name>AdminFilter</filter-name> 
<!--url-pattern 配置拦截路径 / 表示请求地址为：http://ip:port/工程路径/ 映射到 IDEA 的 web 目录 
/admin/* 表示请求地址为：http://ip:port/工程路径/admin/* --> 
<url-pattern>/admin/*</url-pattern> 
</filter-mapping>

Filter 过滤器的使用步骤：
1、编写一个类去实现 Filter 接口
2、实现过滤方法 doFilter()
3、到 web.xml 中去配置 Filter 的拦截路径

三、完整的用户登录

login.jsp 页面 == 登录表单

这是登录页面。login.jsp 页面 <br> 
<form action="http://localhost:8080/15_filter/loginServlet" method="get"> 
	用户名：<input type="text" name="username"/> <br> 
	密 码：<input type="password" name="password"/> <br> 
	<input type="submit" /> 
</form>

LoginServlet 程序

public class LoginServlet extends HttpServlet { 
	@Override 
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
		resp.setContentType("text/html; charset=UTF-8"); 
		String username = req.getParameter("username"); 
		String password = req.getParameter("password"); 
		if ("wzg168".equals(username) && "123456".equals(password)) { 
			req.getSession().setAttribute("user",username); 
			resp.getWriter().write("登录 成功！！！"); 
		} else { 
			req.getRequestDispatcher("/login.jsp").forward(req,resp); 
		} 
	} 
}

四、Filter 的生命周期

Filter 的生命周期包含几个方法
1、构造器方法
2、init 初始化方法
第 1，2 步，在 web 工程启动的时候执行（Filter 已经创建）
3、doFilter 过滤方法
第 3 步，每次拦截到请求，就会执行
4、destroy 销毁
第 4 步，停止 web 工程的时候，就会执行（停止 web 工程，也会销毁 Filter 过滤器）

五、FilterConfig 类

FilterConfig 类见名知义，它是 Filter 过滤器的配置文件类。
Tomcat 每次创建 Filter 的时候，也会同时创建一个 FilterConfig 类，这里包含了 Filter 配置文件的配置信息。

FilterConfig 类的作用是获取 filter 过滤器的配置内容
1、获取 Filter 的名称 filter-name 的内容
2、获取在 Filter 中配置的 init-param 初始化参数
3、获取 ServletContext 对象

java 代码

	@Override 
	public void init(FilterConfig filterConfig) throws ServletException { 

		// 1、获取 Filter 的名称 filter-name 的内容 
		System.out.println("filter-name 的值是：" + filterConfig.getFilterName()); 
		
		// 2、获取在 web.xml 中配置的 init-param 初始化参数 
		System.out.println("初始化参数 username 的值是：" + filterConfig.getInitParameter("username")); 
		System.out.println("初始化参数 url 的值是：" + filterConfig.getInitParameter("url")); 
		
		// 3、获取 ServletContext 对象 
		System.out.println(filterConfig.getServletContext()); 
	}

web.xml 配置

<!--filter 标签用于配置一个 Filter 过滤器--> 
<filter> 
	<!--给 filter 起一个别名--> 
	<filter-name>AdminFilter</filter-name> 
	<!--配置 filter 的全类名-->
	<filter-class>com.atguigu.filter.AdminFilter</filter-class> 
	
	<init-param> 
	<param-name>username</param-name> 
	<param-value>root</param-value> 
	</init-param> 
	
	<init-param> 
	<param-name>url</param-name> 
	<param-value>jdbc:mysql://localhost3306/test</param-value> 
	</init-param> 
</filter>

六、FilterChain 过滤器链

在这里插入图片描述

七、Filter 的拦截路径

7.1、精确匹配

<url-pattern>/target.jsp</url-pattern>
以上配置的路径，表示请求地址必须为：http://ip:port/工程路径/target.jsp

7.2、目录匹配

<url-pattern>/admin/*</url-pattern>
以上配置的路径，表示请求地址必须为：http://ip:port/工程路径/admin/*

7.3、后缀名匹配

<url-pattern>*.html</url-pattern>
以上配置的路径，表示请求地址必须以.html 结尾才会拦截到

<url-pattern>*.do</url-pattern>
以上配置的路径，表示请求地址必须以.do 结尾才会拦截到

<url-pattern>*.action</url-pattern>
以上配置的路径，表示请求地址必须以.action 结尾才会拦截到

Filter 过滤器它只关心请求的地址是否匹配，不关心请求的资源是否存在！！！

JSON、AJAX

一、什么是 JSON?

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON 采用完全独立于语言的文本格式，而且很多语言都提供了对 json 的支持（包括 C, C++, C#, Java, JavaScript, Perl, Python 等）。这样就使得 JSON 成为理想的数据交换格式。
json 是一种轻量级的数据交换格式。
轻量级指的是跟 xml 做比较。
数据交换指的是客户端和服务器之间业务数据的传递格式。

1.1、JSON 在 JavaScript 中的使用

1.1.1、json 的定义

json 是由键值对组成，并且由花括号（大括号）包围。每个键由引号引起来，键和值之间使用冒号进行分隔，多组键值对之间进行逗号进行分隔。

json 定义示例

var jsonObj = { 
	"key1":12, 
	"key2":"abc", 
	"key3":true, 
	"key4":[11,"arr",false], 
	"key5":{ 
		"key5_1" : 551, 
		"key5_2" : "key5_2_value" 
	},
	"key6":[{ 
		"key6_1_1":6611, 
		"key6_1_2":"key6_1_2_value"
	},{
		"key6_2_1":6621, 
		"key6_2_2":"key6_2_2_value" 
	}] 
};

1.1.2、json 的访问

json 本身是一个对象。
json 中的 key 我们可以理解为是对象中的一个属性。
json 中的 key 访问就跟访问对象的属性一样： json 对象.key

json 访问示例

alert(typeof(jsonObj));// object json 就是一个对象 
alert(jsonObj.key1); //12 
alert(jsonObj.key2); // abc 
alert(jsonObj.key3); // true 
alert(jsonObj.key4);// 得到数组[11,"arr",false] 
// json 中数组值的遍历 
for(var i = 0; i < jsonObj.key4.length; i++) { 
	alert(jsonObj.key4[i]); 
}
alert(jsonObj.key5.key5_1);//551 
alert(jsonObj.key5.key5_2);//key5_2_value 
alert( jsonObj.key6 );// 得到 json 数组 
// 取出来每一个元素都是 json 对象 
var jsonItem = jsonObj.key6[0]; 
alert( jsonItem.key6_1_1 ); //6611 
alert( jsonItem.key6_1_2 ); //key6_1_2_value

1.1.3、json 的两个常用方法

json 的存在有两种形式。

一种是：对象的形式存在，我们叫它 json 对象。
一种是：字符串的形式存在，我们叫它 json 字符串。
一般我们要操作 json 中的数据的时候，需要 json 对象的格式。
一般我们要在客户端和服务器之间进行数据交换的时候，使用 json 字符串。

JSON.stringify() ，把 json 对象转换成为 json 字符串

JSON.parse() ，把 json 字符串转换成为 json 对象

示例代码

// 把 json 对象转换成为 json 字符串 
var jsonObjString = JSON.stringify(jsonObj); // 特别像 Java 中对象的 toString alert(jsonObjString) 
// 把 json 字符串。转换成为 json 对象 
var jsonObj2 = JSON.parse(jsonObjString); 
alert(jsonObj2.key1);// 12 
alert(jsonObj2.key2);// abc

1.2、JSON 在 java 中的使用

1.2.1、javaBean 和 json 的互转

	@Test 
	public void test1(){ 
		Person person = new Person(1,"国哥好帅!"); 
		// 创建 Gson 对象实例 
		Gson gson = new Gson(); 
		// toJson 方法可以把 java 对象转换成为 json 字符串 
		String personJsonString = gson.toJson(person); 
		System.out.println(personJsonString); 
		// fromJson 把 json 字符串转换回 Java 对象 
		// 第一个参数是 json 字符串 
		// 第二个参数是转换回去的 Java 对象类型 
		Person person1 = gson.fromJson(personJsonString, Person.class); 
		System.out.println(person1); 
	}

1.2.2、List 和 json 的互转

	// 1.2.2、List 和 json 的互转 
	@Test 
	public void test2() { 
		List<Person> personList = new ArrayList<>(); 
		
		personList.add(new Person(1, "国哥")); 
		personList.add(new Person(2, "康师傅")); 
		
		Gson gson = new Gson(); 
		
		// 把 List 转换为 json 字符串 
		String personListJsonString = gson.toJson(personList); 
		System.out.println(personListJsonString);
		
		List<Person> list = gson.fromJson(personListJsonString, new PersonListType().getType()); 
		
		System.out.println(list); 
		
		Person person = list.get(0); 
		
		System.out.println(person); 
	}

1.2.3、map 和 json 的互转

	// 1.2.3、map 和 json 的互转 
	@Test 
	public void test3(){ 
		Map<Integer,Person> personMap = new HashMap<>(); 
		
		personMap.put(1, new Person(1, "国哥好帅")); 
		personMap.put(2, new Person(2, "康师傅也好帅")); 
		
		Gson gson = new Gson(); 
		
		// 把 map 集合转换成为 json 字符串 
		String personMapJsonString = gson.toJson(personMap); 
		System.out.println(personMapJsonString); 
		
		// Map<Integer,Person> personMap2 = gson.fromJson(personMapJsonString, new PersonMapType().getType()); 
		
		Map<Integer,Person> personMap2 = gson.fromJson(personMapJsonString, new TypeToken<HashMap<Integer,Person>>(){}.getType()); 
		System.out.println(personMap2); 
		
		Person p = personMap2.get(1); 
		System.out.println(p); 
	}

二、AJAX 请求

2.1、什么是 AJAX 请求

AJAX 即“Asynchronous Javascript And XML”（异步 JavaScript 和 XML），是指一种创建交互式网页应用的网页开发技术。
ajax 是一种浏览器通过 js 异步发起请求，局部更新页面的技术。
Ajax 请求的局部更新，浏览器地址栏不会发生变化
局部更新不会舍弃原来页面的内容

2.2、原生 AJAX 请求的示例

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> 
	<head> 
		<meta http-equiv="pragma" content="no-cache" /> 
		<meta http-equiv="cache-control" content="no-cache" /> 
		<meta http-equiv="Expires" content="0" /> 
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 
		<title>Insert title here</title> 
		<script type="text/javascript"> 
		// 在这里使用 javaScript 语言发起 Ajax 请求，访问服务器 AjaxServlet 中 javaScriptAjax 
		function ajaxRequest() { 
		// 1、我们首先要创建 XMLHttpRequest 
		var xmlhttprequest = new XMLHttpRequest(); 
		// 2、调用 open 方法设置请求参数 
		xmlhttprequest.open("GET","http://localhost:8080/16_json_ajax_i18n/ajaxServlet?action=javaScriptAj ax",true) 
		// 3、在 send 方法前绑定 onreadystatechange 事件，处理请求完成后的操作。 
		xmlhttprequest.onreadystatechange = function(){ 
		if (xmlhttprequest.readyState == 4 && xmlhttprequest.status == 200) { 
		var jsonObj = JSON.parse(xmlhttprequest.responseText); 
		// 把响应的数据显示在页面上 
		document.getElementById("div01").innerHTML = "编号：" + jsonObj.id + " , 姓名：" + jsonObj.name; 
		} 
		} 
		// 4、调用 send 方法发送请求 
		xmlhttprequest.send(); 
		} 
		</script> 
	</head> 
	<body> 
		<button onclick="ajaxRequest()">ajax request</button> 
		<div id="div01"> 
		</div> 
	</body> 
</html>

2.3、jQuery 中的 AJAX 请求

$.ajax 方法
url 表示请求的地址
type 表示请求的类型为GET 或 POST 请求
data 表示发送给服务器的数据格式有两种：
一：name=value&name=value
二：{key:value} success 请求成功，响应的回调函数
dataType 表示响应的数据类型
常用的数据类型有：
text 表示纯文本
xml 表示 xml 数据
json 表示 json 对象

$("#ajaxBtn").click(function(){ 
	$.ajax({ 
		url:"http://localhost:8080/16_json_ajax_i18n/ajaxServlet", 
		// data:"action=jQueryAjax", 
		data:{action:"jQueryAjax"}, 
		type:"GET", 
		success:function (data) { 
			// alert("服务器返回的数据是：" + data); 
			// var jsonObj = JSON.parse(data); 
			$("#msg").html("编号：" + data.id + " , 姓名：" + data.name); 
		},
		dataType : "json" 
	}); 
});

$.get 方法和 $.post 方法
url 请求的 url 地址
data 发送的数据
callback 成功的回调函数
type 返回的数据类型

// ajax--get 请求 
$("#getBtn").click(function(){ 
	$.get("http://localhost:8080/16_json_ajax_i18n/ajaxServlet","action=jQueryGet",function (data) { 
		$("#msg").html(" get 编号：" + data.id + " , 姓名：" + data.name); 
	},"json"); 
}); 
// ajax--post 请求 
$("#postBtn").click(function(){ 
	$.post("http://localhost:8080/16_json_ajax_i18n/ajaxServlet","action=jQueryPost",function (data) { 
		$("#msg").html(" post 编号：" + data.id + " , 姓名：" + data.name);
	},"json"); 
});

$.getJSON 方法
url 表示请求的 url 地址
data 表示发送给服务器的数据
callback 表示成功的回调函数

// ajax--getJson 请求 
$("#getJSONBtn").click(function(){ 
	$.getJSON("http://localhost:8080/16_json_ajax_i18n/ajaxServlet","action=jQueryGetJSON",function (data) { 
		$("#msg").html(" getJSON 编号：" + data.id + " , 姓名：" + data.name); 
	}); 
});

表单序列化 serialize()
serialize()可以把表单中所有表单项的内容都获取到，并以 name=value&name=value 的形式进行拼接。

// ajax 请求 
$("#submit").click(function(){ 
	// 把参数序列化 
	$.getJSON("http://localhost:8080/16_json_ajax_i18n/ajaxServlet","action=jQuerySerialize&" + $("#form01").serialize(),function (data) { 
		$("#msg").html(" Serialize 编号：" + data.id + " , 姓名：" + data.name); 
	}); 
});

CSDN学习社区

CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！

更多推荐

用 OpenAI Assistants 做大模型应用开发

CSDN学习社区

1 小时解读鸿蒙 10 大热点问题

CSDN学习社区

1 小时解读鸿蒙 10 大热点问题

CSDN学习社区

所有评论(0)

查看更多评论

ok~~

@weixin_46597552

已为社区贡献1条内容

JavaWeb

ok~~

Servlet

一、Servlet 技术

1、什么是 Servlet

url 地址到程序的访问

2、Servlet 程序的生命周期

3、通过继承 HttpServlet 实现 Servlet 程序

Servlet 类的继承体系

二、ServletConfig 类

ServletConfig 类的三大作用

三、ServletContext 类

1、什么是 ServletContext ?

2、ServletContext类的四个作用

四、HTTP 协议

1、什么是 HTTP 协议

2、请求的 HTTP 协议格式

GET 请求

GET 请求的HTTP内容的图解

POST 请求

POST 请求的HTTP内容的图解

常用请求头的说明

哪些是 GET 请求，哪些是 POST 请求?

3、响应的 HTTP 协议格式

响应的 HTTP 格式

4、常用的响应码说明

五、HttpServletRequest 类

1、HttpServletRequest 类的作用

2、HttpServletRequest 类的常用方法

3、如何获取请求参数

doGet 请求的中文乱码解决方式

doPost 请求的中文乱码解决方式

请求转发

请求转发图解

base 标签的作用

Web 中的相对路径和绝对路径

web 中 / 斜杠的不同意义

六、HttpServletResponse 类

HttpServletResponse 类的作用

两个输出流的说明

字节流冲突异常

如何往客户端回传数据

响应的乱码解决

请求重定向

请求重定向

JSP

一、什么是 jsp ，它有什么用?

二、jsp 的本质是什么

三、jsp 的三种语法

jsp 头部的 page 指令

缓冲区溢出错误

jsp 中的常用脚本

声明脚本(极少使用)

表达式脚本（常用）

代码脚本

四、jsp 九大内置对象

五、jsp 四大域对象

六、jsp 中的 out 输出和 response.getWriter 输出的区别

七、jsp 的常用标签

jsp 静态包含

jsp 动态包含

jsp 标签-转发

八、什么是 Listener 监听器？

ServletContextListener 监听器

监听器实现类

web.xml 中的配置

EL 表达式 & JSTL 标签库

一、EL 表达式

什么是 EL 表达式，EL 表达式的作用?

EL 表达式搜索域数据的顺序

EL 表达式输出 Bean 的普通属性，数组属性。List 集 合属性，map 集合属性

Person类

输出的代码

EL 表达式——运算

关系运算

逻辑运算

算数运算

empty 运算

三元运算

“.”点运算 和 [] 中括号运算符

EL 表达式输出 Bean 的普通属性，数组属性。List 集合属性，map 集合属性

“.”点运算和 [] 中括号运算符