JavaWeb技术（上）

Html、CSS、JavaScript基础语法

点击这里了解

JSON

前后端都是使用对象来存储数据的，但是JS的对象和Java的对象并不能互通，两者是将数据转化成JSON进行传输的。

JSON(JavaScript Object Notation)JS对象简谱，采用完全独立于编程语言的文本格式来存储和表示数据。JSON是一种字符串格式，这种格式无论是在前端还是后端，都可以很容易的转换成对象，所以常用于前后端数据传递。

• JSON语法：var obj = '{"属性名": "属性值", ...}'

• JSON在客户端（前端）的使用：

  1. 获取JSON字符串
  2. 使用JSON.parse(jsonStr)将JSON转化成对象

• JSON在服务端（后端）的使用：

  1. 编写需要转化成JSON的对象或者获取到JSON时
  2. 使用GSON、Jackson、Fastjson等第三方工具类（需要导入jar包），将对象转化成JSON字符串。Jackson语法为：new ObjectMapper().writeValueAsString(jsonStr)和new ObjectMapper().readValue(jsonStr, 需要转化的类名.class)

BOM编程

​ BOM(Browser Object Model)浏览器对象模型，BOM由一系列对象组成，是访问、控制、修改浏览器的属性和方法(通过window对象及属性的一系列方法控制浏览器行为的一种编程)，BOM没有统一的标准(每种客户端都可以自定标准)，BOM编程是将浏览器窗口的各个组成部分抽象成各个对象,通过各个对象的API操作组件行为的一种编程。
BOM编程的对象结构如下：

• window：顶级对象,代表整个浏览器窗口
• location：window对象的属性之一,代表浏览器的地址栏
• history：window对象的属性之一,代表浏览器的访问历史
• screen：window对象的属性之一,代表屏幕
• navigator：window对象的属性之一,代表浏览器软件本身
• document：window对象的属性之一,代表浏览器窗口目前解析的html文档
• console：window对象的属性之一,代表浏览器开发者工具的控制台
• localStorage：window对象的属性之一,代表浏览器的本地数据持久化存储
• sessionStorage window对象的属性之一,代表浏览器的本地数据会话级存储（暂时存储）

DOM编程

​ DOM(Document Object Model)文档对象模型编程，就是使用document对象的API完成对网页HTML文档进行动态修改,以实现网页数据和样式动态变化效果的编程

DOM

当网页被加载时，浏览器会创建页面的文档对象模型（Document Object Model），HTML DOM 模型被结构化为对象树：

HTML DOM 是 HTML 的标准对象模型和编程接口。它定义了：

• 作为对象的 HTML 元素
• 所有 HTML 元素的属性
• 访问所有 HTML 元素的方法
• 所有 HTML 元素的事件

文档：一个页面就是一个文档，DOM中使用document 表示。
网页：框架标记（frameset iframe）一个页面中包含了多个文档documen对象
元素：页面中所有的标签都是元素，DOM中使用element表示
节点：页面中所有内容都是节点（标签、属性、文本、注释等），DOM中使用node表示

DOM基本方法

DOM能通过JS进行访问，DOM中所有HTML元素都被定义为对象。我们通过JS对这些对象操作，改变HTML元素的内容

• 使用getElementByID()方法可以获取带有ID的元素对象

<script>
var mydiv=document.getElementById('mydiv');
console.log(mydiv);
</script>
<div id="mydiv">my id a nice man</div>

• 使用getElementByTagname()方法可以返回带有指定标签名的对象集合

document.getElementByTagname('标签名')

也可以获取（父元素）内部所有指定标签名的子元素。

dlement.getElementBytagName('标签名');
//父元素必须是单个对象（必须指明）。

• getElementByName()方法可返回带有指定名称的对象的集合，它查询的元素是name属性，返回的是数组，不是一个元素

//根据类名返回元素对象集合
document.getElementsByClassName('类名');
//根据指定选择器返回第一个元素对象 里面的选择器需要加符号
document.querySelector('选择器');
//根据指定选择器返回
document.querySelectorAll('选择器');

• 获取body元素

document.body

• 获取html元素

document.dovumentElement

改变HTML元素

JavaScript的DOM操作可以改变网页内容、结构和样式，我们可以利用DOm操作元素来改变元素李的内容、属性等操作

element.innerHtml=new htmlcontent ：改变元素的HTML
element.innerTEXT=new text：改变元素的文本内容
element.attribute=new value：改变HTML元素的属性值
element.setAttribute(attribuute,value)：改变HTML元素的属性值
element.hasAttribute(attribute)：删除元素属性
element.removeAttribute(attribute)：删除元素属性
element.style.property=new style：改变html元素的样式

• 元素属性innerHtml就是元素的html代码，查找到元素后，可以对其innerHtml属性进行重新赋值修改

<div>
	<h1>hello<h1>
</div>
<script>
	var h1=document.querySelector("div");
	h1.innerHTML="<h2>World</h2>";
</script>

• element.innerText改变element中的文本

<div>
	<h1>hello<h1>
</div>
<script>
	var h1=document.querySelector("div");
	//改变文本，html不解析，同时去空格、换行
	h1.innerText="<h2>World</h2>";
</script>

• attribute 是代词，具体看元素属性。如a标签有href属性，可以使用element.gref来改变

<div>
    <a href="https://www.4399.com">网址</a>
</div>

<script>
    var a = document.querySelector("a");
    a.href = "https://www.qq.com";
</script>

• 通过 element.setAttribute 方法来改变元素属性值

element.setAttribute(attribute, value)

attribute：属性名
value：属性值

<div>
    <a class="hightlight" href="https://www.4399.com">网址</a>
</div>
<script>
 var a = document.querySelector("a"); 
//更改属性
 a.setAttribute("href","https://www.qq.com");
    // 用className方法更改 class 属性使用 
    // 注意空格，这里是增加一个class
    a.className += " hidden";  
    // 用 setAttribute 更改 class 属性直接用 class
    // 也可写两个属性
    a.setAttribute("class", "hightlight hidden");
</script>

• 通过element.hasAttribute判断是否有指定属性

<a href="www.baidu.com">bd</a>
<script>
var a=documnet.querySelector("a");
a.hasAttribute("href");//返回true
</script>

• 通过element.removeAttribute移除指定元素

<a date-index="1">123</a>
<script>
var a=documnet.querySelector("a");
a.removeAttribute("date-index");
</script>

• 使用元素中style 属性可以修改元素样式，修改的样式直接作用在css样式里

  • css中原本使用“-”连接的名字要转换成驼峰式，如background-color -> backgroundColor

  • 修改样式的属性名需要改写

  • 属性值都是字符串，设置是必须包括单位

<div><a href="www.4399.com">网址</a></div>
<script>
var a =document.querySelector("a");
a.style.fontSize="30px";
</script>

获取HTML元素

• 利用DOM树可把节点划分不同的关系，node.parentNode:可返回最近的一个父节点，如果没有返回null
• parentNode.childNodes(标准)：返回指定节点的子节点的集合;返回值包括所有的子节点、元素节点、文本节点。
• parentNodes.children(非标准)：一个只读属性，只返回所有子元素节点，其他节点不返回；获取所有元素节点，需要其他特殊处理，一般不推荐使用childNode，但浏览器都支持。

