JavaWeb（华清远见）

JavaWeb，是通过使用Java技术来解决相关web互联网领域的技术总和。web包括web服务器和web客户端两部分。

web开发相关知识：

web,表示网页的意思，用于表示Internet主机上供外界访问的资源
Internet上供外界访问的web资源分为：
- 静态web资源（如html页面）：值web页面中供人们浏览的数据始终是不变的。
- 动态web资源：指web页面中供人们浏览的数据是由程序产生的，不同时间访问web页面，浏览的数据都不同。
静态web资源开发技术：jsp/Servlet、ASP、PHP等

web发展：静态和动态

静态web：

在静态WEB程序中，客户端使用WEB浏览器（IE、FireFox等）经过网络(Network)连接到服务器上，使用HTTP协议发起一个请求（Request），告诉服务器我现在需要得到哪个页面，所有的请求交给WEB服务器，之后WEB服务器根据用户的需要，从文件系统（存放了所有静态页面的磁盘）取出内容。之后通过WEB服务器返回给客户端，客户端接收到内容之后经过浏览器渲染解析，得到显示的效果。

静态WEB中存在以下几个缺点：

web页面中的内容无法动态更新，所有的用户每时每刻看见的内容和最终效果都是一样的。
- 为了可以让静态的WEB的显示更加好看，可以加入了JavaScript以完成一些页面上的显示特效，但是这些特效都是在客户端上借助于浏览器展现给用户的，所以在服务器上本身并没有任何的变化。实现静态WEB客户端动态效果的手段：
  - JavaScript（在实际的开发中JavaScript使用得最多。）
  - VBScript
静态WEB无法连接数据库，无法实现和用户的交互。

动态WEB

动态WEB中，程序依然使用客户端和服务端，客户端依然使用浏览器（IE、FireFox等），通过网络(Network)连接到服务器上，使用HTTP协议发起请求（Request），现在的所有请求都先经过一个WEB Server Plugin（服务器插件）来处理，此插件用于区分是请求的是静态资源(.htm或者是.htm)还是动态资源。

如果WEB Server Plugin发现客户端请求的是静态资源(.htm或者是.htm)，则将请求直接转交给WEB服务器，之后WEB服务器从文件系统中取出内容，发送回客户端浏览器进行解析执行。

如果WEB Server Plugin发现客户端请求的是动态资源（.jsp、.asp/.aspx、.php），则先将请求转交给WEB Container(WEB容器)，在WEB Container中连接数据库，从数据库中取出数据等一系列操作后动态拼凑页面的展示内容，拼凑页面的展示内容后，把所有的展示内容交给WEB服务器，之后通过WEB服务器将内容发送回客户端浏览器进行解析执行。

web应用程序:

WEB应用程序指供浏览器访问的程序，通常也简称为web应用。例如a.html 、b.html……多个web资源，这多个web资源用于对外提供服务，此时应把这多个web资源放在一个目录中，以组成一个web应用（或web应用程序）

一个web应用由多个静态web资源和动态web资源组成，如:html、css、js文件，Jsp文件、java程序、支持jar包、配置文件等等。

虚似目录的映射：Web应用开发好后，若想供外界访问，需要把web应用所在目录交给web服务器管理，这个过程称之为虚似目录的映射

Servlet

Servlet是sun公司制定的一种用于扩展web服务器功能的组件规范，包含与Web应用相关的一系列接口，是Web应用实现方式的宏观解决方案。而具体的Servlet容器负责提供标准的实现。

web服务器通常只能处理静态的资源(html , css , img , js…) , 为了解决一些动态的处理数据，就需要对web服务器的功能进行扩展，servlet就是用于处理动态数据的组件规范。
组件：符号一定规范，完成部分功能的软件模块。这些软件模块需要放在容器中进行运行。比如：servlet , jsp就属于组件， tomcat就属于容器。 servlet必须放在tomcat容器中进行运行。
- 必须先启动tomcat，然后才能访问到servlet , jsp.
容器：符号一定规范，能够运行组件的一种软件。比如：tomcat …
servlet规范：使用servlet的时候，自定义的类是HttpServlet的子类，那么就是符合servlet的规范。