var ul=document.querySelector('ul');
for(var i = 0; i < ul.childNodes.lenth; i++) {
		if(ul.childNodes[i].nodeType == 1) {
		//ul.childNodes[i] 是元素节点
		console.log(ul.childNodes[i]);
		}
	}

• parentNode.firstChild:返回一个子节点，找不到返回null，包含所有的节点。
• parentNode.lastChild:返回最后一个子节点，找不到返回null，也包含所有节点
  以下两个只支持IE9以上
• parentNode.firstElementChild:返回第一个子节点，找不到返回null。
• parentNode.lastElementChild:返回最后一个元素节点，找不到返回null。
• node.nextSibling:返回当前元素的下一个兄弟节点，找不到返回null，包括所有节点。
• node.previousSibling:返回当前元素的上一个兄弟节点，找不到返回null，包括所有节点。
  指定节点（只支持IE9以上）
• node.nextElementSibling:返回当前元素下一个兄弟元素节点，找不到返回null。
• node.nextpreviousElementSibling:返回当前元素上一个兄弟节点，找不到返回null。

操作HTML元素

• document.createElement():方法创建由tagName指定的html元素（动态创建元素点）。

• node.appendChild():方法将一个节点添加到父节点的子节点列表末尾。

• node.insertBefore(child,指定元素):

// 添加节点 node.appendChild(child)  node 父级  child子级
var ul = document.querySelector('ul');
ul.appendChild(li);
//node.insertBefore(child,指定元素);
var lili = document.createElement('li');
ul.insertBefore(lili,ul.children[0]);

• node.removeChild(child):方法从DOM中删除一个子节点，返回删除的节点

Tomcat

Tomcat是一款JavaWeb服务器，Tomcat技术先进、性能稳定，而且免费开源，因而深受Java爱好者的喜爱并得到了部分软件开发商的认可，成为比较流行的Web应用服务器

Tomcat目录及测试

• bin：该目录下存放的是二进制可执行文件，如果是安装版，那么这个目录下会有两个exe文件：tomcat10.exe、tomcat10w.exe，前者是在控制台下启动Tomcat，后者是弹出GUI窗口启动Tomcat；如果是解压版，那么会有startup.bat和shutdown.bat文件，startup.bat用来启动Tomcat，但需要先配置JAVA_HOME环境变量才能启动，shutdawn.bat用来停止Tomcat

• conf：这个目录下有四个最为重要的文件：

  • server.xml：配置整个服务器信息。例如修改端口号。默认HTTP请求的端口号是：8080

  • tomcat-users.xml：存储tomcat用户的文件，这里保存的是tomcat的用户名及密码，以及用户的角色信息。可以按着该文件中的注释信息添加tomcat用户，然后就可以在Tomcat主页中进入Tomcat Manager页面

    <tomcat-users xmlns="http://tomcat.apache.org/xml"
                  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                  xsi:schemaLocation="http://tomcat.apache.org/xml tomcat-users.xsd"
                  version="1.0">	
    	<role rolename="admin-gui"/>
    	<role rolename="admin-script"/>
    	<role rolename="manager-gui"/>
    	<role rolename="manager-script"/>
    	<role rolename="manager-jmx"/>
    	<role rolename="manager-status"/>
    	<user 	username="admin" 
    			password="admin" 
    			roles="admin-gui,admin-script,manager-gui,manager-script,manager-jmx,manager-status"
    	/>
    </tomcat-users>

  • web.xml：部署描述符文件，这个文件中注册了很多MIME类型，即文档类型。这些MIME类型是客户端与服务器之间说明文档类型的，如用户请求一个html网页，那么服务器还会告诉客户端浏览器响应的文档是text/html类型的，这就是一个MIME类型。客户端浏览器通过这个MIME类型就知道如何处理它了。当然是在浏览器中显示这个html文件了。但如果服务器响应的是一个exe文件，那么浏览器就不可能显示它，而是应该弹出下载窗口才对。MIME是用来说明文档的内容是什么类型的

  • context.xml：对所有应用的统一配置，通常不会去配置它

• lib：Tomcat的类库，里面是一大堆jar文件。如果需要添加Tomcat依赖的jar文件，可以把它放到这个目录中，当然也可以把应用依赖的jar文件放到这个目录中，这个目录中的jar所有项目都可以共享之，但这样你的应用放到其他Tomcat下时就不能再共享这个目录下的jar包了，所以建议只把Tomcat需要的jar包放到这个目录下；

• logs：这个目录中都是日志文件，记录了Tomcat启动和关闭的信息，如果启动Tomcat时有错误，那么异常也会记录在日志文件中

• temp：存放临时文件

• webapps：存放web项目的目录，其中每个文件夹都是一个项目；如果这个目录下已经存在了目录，那么都是tomcat自带的项目。其中ROOT是一个特殊的项目，在地址栏中访问http://127.0.0.1:8080，没有给出项目目录时，对应的就是ROOT项目.http://localhost:8080/examples，进入示例项目

• work：运行时生成的文件，最终运行的文件都在这里。通过webapps中的项目生成。可以把这个目录下的内容删除，再次运行时会生再次生成work目录。当客户端用户访问一个JSP文件时，Tomcat会通过JSP生成Java文件，然后再编译Java文件生成class文件，生成的java和class文件都会存放到这个目录下

Web项目的标准结构

app：应用根目录

• static 非必要目录,约定俗成的名字,一般在此处放静态资源 ( css js img)
• WEB-INF：必要目录,必须叫WEB-INF,受保护的资源目录,浏览器通过url不可以直接访问的目录
  • classes：必要目录,src下源代码,配置文件,编译后会在该目录下,web项目中如果没有源码,则该目录不会出现
  • lib：必要目录,项目依赖的jar编译后会出现在该目录下,web项目要是没有依赖任何jar,则该目录不会出现
  • web.xml：必要文件,web项目的基本配置文件. 较新的版本中可以没有该文件,但是学习过程中还是需要该文件
• index.html：非必要文件,index.html/index.htm/index.jsp为默认的欢迎页

Web项目的部署方式

方式1 直接将编译好的项目放在webapps目录下

方式2 将编译好的项目打成war包放在webapps目录下,tomcat启动后会自动解压war包

方式3 可以将项目放在非webapps的其他目录下,在tomcat中通过配置文件指向app的实际磁盘路径

• 在磁盘的自定义目录上准备一个app

• 在tomcat的conf下创建Catalina/localhost目录,并在该目录下准备一个app.xml文件

<!-- 
	path: 项目的访问路径,也是项目的上下文路径,就是在浏览器中,输入的项目名称
    docBase: 项目在磁盘中的实际路径
 -->
<Context path="/app" docBase="D:\mywebapps\app" />

• 启动tomcat访问测试即可

IDEA部署项目并运行的原理

• idea并没有直接进将编译好的项目放入tomcat的webapps中
• idea根据关联的tomcat,创建了一个tomcat副本,将项目部署到了这个副本中
• idea的tomcat副本在C:\用户\当前用户\AppData\Local\JetBrains\IntelliJIdea\tomcat\
• idea的tomcat副本并不是一个完整的tomcat,副本里只是准备了和当前项目相关的配置文件
• idea启动tomcat时,是让本地tomcat程序按照tomcat副本里的配置文件运行
• idea的tomcat副本部署项目的模式通过conf/Catalina/localhost/*.xml配置文件的形式实现项目部署

Servlet

Servlet (server applet) 是运行在服务端(tomcat)的Java小程序，是sun公司提供一套定义动态资源规范; 从代码层面上来讲Servlet就是一个接口

• Servlet用来接收、处理客户端请求、响应给浏览器的动态资源。在整个Web应用中，Servlet主要负责接收处理请求、协同调度功能以及响应数据。我们可以把Servlet称为Web应用中的控制器

• 不是所有的JAVA类都能用于处理客户端请求,能处理客户端请求并做出响应的一套技术标准就是Servlet

• Servlet是运行在服务端的,所以Servlet必须在WEB项目##中开发且在Tomcat这样的服务容器中运行

使用实例

步骤1 开发一个web类型的module

步骤2 开发一个UserServlet

public class UserServlet  extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取请求中的参数
        String username = req.getParameter("username");
        if("atguigu".equals(username)){
            //通过响应对象响应信息
            resp.getWriter().write("NO");
        }else{
            resp.getWriter().write("YES");
        }

    }
}

• 自定义一个类,要继承HttpServlet类
• 重写service方法,该方法主要就是用于处理用户请求的服务方法
• HttpServletRequest 代表请求对象,是有请求报文经过tomcat转换而来的,通过该对象可以获取请求中的信息
• HttpServletResponse 代表响应对象,该对象会被tomcat转换为响应的报文,通过该对象可以设置响应中的信息
• Servlet对象的生命周期(创建,初始化,处理服务,销毁)是由tomcat管理的,无需我们自己new
• HttpServletRequest HttpServletResponse 两个对象也是有tomcat负责转换,在调用service方法时传入给我们用的

步骤3 在web.xml为UseServlet配置请求的映射路径

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.0">

    <servlet>
        <!--给UserServlet起一个别名-->
        <servlet-name>userServlet</servlet-name>
        <servlet-class>com.atguigu.servlet.UserServlet</servlet-class>
    </servlet>


    <servlet-mapping>
        <!--关联别名和映射路径-->
        <servlet-name>userServlet</servlet-name>
        <!--可以为一个Servlet匹配多个不同的映射路径,但是不同的Servlet不能使用相同的url-pattern-->
        <url-pattern>/userServlet</url-pattern>
       <!-- <url-pattern>/userServlet2</url-pattern>-->
        <!--
            /        表示通配所有资源,不包括jsp文件
            /*       表示通配所有资源,包括jsp文件
            /a/*     匹配所有以a前缀的映射路径
            *.action 匹配所有以action为后缀的映射路径
        -->
       <!-- <url-pattern>/*</url-pattern>-->
    </servlet-mapping>

</web-app>

• Servlet并不是文件系统中实际存在的文件或者目录,所以为了能够请求到该资源,我们需要为其配置映射路径
• servlet的请求映射路径配置在web.xml中
• servlet-name作为servlet的别名,可以自己随意定义,见名知意就好
• url-pattern标签用于定义Servlet的请求映射路径
• 一个servlet可以对应多个不同的url-pattern
• 多个servlet不能使用相同的url-pattern
• url-pattern中可以使用一些通配写法
  • / 表示通配所有资源,不包括jsp文件
  • /* 表示通配所有资源,包括jsp文件
  • /a/* 匹配所有以a前缀的映射路径
  • *.action 匹配所有以action为后缀的映射路径

步骤4 开发一个form表单,向servlet发送一个get请求并携带username参数

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="userServlet">
        请输入用户名:<input type="text" name="username" /> <br>
        <input type="submit" value="校验">
    </form>
</body>
</html>

启动项目,访问index.html ,提交表单测试

生命周期

什么是Servlet的生命周期

• 应用程序中的对象不仅在空间上有层次结构的关系，在时间上也会因为处于程序运行过程中的不同阶段而表现出不同状态和不同行为——这就是对象的生命周期。
• 简单的叙述生命周期，就是对象在容器中从开始创建到销毁的过程。

Servlet容器

• Servlet对象是Servlet容器创建的，生命周期方法都是由容器(目前我们使用的是Tomcat)调用的。这一点和我们之前所编写的代码有很大不同。在今后的学习中我们会看到，越来越多的对象交给容器或框架来创建，越来越多的方法由容器或框架来调用，开发人员要尽可能多的将精力放在业务逻辑的实现上。

Servlet主要的生命周期执行特点

生命周期	对应方法	执行时机	执行次数
构造对象	构造器	第一次请求或者容器启动	1
初始化	init()	构造完毕后	1
处理服务	service(HttpServletRequest req,HttpServletResponse resp)	每次请求	多次
销毁	destory()	容器关闭时	1

1. Servlet对象在容器中是单例的
2. 容器是可以处理并发的用户请求的,每个请求在容器中都会开启一个线程
3. 多个线程可能会使用相同的Servlet对象,所以在Servlet中,我们不要轻易定义一些容易经常发生修改的成员变量
4. load-on-startup中定义的正整数表示实例化顺序,如果数字重复了,容器会自行解决实例化顺序问题,但是应该避免重复
5. Tomcat容器中,已经定义了一些随系统启动实例化的servlet,我们自定义的servlet的load-on-startup尽量不要占用数字1-5

ServletConfig

• ServletConfig为Servlet提供初始配置参数的一种对象,每个Servlet都有自己独立唯一的ServletConfig对象
• 容器会为每个Servlet实例化一个ServletConfig对象,并通过Servlet生命周期的init方法传入给Servlet作为属性

了解是什么即可

ServletContext

• ServletContext对象有称呼为上下文对象,或者叫应用域对象
• 容器会为每个app创建一个独立的唯一的ServletContext对象
• ServletContext对象为所有的Servlet所共享
• ServletContext可以为所有的Servlet提供初始配置参数

ServletContext重要API

获取资源的真实路径

String realPath = servletContext.getRealPath("资源在web目录中的路径");

• 例如我们的目标是需要获取项目中某个静态资源的路径，不是工程目录中的路径，而是部署目录中的路径；我们如果直接拷贝其在我们电脑中的完整路径的话其实是有问题的，因为如果该项目以后部署到公司服务器上的话，路径肯定是会发生改变的，所以我们需要使用代码动态获取资源的真实路径. 只要使用了servletContext动态获取资源的真实路径，那么无论项目的部署路径发生什么变化，都会动态获取项目运行时候的实际路径，所以就不会发生由于写死真实路径而导致项目部署位置改变引发的路径错误问题

获取项目的上下文路径

String contextPath = servletContext.getContextPath();

• 项目的部署名称,也叫项目的上下文路径,在部署进入tomcat时所使用的路径,该路径是可能发生变化的,通过该API动态获取项目真实的上下文路径,可以帮助我们解决一些后端页面渲染技术或者请求转发和响应重定向中的路径问题

域对象的相关API

• 域对象: 一些用于存储数据和传递数据的对象,传递数据不同的范围,我们称之为不同的域,不同的域对象代表不同的域,共享数据的范围也不同
• ServletContext代表应用,所以ServletContext域也叫作应用域,是webapp中最大的域,可以在本应用内实现数据的共享和传递
• webapp中的三大域对象,分别是应用域,会话域,请求域

API	功能解释
void setAttribute(String key,Object value);	向域中存储/修改数据
Object getAttribute(String key);	获得域中的数据
void removeAttribute(String key);	移除域中的数据

HttpServletRequest

• HttpServletRequest是一个接口,其父接口是ServletRequest
• HttpServletRequest是Tomcat将请求报文转换封装而来的对象,在Tomcat调用service方法时传入
• HttpServletRequest代表客户端发来的请求,所有请求中的信息都可以通过该对象获得

HttpServletRequest常见API

• 获取请求行信息相关(方式,请求的url,协议及版本)

API	功能解释
StringBuffer getRequestURL();	获取客户端请求的url
String getRequestURI();	获取客户端请求项目中的具体资源
int getServerPort();	获取客户端发送请求时的端口
int getLocalPort();	获取本应用在所在容器的端口
int getRemotePort();	获取客户端程序的端口
String getScheme();	获取请求协议
String getProtocol();	获取请求协议及版本号
String getMethod();	获取请求方式

• 获得请求头信息相关

API	功能解释
String getHeader(String headerName);	根据头名称获取请求头
Enumeration getHeaderNames();	获取所有的请求头名字
String getContentType();	获取content-type请求头

• 获得请求参数相关

API	功能解释
String getParameter(String parameterName);	根据请求参数名获取请求单个参数值
String[] getParameterValues(String parameterName);	根据请求参数名获取请求多个参数值数组
Enumeration getParameterNames();	获取所有请求参数名
Map<String, String[]> getParameterMap();	获取所有请求参数的键值对集合
BufferedReader getReader() throws IOException;	获取读取请求体的字符输入流
ServletInputStream getInputStream() throws IOException;	获取读取请求体的字节输入流
int getContentLength();	获得请求体长度的字节数

• 其他API

API	功能解释
String getServletPath();	获取请求的Servlet的映射路径
ServletContext getServletContext();	获取ServletContext对象
Cookie[] getCookies();	获取请求中的所有cookie
HttpSession getSession();	获取Session对象
void setCharacterEncoding(String encoding) ;	设置请求体字符集

HttpServletResponse

• HttpServletResponse是一个接口,其父接口是ServletResponse
• HttpServletResponse是Tomcat预先创建的,在Tomcat调用service方法时传入
• HttpServletResponse代表对客户端的响应,该对象会被转换成响应的报文发送给客户端,通过该对象我们可以设置响应信息

HttpServletResponse的常见API

• 设置响应行相关

API	功能解释
void setStatus(int code);	设置响应状态码

• 设置响应头相关

API	功能解释
void setHeader(String headerName, String headerValue);	设置/修改响应头键值对
void setContentType(String contentType);	设置content-type响应头及响应字符集(设置MIME类型)

• 设置响应体相关

API	功能解释
PrintWriter getWriter() throws IOException;	获得向响应体放入信息的字符输出流
ServletOutputStream getOutputStream() throws IOException;	获得向响应体放入信息的字节输出流
void setContentLength(int length);	设置响应体的字节长度,其实就是在设置content-length响应头

• 其他API

API	功能解释
void sendError(int code, String message) throws IOException;	向客户端响应错误信息的方法,需要指定响应码和响应信息
void addCookie(Cookie cookie);	向响应体中增加cookie
void setCharacterEncoding(String encoding);	设置响应体字符集

MIME类型

• MIME类型,可以理解为文档类型,用户表示传递的数据是属于什么类型的文档
• 浏览器可以根据MIME类型决定该用什么样的方式解析接收到的响应体数据
• 可以这样理解: 前后端交互数据时,告诉对方发给对方的是 html/css/js/图片/声音/视频/… …
• tomcat/conf/web.xml中配置了常见文件的拓展名和MIMIE类型的对应关系
• 常见的MIME类型举例如下

文件拓展名	MIME类型
.html	text/html
.css	text/css
.js	application/javascript
.png /.jpeg/.jpg/… …	image/jpeg
.mp3/.mpe/.mpeg/ … …	audio/mpeg
.mp4	video/mp4
.m1v/.m1v/.m2v/.mpe/… …	video/mpeg

请求转发和响应重定向

• 请求转发和响应重定向是web应用中间接访问项目资源的两种手段,也是Servlet控制页面跳转的两种手段
• 请求转发通过HttpServletRequest实现,响应重定向通过HttpServletResponse实现

请求转发

• 请求转发通过HttpServletRequest对象获取请求转发器实现
• 请求转发是服务器内部的行为,对客户端是屏蔽的
• 客户端只发送了一次请求,客户端地址栏不变
• 服务端只产生了一对请求和响应对象,这一对请求和响应对象会继续传递给下一个资源
• 因为全程只有一个HttpServletRequset对象,所以请求参数可以传递,请求域中的数据也可以传递
• 请求转发可以转发给其他Servlet动态资源,也可以转发给一些静态资源以实现页面跳转
• 请求转发可以转发给WEB-INF下受保护的资源
• 请求转发不能转发到本项目以外的外部资源

示例

• ServletA

@WebServlet("/servletA")
public class ServletA extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //  获取请求转发器
        //  转发给servlet  ok
        RequestDispatcher  requestDispatcher = req.getRequestDispatcher("servletB");
        //  转发给一个视图资源 ok
        //RequestDispatcher requestDispatcher = req.getRequestDispatcher("welcome.html");
        //  转发给WEB-INF下的资源  ok
        //RequestDispatcher requestDispatcher = req.getRequestDispatcher("WEB-INF/views/view1.html");
        //  转发给外部资源   no
        //RequestDispatcher requestDispatcher = req.getRequestDispatcher("http://www.atguigu.com");
        //  获取请求参数
        String username = req.getParameter("username");
        System.out.println(username);
        //  向请求域中添加数据
        req.setAttribute("reqKey","requestMessage");
        //  做出转发动作
        requestDispatcher.forward(req,resp);
    }
}

• ServletB

@WebServlet("/servletB")
public class ServletB extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取请求参数
        String username = req.getParameter("username");
        System.out.println(username);
        // 获取请求域中的数据
        String reqMessage = (String)req.getAttribute("reqKey");
        System.out.println(reqMessage);
        // 做出响应
        resp.getWriter().write("servletB response");        
    }
}

响应重定向

• 响应重定向通过HttpServletResponse对象的sendRedirect方法实现
• 响应重定向是服务端通过302响应码和路径,告诉客户端自己去找其他资源,是在服务端提示下的,客户端的行为
• 客户端至少发送了两次请求,客户端地址栏是要变化的
• 服务端产生了多对请求和响应对象,且请求和响应对象不会传递给下一个资源
• 因为全程产生了多个HttpServletRequset对象,所以请求参数不可以传递,请求域中的数据也不可以传递
• 重定向可以是其他Servlet动态资源,也可以是一些静态资源以实现页面跳转
• 重定向不可以到给WEB-INF下受保护的资源
• 重定向可以到本项目以外的外部资源

示例

• ServletA

@WebServlet("/servletA")
public class ServletA extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //  获取请求参数
        String username = req.getParameter("username");
        System.out.println(username);
        //  向请求域中添加数据
        req.setAttribute("reqKey","requestMessage");
        //  响应重定向
        // 重定向到servlet动态资源 OK
        resp.sendRedirect("servletB");
        // 重定向到视图静态资源 OK
        //resp.sendRedirect("welcome.html");
        // 重定向到WEB-INF下的资源 NO
        //resp.sendRedirect("WEB-INF/views/view1");
        // 重定向到外部资源
        //resp.sendRedirect("http://www.atguigu.com");
    }
}

• ServletB

@WebServlet("/servletB")
public class ServletB extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取请求参数
        String username = req.getParameter("username");
        System.out.println(username);
        // 获取请求域中的数据
        String reqMessage = (String)req.getAttribute("reqKey");
        System.out.println(reqMessage);
        // 做出响应
        resp.getWriter().write("servletB response");

    }
}

同样实现页面跳转，只要重定向能做到，就优先使用重定向！！！

MVC架构

MVC（Model View Controller）是软件工程中的一种**软件架构模式，它把软件系统分为模型、视图和控制器**三个基本部分。用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。

• M：Model 模型层,具体功能如下

  1. 存放和数据库对象的实体类以及一些用于存储非数据库表完整相关的VO对象
  2. 存放一些对数据进行逻辑运算操作的的一些业务处理代码

• V：View 视图层,具体功能如下

  1. 存放一些视图文件相关的代码 html css js等
  2. 在前后端分离的项目中,后端已经没有视图文件,该层次已经衍化成独立的前端项目

• C：Controller 控制层,具体功能如下

  1. 接收客户端请求,获得请求数据
  2. 将准备好的数据响应给客户端

MVC模式下,项目中的常见包

• M:
  1. 实体类包(pojo /entity /bean) 专门存放和数据库对应的实体类和一些VO对象
  2. 数据库访问包(dao/mapper) 专门存放对数据库不同表格CURD方法封装的一些类
  3. 服务包(service) 专门存放对数据进行业务逻辑运算的一些类
• C: 控制层包(controller)
• V:
  1. web目录下的视图资源 html css js img 等
  2. 前端工程化后,在后端项目中已经不存在了

会话

为什么需要会话管理

HTTP是无状态协议

• 无状态就是不保存状态,即无状态协议(stateless),HTTP协议自身不对请求和响应之间的通信状态进行保存,也就是说,在HTTP协议这个级别,协议对于发送过的请求或者响应都不做持久化处理
• 简单理解:浏览器发送请求,服务器接收并响应,但是服务器不记录请求是否来自哪个浏览器,服务器没记录浏览器的特征,就是客户端的状态

会话管理实现的手段

Cookie和Session配合解决

• cookie是在客户端保留少量数据的技术,主要通过响应头向客户端响应一些客户端要保留的信息
• session是在服务端保留更多数据的技术,主要通过HttpSession对象保存一些和客户端相关的信息
• cookie和session配合记录请求状态

Cookie

cookie是一种客户端会话技术,cookie由服务端产生,它是服务器存放在浏览器的一小份数据,浏览器以后每次访问该服务器的时候都会将这小份数据携带到服务器去。

• 服务端创建cookie,将cookie放入响应对象中,Tomcat容器将cookie转化为set-cookie响应头,响应给客户端
• 客户端在收到cookie的响应头时,在下次请求该服务的资源时,会以cookie请求头的形式携带之前收到的Cookie
• cookie是一种键值对格式的数据,从tomcat8.5开始可以保存中文,但是不推荐
• 由于cookie是存储于客户端的数据,比较容易暴露,一般不存储一些敏感或者影响安全的数据

Cookie的使用

servletA向响应中增加Cookie

@WebServlet("/servletA")
public class ServletA extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 创建Cookie
        Cookie cookie1 =new Cookie("c1","c1_message");
        Cookie cookie2 =new Cookie("c2","c2_message");
        // 将cookie放入响应对象
        resp.addCookie(cookie1);
        resp.addCookie(cookie2);
    }
}

servletB从请求中读取Cookie

@WebServlet("/servletB")
public class ServletB extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取请求中的cookie
        Cookie[] cookies = req.getCookies();
        //迭代cookies数组
        if (null != cookies && cookies.length!= 0) {
            for (Cookie cookie : cookies) {
                System.out.println(cookie.getName()+":"+cookie.getValue());
            }
        }
    }
}

Cookie时效性

默认情况下Cookie的有效期是一次会话范围内，我们可以通过cookie的setMaxAge()方法让Cookie持久化保存到浏览器上

• 会话级Cookie
  • 服务器端并没有明确指定Cookie的存在时间
  • 在浏览器端，Cookie数据存在于内存中
  • 只要浏览器还开着，Cookie数据就一直都在
  • 浏览器关闭，内存中的Cookie数据就会被释放
• 持久化Cookie
  • 服务器端明确设置了Cookie的存在时间
  • 在浏览器端，Cookie数据会被保存到硬盘上
  • Cookie在硬盘上存在的时间根据服务器端限定的时间来管控，不受浏览器关闭的影响
  • 持久化Cookie到达了预设的时间会被释放

cookie.setMaxAge(int expiry)参数单位是秒，表示cookie的持久化时间，如果设置参数为0，表示将浏览器中保存的该cookie删除

• servletA设置一个Cookie为持久化cookie

@WebServlet("/servletA")
public class ServletA extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 创建Cookie
        Cookie cookie1 = new Cookie("c1","c1_message");
        cookie1.setMaxAge(60);
        Cookie cookie2 = new Cookie("c2","c2_message");
        // 将cookie放入响应对象
        resp.addCookie(cookie1);
        resp.addCookie(cookie2);
    }
}

• servletB接收Cookie,浏览器中间发生一次重启再请求servletB测试

@WebServlet("/servletB")
public class ServletB extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取请求中的cookie
        Cookie[] cookies = req.getCookies();
        //迭代cookies数组
        if (null != cookies && cookies.length != 0) {
            for (Cookie cookie : cookies) {
                System.out.println(cookie.getName()+":"+cookie.getValue());
            }
        }
    }
}

Cookie的提交路径

访问互联网资源时不能每次都需要把所有Cookie带上。访问不同的资源时,可以携带不同的cookie,我们可以通过cookie的setPath(String path) 对cookie的路径进行设置

• 从ServletA中获取cookie

public class ServletA extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 创建Cookie
        Cookie cookie1 =new Cookie("c1","c1_message");
        // 设置cookie的提交路径，向ServletB请求时会携带c1，向其他资源请求时不携带c1
        cookie1.setPath("/web03_war_exploded/servletB");
        Cookie cookie2 =new Cookie("c2","c2_message");
        // 将cookie放入响应对象
        resp.addCookie(cookie1);
        resp.addCookie(cookie2);
    }
}

Session

HttpSession是一种保留更多信息在服务端的一种技术,服务器会为每一个客户端开辟一块内存空间,即session对象. 客户端在发送请求时,都可以使用自己的session. 这样服务端就可以通过session来记录某个客户端的状态了

• 服务端在为客户端创建session时,会同时将session对象的id,即JSESSIONID以cookie的形式放入响应对象
• 后端创建完session后,客户端会收到一个特殊的cookie,叫做JSESSIONID
• 客户端下一次请求时携带JSESSIONID,后端收到后,根据JSESSIONID找到对应的session对象
• 通过该机制,服务端通过session就可以存储一些专门针对某个客户端的信息了
• session也是域对象

HttpSession的使用

用户提交form表单到ServletA,携带用户名,ServletA获取session 将用户名存到Session,用户再请求其他任意Servlet,获取之间存储的用户

• 定义表单页,提交用户名,提交后

<form action="servletA" method="post">
    用户名:
    <input type="text" name="username">
    <input type="submit" value="提交">
</form>

• 定义ServletA,将用户名存入session

@WebServlet("/servletA")
public class ServletA extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取请求中的参数
        String username = req.getParameter("username");
        // 获取session对象
        HttpSession session = req.getSession();
         // 获取Session的ID
        String jSessionId = session.getId();
        System.out.println(jSessionId);
        // 判断session是不是新创建的session
        boolean isNew = session.isNew();
        System.out.println(isNew);
        // 向session对象中存入数据
        session.setAttribute("username",username);

    }
}

• 定义其他Servlet,从session中读取用户名

@WebServlet("/servletB")
public class ServletB extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取session对象
        HttpSession session = req.getSession();
         // 获取Session的ID
        String jSessionId = session.getId();
        System.out.println(jSessionId);
        // 判断session是不是新创建的session
        boolean isNew = session.isNew();
        System.out.println(isNew);
        // 从session中取出数据
        String username = (String)session.getAttribute("username");
        System.out.println(username);
    }
}

getSession方法的处理逻辑

HttpSession时效性

为什么要设置session的时效

• 用户量很大之后，Session对象相应的也要创建很多。如果一味创建不释放，那么服务器端的内存迟早要被耗尽。
• 客户端关闭行为无法被服务端直接侦测,或者客户端较长时间不操作也经常出现,类似这些的情况,就需要对session的时限进行设置了
• 默认的session最大闲置时间(两次使用同一个session中的间隔时间) 在tomcat/conf/web.xml配置为30分钟

可以通过HttpSession的API对最大闲置时间进行设定

// 设置最大闲置时间
session.setMaxInactiveInterval(60);

可以直接让session失效

// 直接让session失效
session.invalidate();

三大域对象

域对象: 一些用于存储数据和传递数据的对象,传递数据不同的范围,我们称之为不同的域,不同的域对象代表不同的域,共享数据的范围也不同

• web项目中,我们一定要熟练使用的域对象分别是:请求域,会话域,应用域
• 请求域对象是HttpServletRequest,传递数据的范围是一次请求之内及请求转发
• 会话域对象是HttpSession,传递数据的范围是一次会话之内,可以跨多个请求
• 应用域对象是ServletContext,传递数据的范围是本应用之内,可以跨多个会话

三大域对象的数据作用范围

域对象常用API

API	功能
void setAttribute(String name,String value)	向域对象中添加/修改数据
Object getAttribute(String name);	从域对象中获取数据
removeAttribute(String name);	移除域对象中的数据

示例

• ServletA向三大域中放入数据

@WebServlet("/servletA")
public class ServletA extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 向请求域中放入数据
        req.setAttribute("request","request-message");
        //req.getRequestDispatcher("servletB").forward(req,resp);
        // 向会话域中放入数据
        HttpSession session = req.getSession();
        session.setAttribute("session","session-message");
        // 向应用域中放入数据
        ServletContext application = getServletContext();
        application.setAttribute("application","application-message");

    }
}

• ServletB从三大于中取出数据

@WebServlet("/servletB")
public class ServletB extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 从请求域中获取数据
        String reqMessage =(String)req.getAttribute("request");
        System.out.println(reqMessage);
        
        // 从会话域中获取数据
        HttpSession session = req.getSession();
        String sessionMessage =(String)session.getAttribute("session");
        System.out.println(sessionMessage);
        // 从应用域中获取数据
        ServletContext application = getServletContext();
        String applicationMessage =(String)application.getAttribute("application");
        System.out.println(applicationMessage);
    }
}

• 请求转发时,请求域可以传递数据请求域内一般放本次请求业务有关的数据,如:查询到的所有的部门信息
• 同一个会话内,不用请求转发,会话域可以传递数据会话域内一般放本次会话的客户端有关的数据,如:当前客户端登录的用户
• 同一个APP内,不同的客户端,应用域可以传递数据应用域内一般放本程序应用有关的数据 如:Spring框架的IOC容器

Filter

Filter,即过滤器,是JAVAEE技术规范之一,作用目标资源的请求进行过滤的一套技术规范,是Java Web项目中最为实用的技术之一

• Filter接口定义了过滤器的开发规范,所有的过滤器都要实现该接口
• Filter的工作位置是项目中所有目标资源之前,容器在创建HttpServletRequest和HttpServletResponse对象后,会先调用Filter的doFilter方法
• Filter的doFilter方法可以控制请求是否继续,如果放行,则请求继续,如果拒绝,则请求到此为止,由过滤器本身做出响应
• Filter不仅可以对请求做出过滤,也可以在目标资源做出响应前,对响应再次进行处理
• Filter是GOF中责任链模式的典型案例
• Filter的常用应用包括但不限于: 登录权限检查,解决网站乱码,过滤敏感字符,日志记录,性能分析… …

过滤器开发中应用的场景

• 日志的记录
• 性能的分析
• 乱码的处理
• 事务的控制
• 登录的控制
• 跨域的处理

过滤器工作位置图解

常用API

API	目标
default public void init(FilterConfig filterConfig)	初始化方法,由容器调用并传入初始配置信息filterConfig对象
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)	过滤方法,核心方法,过滤请求,决定是否放行,响应之前的其他处理等都在该方法中
default public void destroy()	销毁方法,容器在回收过滤器对象之前调用的方法

Filter使用实例

目标:开发一个日志记录过滤器

• 用户请求到达目标资源之前,记录用户的请求资源路径
• 响应之前记录本次请求目标资源运算的耗时
• 可以选择将日志记录进入文件,为了方便测试,这里将日志直接在控制台打印

定义一个过滤器类,编写功能代码

public class LoggingFilter  implements Filter {

    private SimpleDateFormat dateFormat =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        // 参数父转子
        HttpServletRequest request =(HttpServletRequest)  servletRequest;
        HttpServletResponse  response =(HttpServletResponse)  servletResponse;
        // 拼接日志文本
        String requestURI = request.getRequestURI();
        String time = dateFormat.format(new Date());
        String beforeLogging =requestURI+"在"+time+"被请求了";
        System.out.println(beforeLogging);
        // 放行请求
        filterChain.doFilter(request,response);
        System.out.println(afterLogging);

    }
}

• 说明
  • doFilter方法中的请求和响应对象是以父接口的形式声明的,实际传入的实参就是HttpServletRequest和HttpServletResponse子接口级别的,可以安全强转
  • filterChain.doFilter(request,response); 这行代码的功能是放行请求,如果没有这一行代码,则请求到此为止
  • filterChain.doFilter(request,response);在放行时需要传入request和response,意味着请求和响应对象要继续传递给后续的资源,这里没有产生新的request和response对象

定义两个Servlet作为目标资源

• ServletA

@WebServlet(urlPatterns = "/servletA",name = "servletAName")
public class ServletA extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 处理器请求
        System.out.println("servletA处理请求的方法,耗时10毫秒");
        // 模拟处理请求耗时
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

    }
}

• ServletB

@WebServlet(urlPatterns = "/servletB", name = "servletBName")
public class ServletB extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 处理器请求
        System.out.println("servletB处理请求的方法,耗时15毫秒");
        // 模拟处理请求耗时
        try {
            Thread.sleep(15);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

配置过滤器以及过滤器的过滤范围

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.0">

    <!--配置filter,并为filter起别名-->
   <filter>
       <filter-name>loggingFilter</filter-name>
       <filter-class>com.atguigu.filters.LoggingFilter</filter-class>
   </filter>
    <!--为别名对应的filter配置要过滤的目标资源-->
    <filter-mapping>
        <filter-name>loggingFilter</filter-name>
        <!--通过映射路径确定过滤资源-->
        <url-pattern>/servletA</url-pattern>
        <!--通过后缀名确定过滤资源-->
        <url-pattern>*.html</url-pattern>
        <!--通过servlet别名确定过滤资源-->
        <servlet-name>servletBName</servlet-name>

    </filter-mapping>
</web-app>

• 说明

  • filter-mapping标签中定义了过滤器对那些资源进行过滤
  • 子标签url-pattern通过映射路径确定过滤范围
    • /servletA 精确匹配,表示对servletA资源的请求进行过滤
    • *.html 表示对以.action结尾的路径进行过滤
    • /* 表示对所有资源进行过滤
    • 一个filter-mapping下可以配置多个url-pattern
  • 子标签servlet-name通过servlet别名确定对那些servlet进行过滤
    • 使用该标签确定目标资源的前提是servlet已经起了别名
    • 一个filter-mapping下可以定义多个servlet-name
    • 一个filter-mapping下,servlet-name和url-pattern子标签可以同时存在

Filter生命周期

过滤器作为web项目的组件之一,和Servlet的生命周期类似,略有不同,没有servlet的load-on-startup的配置,默认就是系统启动立刻构造

阶段	对应方法	执行时机	执行次数
创建对象	构造器	web应用启动时	1
初始化方法	void init(FilterConfig filterConfig)	构造完毕	1
过滤请求	void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)	每次请求	多次
销毁	default void destroy()	web应用关闭时	1次

Filter链

一个web项目中,可以同时定义多个过滤器,多个过滤器对同一个资源进行过滤时,工作位置有先后,整体形成一个工作链,称之为过滤器链

• 过滤器链中的过滤器的顺序由filter-mapping顺序决定
• 每个过滤器过滤的范围不同,针对同一个资源来说,过滤器链中的过滤器个数可能是不同的
• 如果某个Filter是使用ServletName进行匹配规则的配置，那么这个Filter执行的优先级要更低

注解方式配置过滤器@WebFilter

• 一个比较完整的Filter的XML配置

<!--配置filter,并为filter起别名-->
<filter>
    <filter-name>loggingFilter</filter-name>
    <filter-class>com.atguigu.filters.LoggingFilter</filter-class>
    <!--配置filter的初始参数-->
    <init-param>
        <param-name>dateTimePattern</param-name>
        <param-value>yyyy-MM-dd HH:mm:ss</param-value>
    </init-param>
</filter>
<!--为别名对应的filter配置要过滤的目标资源-->
<filter-mapping>
    <filter-name>loggingFilter</filter-name>
    <!--通过映射路径确定过滤资源-->
    <url-pattern>/servletA</url-pattern>
    <!--通过后缀名确定过滤资源-->
    <url-pattern>*.html</url-pattern>
    <!--通过servlet别名确定过滤资源-->
    <servlet-name>servletBName</servlet-name>
</filter-mapping>

• 将xml配置转换成注解方式实现

@WebFilter(
        filterName = "loggingFilter",
        initParams = {@WebInitParam(name="dateTimePattern",value="yyyy-MM-dd HH:mm:ss")},
        urlPatterns = {"/servletA","*.html"},
        servletNames = {"servletBName"}
)
public class LoggingFilter  implements Filter {
    private SimpleDateFormat dateFormat ;

    /*init初始化方法,通过filterConfig获取初始化参数
    * init方法中,可以用于定义一些其他初始化功能代码
    * */
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 获取初始参数
        String dateTimePattern = filterConfig.getInitParameter("dateTimePattern");
        // 初始化成员变量
        dateFormat=new SimpleDateFormat(dateTimePattern);
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        // 参数父转子
        HttpServletRequest request =(HttpServletRequest)  servletRequest;
        HttpServletResponse  response =(HttpServletResponse)  servletResponse;
        // 拼接日志文本
        String requestURI = request.getRequestURI();
        String time = dateFormat.format(new Date());
        String beforeLogging =requestURI+"在"+time+"被请求了";
        // 打印日志
        System.out.println(beforeLogging);
        // 获取系统时间
        long t1 = System.currentTimeMillis();
        // 放行请求
        filterChain.doFilter(request,response);
        // 获取系统时间
        long t2 = System.currentTimeMillis();
        String afterLogging =requestURI+"在"+time+"的请求耗时:"+(t2-t1)+"毫秒";
        // 打印日志
        System.out.println(afterLogging);

    }
}