Servlet作为服务器端的一个组件，它的本意是“服务器端的小程序”。Servlet的实例对象由Servlet容器负责创建；Servlet的方法由容器在特定情况下调用；Servlet容器会在Web应用卸载时销毁Servlet对象的实例。

简单可以理解为 Servlet就是用来处理客户端的请求的.

狭义的Servlet是指Java语言实现的一个接口，广义的Servlet是指任何实现了这个Servlet接口的类，一般情况下，人们将Servlet理解为后者。Servlet运行于支持Java的应用服务器中。从原理上讲，Servlet可以响应任何类型的请求，但绝大多数情况下Servlet只用来扩展基于HTTP协议的Web服务器。

Servlet开发步骤

新建符合java web项目的工程
servlet 类继承 HttpServlet
- 重写service方法
- service(HttpServletRequest request , HttpServletResponse response)
  - HttpServletRequest（请求） : 该接口是ServletRequest接口的子接口，封装了HTTP请求的相关信息，由Servlet容器创建其实现类对象并传入service(ServletRequest req, ServletResponse res)方法中。
  - HttpServletResponse （响应）：该接口是ServletResponse接口的子接口，封装了HTTP响应的相关信息，由Servlet容器创建其实现类对象并传入service(ServletRequest req, ServletResponse res)方法中。
java web工程中的web.xml文件
- web.xml 的文件名不能修改（tomcat找web.xml）
- 将java的类和浏览器访问的地址做一个映射
- 浏览器没法办法直接访问java类中的方法，所以需要java类映射到一个浏览器能访问的url地址。
打包(idea帮助完成)
- 把web项目运行需要的文件内容按指定文件结构保存。
部署（在idea中可以完成）
- 把打包好的web程序放到tomcat容器中，然后运行tomcat容器的时候，才能访问我们的web程序。
启动容器，然后可以通过浏览器访问访问web程序。

Http协议和Servlet的执行

Http协议

Servlet的执行

浏览器的缓存

servlet的url映射方式

tomcat 优先查找servlet ，如果没有符合的servlet ,那么就找静态资源，如果也没有静态资源被找到，
就404.

/life ：精确地址，没有扩展名，以/开始
/life.do: 精确地址，有扩展名，以 / 开始
*.do , 通配符 + 扩展名，所有以.do结尾的请求，都会被拦截，不能以/开始。
/ , 拦截所有请求，但不拦截jsp*
/ *, 拦截所有请求

servlet的生命周期

Servlet的生命周期为init->service->doGet/doPost->destroy
init只在容器启动或是第一次访问servlet时调用，destroy在关闭容器时调用
Servlet每次被访问的时候，反复执行service（doGet/doPost）

Servlet的参数

Servlet级的参数