Listener

监听器：专门用于对域对象对象身上发生的事件或状态改变进行监听和相应处理的对象

• 监听器是GOF设计模式中,观察者模式的典型案例

• 观察者模式: 当被观察的对象发生某些改变时, 观察者自动采取对应的行动的一种设计模式

• 监听器使用的感受类似JS中的事件,被观察的对象发生某些情况时,自动触发代码的执行

• 监听器并不监听web项目中的所有组件,仅仅是对三大域对象做相关的事件监听

监听器的分类

• web中定义八个监听器接口作为监听器的规范,这八个接口按照不同的标准可以形成不同的分类

• 按监听的对象划分

  • application域监听器 ServletContextListener ServletContextAttributeListener
  • session域监听器 HttpSessionListener HttpSessionAttributeListener HttpSessionBindingListener HttpSessionActivationListener
  • request域监听器 ServletRequestListener ServletRequestAttributeListener

• 按监听的事件分

  • 域对象的创建和销毁监听器 ServletContextListener HttpSessionListener ServletRequestListener
  • 域对象数据增删改事件监听器 ServletContextAttributeListener HttpSessionAttributeListener ServletRequestAttributeListener
  • 其他监听器 HttpSessionBindingListener HttpSessionActivationListener

application域监听器

ServletContextListener 监听ServletContext对象的创建与销毁

方法名	作用
contextInitialized(ServletContextEvent sce)	ServletContext创建时调用
contextDestroyed(ServletContextEvent sce)	ServletContext销毁时调用

• ServletContextEvent对象代表从ServletContext对象身上捕获到的事件，通过这个事件对象我们可以获取到ServletContext对象。

ServletContextAttributeListener 监听ServletContext中属性的添加、移除和修改

方法名	作用
attributeAdded(ServletContextAttributeEvent scab)	向ServletContext中添加属性时调用
attributeRemoved(ServletContextAttributeEvent scab)	从ServletContext中移除属性时调用
attributeReplaced(ServletContextAttributeEvent scab)	当ServletContext中的属性被修改时调用

• ServletContextAttributeEvent对象代表属性变化事件，它包含的方法如下：

方法名	作用
getName()	获取修改或添加的属性名
getValue()	获取被修改或添加的属性值
getServletContext()	获取ServletContext对象

示例

• 定义监听器

@WebListener
public class ApplicationListener implements ServletContextListener , ServletContextAttributeListener {
    // 监听初始化
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        ServletContext application = sce.getServletContext();
        System.out.println("application"+application.hashCode()+" initialized");
    }
    // 监听销毁
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        ServletContext application = sce.getServletContext();
        System.out.println("application"+application.hashCode()+" destroyed");
    }

    // 监听数据增加
    @Override
    public void attributeAdded(ServletContextAttributeEvent scae) {
        String name = scae.getName();
        Object value = scae.getValue();
        ServletContext application = scae.getServletContext();
        System.out.println("application"+application.hashCode()+" add:"+name+"="+value);
    }

    // 监听数据移除
    @Override
    public void attributeRemoved(ServletContextAttributeEvent scae) {
        String name = scae.getName();
        Object value = scae.getValue();
        ServletContext application = scae.getServletContext();
        System.out.println("application"+application.hashCode()+" remove:"+name+"="+value);
    }
    // 监听数据修改
    @Override
    public void attributeReplaced(ServletContextAttributeEvent scae) {
        String name = scae.getName();
        Object value = scae.getValue();
        ServletContext application = scae.getServletContext();
        Object newValue = application.getAttribute(name);
        System.out.println("application"+application.hashCode()+" change:"+name+"="+value+" to "+newValue);
    }
}