<servlet><servlet-name>arg</servlet-name><servlet-class>action.ArgusServlet</servlet-class>
<!--    初始化参数的配置： servlet标签内部配置的参数，只在当前servlet有效。--><init-param><param-name>dbname</param-name><param-value>empdb</param-value></init-param><init-param><param-name>dbtable</param-name><param-value>emp</param-value></init-param></servlet>

 @Overrideprotected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {// --- 从web.xml中，servlet中配置的参数，获取到这些参数，然后在程序中使用。System.out.println(this.getInitParameter("dbname"));System.out.println(this.getInitParameter("dbtable"));}

conext级参数

<!--  全局参数(context级别) , 任何servlet中 都可以使用--><context-param><param-name>count</param-name><param-value>100</param-value></context-param>

@Overrideprotected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {ServletContext servletContext = this.getServletContext();String count = servletContext.getInitParameter("count");System.out.println("count:" + count);}

tomcat 服务器

服务器是一种被动的操作，用来处理用户的一些请求和给用户一些响应信息；

java web项目运行，需要运行在支持java web项目的服务器上，常见的java web服务器：

tomcat
JBoss
Resin
Jetty

Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，最新的Servlet 和JSP 规范总是能在Tomcat 中得到体现，因为Tomcat 技术先进、性能稳定，而且免费，因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可，成为目前比较流行的Web 应用服务器。

Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。

Maven-Repository（存储库）

Maven Repository/存储库，顾名思义是一个存储JAR文件的仓库，Maven根据项目中pom.xml文件中提供的jar包依赖信息，从存储库中查找并获取需要的jar包，Maven搜索依赖项时，会按照：本地库、中央库和远程库的顺序进行。

Maven Repository有3种类型:

Local Repository – 本地库
Central Repository – 中央库
Remote Repository – 远程库

bmi(身体质量指数)：

Servlet:

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;public class BmiServlet extends HttpServlet {@Overrideprotected void service(HttpServletRequest req, HttpServletResponse resp) throws IOException {//1、设置中文编码resp.setContentType("text/html;charset=UTF-8");req.setCharacterEncoding("UTF-8");//2、获取参数String weight = req.getParameter("weight");String high = req.getParameter("high");//3、处理数据double w = Double.parseDouble(weight);double h = Double.parseDouble(high);double bmi = w/(h*h);//4、响应结果PrintWriter writer = resp.getWriter();if(bmi<18.5){writer.println("太廋");}else if(bmi>18.5&&bmi<23.9){writer.println("正常");}else if(bmi>23.9){writer.println("胖");}}
}

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Title</title>
</head>
<body>
<h2>BMI计算:体重指数(BMI)=体重(kg)/身高(m)的平方</h2>
<form action="bmi"><label>请输入体重:</label><input type="text" name="weight"><br><label>请输入身高:</label><input type="tekt" name="high"><br><input type="submit" value="计算"><input type="reset" value="重置">
</form>
</body>
</html>

web.xml配置:

<servlet><servlet-name>bmi</servlet-name><servlet-class>action.BmiServlet</servlet-class></servlet><servlet-mapping><servlet-name>bmi</servlet-name><!--        showTimeServlet 对应的请求地址--><url-pattern>/bmi</url-pattern></servlet-mapping>

jsp的使用

jsp全称Java Server Pages，是一种运行在服务器端的页面，它里面包含html ，嵌入一些java语言，在服务器(tomcat)上经过解析转换，输出为html页面。

相比于Servlet，JSP更加善于处理显示页面，而Servlet跟擅长处理业务逻辑，两种技术各有专长，所以一般我们会将Servlet和JSP结合使用，Servlet负责业务，JSP负责显示。

jsp不需要配置，直接用它的路径和文件名进行访问。

jsp是sun公司制定的一种用于服务器动态页面的技术规范，也是一种组件，依赖于tomcat进行运行。

servlet + html ：数据的处理和数据的显示
servlet + jsp: 数据处理(servlet) , 数据展示(jsp-- 嵌套java使用)
- servlet 做数据显示的时候，不方便（编写，维护都不方便）
- jsp:让数据的处理和数据的展示进行分离

<!--pom.xml文件添加依赖-->
<dependency><groupId>javax.servlet.jsp</groupId><artifactId>javax.servlet.jsp-api</artifactId><version>2.3.3</version><scope>provided</scope></dependency>

jsp基本语法

page：指令，用于对jsp做一些设置，比如contentType=“text/html;charset=UTF-8”，设置网页类型和编码方式

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--注释--%>
<%--jsp导包：--%>
<%@ page import="java.util.Date" %>
<%@ page import="java.text.SimpleDateFormat" %>

添加Java代码

<%//Java代码String str= "，此时此刻";Date a = new Date();SimpleDateFormat sdf = new SimpleDateFormat("yy-MM-dd");str=sdf.format(a)+str;%>

输出str
```
<p><%=str%></p>
```

jsp循环语句

<%-- 要求：  显示20行div ， 单行背景色红色， 双行背景色蓝色--%><% for (int i =1 ; i <= 20 ; i ++){if(i%2==0){ %><div style="background-color:blue">shuang</div><%  }else{ %><div style="background-color:red">dan </div><%    }}%>

jsp的运行：jsp的本质是servlet。
- 当第一个访问一个jsp页面的时候，会将jsp文件，对应生成一个servlet类。
- html ， js , css这种内容就用输出语句拼接。
- 其他和java相关的内容，就按java的方式转换。

JSP的隐含对象

①out（JspWriter）：相当于response.getWriter()获取的对象，用于在页面中显示信息。

②config（ServletConfig）：对应Servlet中的ServletConfig对象。

③page（Object）：对应当前Servlet对象，实际上就是this。

④pageContext（PageContext）：当前页面的上下文，也是一个域对象。

⑤exception（Throwable）：错误页面中异常对象

⑥request（HttpServletRequest）：HttpServletRequest对象

⑦response（HttpServletResponse）：HttpServletResponse对象

⑧application（ServletContext）：ServletContext对象

⑨session（HttpSession）：HttpSession对象

EL表达式

①EL是JSP内置的表达式语言，用以访问页面的上下文以及不同作用域中的对象，取得对象属性的值，或执行简单的运算或判断操作。EL在得到某个数据时，会自动进行数据类型的转换。

②EL表达式用于代替JSP表达式(<%= %>)在页面中做输出操作。

③EL表达式仅仅用来读取数据，而不能对数据进行修改。

④使用EL表达式输出数据时，如果有则输出数据，如果为null则什么也不输出。

⑤EL表达式的语法:

⑥EL取值的四个域:

pageContext：只在当前页面有效
request：请求期间有效
session：会话期间有效

application：程序运行期间有效

<%int i = 0 ;// int k = 10/i; // 抛异常pageContext.setAttribute("hello" , "你好 , pageContext");//pageContext.getAttribute("hello");request.setAttribute("hello" ,"你好， request");
session.setAttribute("hello" ,"你好， session");application.setAttribute("hello" , "你好， application");String  hello = "你好";// 作用域小的数据，优先被获取到// pageContext > request > session > application
%>
<h1>${hello}</h1>
<h2>${pageScope.hello}</h2>
<h2>${requestScope.hello}</h2>
<h2>${sessionScope.hello}</h2>
<h2>${applicationScope.hello}</h2>

EL表达式

<%@ page import="entity.Emp" %><%--Created by IntelliJ IDEA.User: ASUSDate: 2022/9/7Time: 9:36To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>Title</title>
</head>
<body>
<%--获取数据--%>
<%Object emp = request.getAttribute( "emp " );Emp e = null;if(emp != null){if(emp instanceof Emp){e = (Emp) emp;}}%>
<h1>emp:<%=e%></h1><%--el表达式：${request中保存的key值}--%>
<h1>emp:${emp}</h1>
<%--${emp.eno}：emp对象的属性值获取--%>
<%--${对象.属性名}，要求，属性必须提供了正确的get方法。〔本质就是在调用get方法)--%><h1>emp信息:${emp.eno}, ${emp.ename}</h1>
<%--el表达式中，如果获取数据值是null，那么就不显示内容--%><h1>emp1:${emp1}</h1>
<h1>list: ${emps}</h1>
<h1>age : ${age}</h1>
<h1>age1: ${age1}</h1>
<h1>nowtime : ${nowtime}</h1>
<h1>el表达式的运算</h1>
条件运算：${age1>18}
<br>
逻辑运算：${age1>18||false}
<br>判空：${empty emp1}
<br>算术运算：${age1+20}
</body>
</html>

重定向和转发的区别

	转发	重定向
浏览器地址栏	不改变	改变
发送请求次数	能	不能
能否共享request对象数据	能	不能
目标资源：WEB-INF下的资源	能访问	不能文房
Rquest中绑定的数据是否可以传递	能	不能

Jstl标签

导入标签库（依赖）

<dependency><groupId>taglibs</groupId><artifactId>standard</artifactId><version>1.1.2</version></dependency><!-- https://mvnrepository.com/artifact/jstl/jstl --><dependency><groupId>jstl</groupId><artifactId>jstl</artifactId><version>1.2</version></dependency>

jstl标签的使用

先引入需要使用的标签库

<%@ taglib prefix=“c” uri=“http://java.sun.com/jsp/jstl/core” %>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--taglib指令prefix="c"  ， prefix 前缀  ， 表示在使用的标签的前面都要加上c: ,解决命名冲突
--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="f" uri="http://java.sun.com/jsp/jstl/fmt" %>
<html>
<head><title>jstl标签库</title>
</head>
<body>
<h1>alice:<c:if test="${age1 >= 18 }">成年入</c:if><c:if test="${age1 < 18}">未成年人</c:if>
</h1>
<h1>alice:<c:choose><c:when test="${age1<6}">儿童</c:when><c:when test="${age1<18}">青少年</c:when><c:when test="${age < 36}">青年</c:when><c:otherwise>青壮年</c:otherwise></c:choose>
</h1>
<table border="1"><tr><th>员工编号</th><th>员工名字</th><th>员工的雇佣日期</th></tr><c:if test="${empty emps}"><tr><td colspan="3">当前没有员工</td></tr></c:if><c:forEach items="${emps}" var="e"><tr><td>${e.eno}</td><td>${e.ename}</td><td>${e.ehiredate}</td></tr></c:forEach>
</table>
</body>
</html>

cookie、session

cookie

cookie	说明
HttpServletRequest.getCookies()	得到cookie的对象，返回数组
new Cookie(“mycard”, “1”)	（键值对形式）创建key为"mycard",value为"1"的cookie
cookie.setMaxAge(20)	设置cookie的有效期，过期cookie就不能用，会重置为0，单位为秒
HttpServletResponse.addCookie(cookie)	添加cookie
cookie.getName()	获取可以值
cookie.getValue()	获取value值

Cookie实际上就是服务器保存在浏览器上的一段信息。浏览器有了Cookie之后，每次向服务器发送请求时都会同时将该信息发送给服务器，服务器收到请求后，就可以根据该信息处理请求。、

cookie使用的方式：

服务器端代码中，创建cookie对象，在response中添加cookie
客户端访问服务器的时候，会将把当前访问路径有关的cookie发送到服务器端
服务器端可以在request中获取到cookie数据，然后对这些数据进行使用
浏览器可以设置禁用cookie，或者用户可以删除cookie数据，用户可以查看到cookie数据，所以重要数据不能直接保存在cookie中。
cookie中存储的是string ，并且存储的数据大小也有限。
cookie 可以设置有效期，过期之后，cookie会被浏览器清除掉。

Cookie的限制性：

Cookie作为请求或响应报文发送，无形中增加了网络流量。
Cookie是明文传送的安全性差。
各个浏览器对Cookie有限制，使用上有局限

protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {resp.setContentType("text/html;charset=utf-8");req.setCharacterEncoding("utf-8");// 1. 获取cookiesCookie[] cookies = req.getCookies();if(cookies != null){for(Cookie c : cookies){// *** 其他次if("mycard".equals(c.getName())){String value = c.getValue();int count = Integer.parseInt(value) + 1;// *** 修改cookie中的数据c.setValue(count +"");c.setMaxAge(30);resp.addCookie(c); // 修改浏览器中的cookie的数据resp.getWriter().println("你是第"+count+"次访问");return ; // 结束方法的运行}}}// ** 第一次和Cookie cookie = new Cookie("mycard" , "1");// *** 设置cookie的有效期 ，过期了cookie就不能使用了。 如果没有设置有效期，那
么有效期默认是session期间有效。// ***  session期间： 指你在浏览器中第一次访问某个服务器，到你把浏览器关闭的时
候，这之间这被称为session期间(session-会话)// *** setMaxAge(单位秒)cookie.setMaxAge(30);resp.addCookie(cookie); // 添加cookie ， 浏览器会保存这个cookie数据resp.getWriter().println("你是第1次访问");}

Session

session	说明
HttpServletRequest.getSession()	获取会话的对象，返回为Object类型
session.setAttribute( sessionName： “a”，Object ：obj);	设置session的值，名称为a,保存对象为obj
session.setMaxInactiveInterval(int i);	设置session的有效期，单位为秒
session.removeAttribute(sessionName： “a”);	移除名称为"a"的session的值

使用Cookie有一个非常大的局限，就是如果Cookie很多，则无形的增加了客户端与服务端的数据传输量。而且由于浏览器对Cookie数量的限制，注定我们不能再Cookie中保存过多的信息，于是Session出现。

Session的作用就是在服务器端保存一些用户的数据，然后传递给用户一个名字为JSESSIONID的Cookie，这个JESSIONID对应这个服务器中的一个Session对象，通过它就可以获取到保存用户信息的Session。

Session的工作原理

Session的创建时机是在request.getSession()方法第一次被调用时。
Session被创建后，同时还会有一个名为JSESSIONID的Cookie被创建。
这个Cookie的默认时效就是当前会话。
简单来说，Session机制也是依赖于Cookie来实现的
Session默认有效时间为30分钟

Session和cookie的区别：

Cookie是把用户的数据写给用户的浏览器，浏览器保存（可以保存多个）
Session把用户的数据写到用户独占Session中，服务器端保存（保存重要的信息，减少服务器资源的浪费）
Session对象由服务创建；

过滤器

对于WEB应用来说，过滤器是一个驻留在服务器中的WEB组件，他可以截取客户端和WEB资源之间的请求和响应信息。WEB资源可能包括Servlet、JSP、HTML页面等

当服务器收到特定的请求后，会先将请求交给过滤器，程序员可以在过滤器中对请求信息进行读取修改等操作，然后将请求信息再发送给目标资源。目标资源作出响应后，服务器会再次将响应转交给过滤器，在过滤器中同样可以对响应信息做一些操作，然后再将响应发送给服务器。

也就是说过滤器可以在WEB资源收到请求之前，浏览器收到响应之前，对请求和响应信息做一些相应的操作。在一个WEB应用中可以部署多个过滤器，多个过滤器就组成了一个过滤器链，请求和响应必须在经过多个过滤器后才能到达目标

过滤器类型：过滤器是sun提供一个组件，需要依赖于tomcat容器运行。

过滤器的执行过程：访问请求的时候，先根据过滤器的配置，符号过滤器路径的请求，则先进入到过滤器中执行，执行结束之后，再根据情况，看是否需要进入到servlet中。

过滤器代码：

public class LoginFilter extends HttpFilter {@Overrideprotected void doFilter(HttpServletRequest request, HttpServletResponse
response, FilterChain chain) throws IOException, ServletException {String requestURI = request.getRequestURI();//http:///...if(requestURI.contains("login")){// login这个地址，单独处理，不需要判断sessionchain.doFilter(request , response);return ;}HttpSession session = request.getSession();Object login = session.getAttribute("login");if(login!=null){// 调用下一个过滤器的doFilter方法。如果没有下一个过滤器了，就调用servlet的
方法chain.doFilter(request ,response);}else{response.setContentType("text/html;charset=utf-8");response.getWriter().println("请求先登录"); // 重定向到登陆的jsp页面}}@Overridepublic void destroy() {}@Overridepublic void init() throws ServletException {}
}

过滤器配置

<filter><filter-name>hh</filter-name><filter-class>action.LoginFilter</filter-class></filter><filter-mapping><filter-name>hh</filter-name><!-- /* 所有的都拦截 ， jsp也拦截--><!-- / 不拦截jsp--><!-- /add ，表示只拦截/add请求--><url-pattern>/*</url-pattern></filter-mapping>

监听器

监听器在后台工作，可以设置需要监听的内容

下面的案例：完成对请求次数的统计

// 在web.xml文件中，进行监听器的配置
public class CountListener  implements ServletRequestListener {@Override // 每次请求， 统计一次 ， 统计的次数保存起来。public void requestInitialized(ServletRequestEvent sre) {ServletContext servletContext = sre.getServletContext();// *** request , session , servletContext 都有setAttribute
/setAttribute 方法//  有效期： request , 每次请求是一个单的的request对象，请求结束 ，
request对象就无效。//      seesion , 每次会话期间，都是同一个session对象， 会话结束，
session对象就无效。//      servletContext(appliction) , 程序启动（tomcat启动），到程序
关闭期间有效（tomcat关闭）， 程序关闭，servletContext对象就无效了。//servletContext.setAttribute("count" , 1);//servletContext.setAttribute("count");// ** 第一次请求和其他次Object total = servletContext.getAttribute("total");if(total==null){servletContext.setAttribute("total" , 1);System.out.println("1次" );}else{int num = (int)total  + 1;servletContext.setAttribute("total" , num );System.out.println(num +"次");}}
}

监听器的配置

<listener><listener-class>action.CountListener</listener-class>
</listener>

Ajax

AJAX 是 Asynchronous JavaScript And XML 的简称。直译为，异步的JS和XML。
AJAX 不是新的编程语言，而是一种使用现有标准的新方法。
AJAX 最大的优点是在不重新加载整个页面的情况下，可以与服务器交换数据并更新部分网页内容。
AJAX 不需要任何浏览器插件，但需要用户允许JavaScript在浏览器上执行。

异步处理

同步处理

AJAX出现之前，我们访问互联网时一般都是同步请求，也就是当我们通过一个页面向服务器发送一个请求时，在服务器响应结束之前，我们的整个页面是不能操作的，也就是直观上来看他是卡主不动的。

这就带来了非常糟糕的用户体验。首先，同步请求时，用户只能等待服务器的响应，而不能做任何操作。其次，如果请求时间过长可能会给用户一个卡死的感觉。最后，同步请求的最大缺点就是即使整个页面中只有一小部分内容发生改变我们也要刷新整个页面。

异步处理

而异步处理指的是我们在浏览网页的同时，通过AJAX向服务器发送请求，发送请求的过程中我们浏览网页的行为并不会收到任何影响，甚至主观上感知不到在向服务器发送请求。当服务器正常响应请求后，响应信息会直接发送到AJAX中，AJAX可以根据服务器响应的内容做一些操作。

使用AJAX的异步请求基本上完美的解决了同步请求带来的问题。首先，发送请求时不会影响到用户的正常访问。其次，即使请求时间过长，用户不会有任何感知。最后，AJAX可以根据服务器的响应信息局部的修改页面，而不需要整个页面刷新。

后端

@WebServlet("/hobby")
public class HobbyServlet extends HttpServlet {@Overrideprotected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {// 获取参数String name = req.getParameter("name");String[] hobbies = req.getParameterValues("hobby");// 数据操作(保存到数据库)System.out.println(name  + ":" + Arrays.toString(hobbies));// 响应结果： json格式的结果 {key:value, key1:value1}// *** application/json： 表示响应结果是json格式// *** text/html :表示响应结果是html格式resp.setContentType("application/json;charset=utf-8");resp.getWriter().println("{\"success\" :true}");}
}

前端

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>爱好</title>
</head>
<body><div><form><label>名字：</label><input type="text" name="name"><br><label>爱好：</label><input type="checkbox" name="hobby" value="看电影">看电影<input type="checkbox" name="hobby" value="打游戏">打游戏<input type="checkbox" name="hobby" value="看书">看书<input type="checkbox" name="hobby" value="跑步">跑步<input type="checkbox" name="hobby" value="葛优躺">葛优躺</form><button>发送</button></div><script src="js/jquery-3.4.1.min.js"></script><script>// ** 发请求$("button").click(function () {// --- ajax函数， 参数是json格式// -- 请求参数， 请求的url， 请求的方式 ,//   期待的响应结果的格式， 请求成功之后，得到响应结果的处理let args = $("form").serialize();// key=value&key=value....console.log(args)$.ajax({url: "hobby", // 请求的urldata: args, // 请求参数type: "get", // 请求的方式dataType: "json",// 期待的响应结果的格式success:function (res) {//成功之后，// res ==> {"success":true}if(res.success){alert("成功")}else{alert("失败了")}}})})</script>
</body>
</html>

heckbox" name=“hobby” value=“跑步”>跑步
葛优躺

发送

```