• 定义触发监听器的代码

// ServletA用于向application域中放入数据
@WebServlet(urlPatterns = "/servletA",name = "servletAName")
public class ServletA extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 向application域中放入数据
        ServletContext application = this.getServletContext();
        application.setAttribute("k1","v1");
        application.setAttribute("k2","v2");
    }
}

// ServletB用于向application域中修改和移除数据
@WebServlet(urlPatterns = "/servletB", name = "servletBName")
public class ServletB extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext appliation  = getServletContext();
        //  修改application域中的数据
        appliation.setAttribute("k1","value1");
        //  删除application域中的数据
        appliation.removeAttribute("k2");
    }
}

session域监听器

HttpSessionListener 监听HttpSession对象的创建与销毁

方法名	作用
sessionCreated(HttpSessionEvent hse)	HttpSession对象创建时调用
sessionDestroyed(HttpSessionEvent hse)	HttpSession对象销毁时调用

• HttpSessionEvent对象代表从HttpSession对象身上捕获到的事件，通过这个事件对象我们可以获取到触发事件的HttpSession对象。

HttpSessionAttributeListener 监听HttpSession中属性的添加、移除和修改

方法名	作用
attributeAdded(HttpSessionBindingEvent se)	向HttpSession中添加属性时调用
attributeRemoved(HttpSessionBindingEvent se)	从HttpSession中移除属性时调用
attributeReplaced(HttpSessionBindingEvent se)	当HttpSession中的属性被修改时调用

• HttpSessionBindingEvent对象代表属性变化事件，它包含的方法如下：

方法名	作用
getName()	获取修改或添加的属性名
getValue()	获取被修改或添加的属性值
getSession()	获取触发事件的HttpSession对象

request域监听器

ServletRequestListener 监听ServletRequest对象的创建与销毁

方法名	作用
requestInitialized(ServletRequestEvent sre)	ServletRequest对象创建时调用
requestDestroyed(ServletRequestEvent sre)	ServletRequest对象销毁时调用

• ServletRequestEvent对象代表从HttpServletRequest对象身上捕获到的事件，通过这个事件对象我们可以获取到触发事件的HttpServletRequest对象。另外还有一个方法可以获取到当前Web应用的ServletContext对象。

ServletRequestAttributeListener 监听ServletRequest中属性的添加、移除和修改

方法名	作用
attributeAdded(ServletRequestAttributeEvent srae)	向ServletRequest中添加属性时调用
attributeRemoved(ServletRequestAttributeEvent srae)	从ServletRequest中移除属性时调用
attributeReplaced(ServletRequestAttributeEvent srae)	当ServletRequest中的属性被修改时调用

• ServletRequestAttributeEvent对象代表属性变化事件，它包含的方法如下：

方法名	作用
getName()	获取修改或添加的属性名
getValue()	获取被修改或添加的属性值
getServletRequest ()	获取触发事件的ServletRequest对象

sessionBinding监听器

HttpSessionBindingListener 监听当前监听器对象在Session域中的增加与移除

方法名	作用
valueBound(HttpSessionBindingEvent event)	该类的实例被放到Session域中时调用
valueUnbound(HttpSessionBindingEvent event)	该类的实例从Session中移除时调用

• HttpSessionBindingEvent对象代表属性变化事件，它包含的方法如下：

方法名	作用
getName()	获取当前事件涉及的属性名
getValue()	获取当前事件涉及的属性值
getSession()	获取触发事件的HttpSession对象

钝化活化监听器

HttpSessionActivationListener 监听某个对象在Session中的序列化与反序列化。

方法名	作用
sessionWillPassivate(HttpSessionEvent se)	该类实例和Session一起钝化到硬盘时调用
sessionDidActivate(HttpSessionEvent se)	该类实例和Session一起活化到内存时调用

• HttpSessionEvent对象代表事件对象，通过getSession()方法获取事件涉及的HttpSession对象。

什么是钝化活化

• session对象在服务端是以对象的形式存储于内存的,session过多,服务器的内存也是吃不消的
• 而且一旦服务器发生重启,所有的session对象都将被清除,也就意味着session中存储的不同客户端的登录状态丢失
• 为了分摊内存 压力并且为了保证session重启不丢失,我们可以设置将session进行钝化处理
• 在关闭服务器前或者到达了设定时间时,对session进行序列化到磁盘,这种情况叫做session的钝化
• 在服务器启动后或者再次获取某个session时,将磁盘上的session进行反序列化到内存,这种情况叫做session的活化

ajax

• AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。

• AJAX 不是新的编程语言，而是一种使用现有标准的新方法。

• AJAX 最大的优点是在不重新加载整个页面的情况下，可以与服务器交换数据并更新部分网页内容。

• AJAX 不需要任何浏览器插件，但需要用户允许 JavaScript 在浏览器上执行。

• XMLHttpRequest 只是实现 Ajax 的一种方式。

ajax工作原理

• 简单来说,我们之前发的请求通过类似 form表单标签,a标签 这种方式,现在通过 运行js代码动态决定什么时候发送什么样的请求
• 通过运行JS代码发送的请求浏览器可以不用跳转页面 ,我们可以在JS代码中决定是否要跳转页面
• 通过运行JS代码发送的请求,接收到返回结果后,我们可以将结果通过dom编程渲染到页面的某些元素上,实现局部更新

原生js方式实现ajax

<script>
  function loadXMLDoc(){
    var xmlhttp=new XMLHttpRequest();
      // 设置回调函数处理响应结果
    xmlhttp.onreadystatechange=function(){
      if (xmlhttp.readyState==4 && xmlhttp.status==200)
      {
        document.getElementById("myDiv").innerHTML=xmlhttp.responseText;
      }
    }
      // 设置请求方式和请求的资源路径
    xmlhttp.open("GET","/try/ajax/ajax_info.txt",true);
      // 发送请求
    xmlhttp.send();
  }
</script>