Servlet_servlet接口里定义的5个抽象方法-CSDN博客

本文链接：https://blog.csdn.net/yungege_/article/details/78965255

html,css：静态网页，双击通过浏览器就可以看到其效果。

html页面让其他人通过浏览器输入URL(协议://ip:port/路径/资源名)的形式访问到,WEB服务器WEB项目/应用程序

创建一个web项目，创建或者添加html页面，把web项目部署到web服务器，启动服务器，通过浏览器URL形式访问到该html页面。

WEB服务器：

1.Tomcat服务器

1.1Tomcat服务器的目录结构：

/bin：存放各种平台下用于启动和停止Tomcat的文件。startup.bat用来启动Tomcat，但需要先配置JAVA_HOME环境变量才能启动，shutdawn.bat用来停止Tomcat(windows:双击)

Linux：执行 Startup.sh Shutdown.sh

/conf：存放Tomcat服务器的各种配置文件。端口号，编码格式，配置文件...

/lib：存放Tomcat服务器所需的各种jar文件，在tomcat中可以部署多个web项目，共享此目录下的jar包。我们也可以自己把一些其他jar包放到这里。

/logs：存放Tomcat的日志文件，记录Tomcat的启动和关闭等信息。

/temp：存放Tomcat在运行过程中，产生的临时文件。

/webapps：存放部署到Tomcat中的Web项目，部署项目后，默认将web项目放到webapps。一个文件夹代表一个项目，如Tomcat自带的Root项目。

/work：与web项目中的JSP文件有关。当客户端用户（浏览器）访问一个JSP文件时Tomcat会通过JSP生成java文件，然后编译成class文件，存放在此目录下。

2.启动tomcat：

1.startup.bat

2.JDK,JAVA_HOME:JDK的安装路径

3.读取配置文件，占用端口号（不能重复，避免端口冲突）

修改 conf/server.xml--http/1.1 8080----8888

WEB项目/应用程序：

web:网，环球网。不同的领域:

普通用户：网络，上网环境

网站开发者：一系列相关技术的统称(前端页面，页面布局，美工，程序，数据库相关技术)

web项目：由用户通过互联网、浏览器访问的应用程序，叫做web应用程序。

特点：只要用户有网，有浏览器，不需要其他的软件，就可以访问到。

如：电商网站，门户网站，论坛，搜索引擎，校园.网络银行...

一个web项目由html,css,js,图片，文件，jar，java代码，配置文件等资源组成

静态资源：web页面上由用户访问的数据都是不变的，html,css..

动态资源：web页面上展示给用户访问的数据由程序动态生成，不同时刻，不同角色查看，内容可能不同

web项目 --部署 --web服务器

java项目：

运行环境：JDK(javaSE)

运行方式：程序入口：主方法main

Web项目：需要有一定的目录结构，需要借助于服务器运行。

运行环境：JDK,javaEE环境(jar)

运行方式：web项目部署在web服务器中，由web服务器去调用执行。

同时Web项目与java项目的目录结构也是不一样的，Web项目的项目结构是固定的。

用户通过浏览器url的形式访问html页面等静态资源

手动创建web项目

部署:把文件按照正确的目录结构的方式组合起来放到webapps中

启动:bin/startup.bat

访问:url:

http://localhost:8888/yun/images/sn.jpg

http://localhost:8888/yun/hello.txt

http://localhost:8888/yun/hello.html

http://localhost:8888<----->tomcat/webapps

web项目的目录结构：Web项目的项目结构是固定的。

1.有一个文件夹，作为项目根目录，文件夹名--项目名，如：firstWebDemo

2.1.WEB-INF目录：java.class,jar,配置文件，资源

2.11 classes:web项目中的java代码编译后生成的class文件

2.12 lib:该web项目要使用的jar包

2.13 web.xml:配置，tomcat/conf/web.xml

2.14web项目中任意的文件或者目录，不可以直接通过URL访问，必须通过程序处理才可访问。

2.2 资源：任意的文件或者目录,可以直接通过URL访问

用户通过浏览器url的形式访问动态资源,比如java代码

servlet:在javaWEB中，能够被浏览器通过URL形式访问到的java类，是servlet。普通java类，特殊的功能。

普通java项目，执行一段java代码（类的方法）

1.程序入口：tomcat服务器负责

2.创建对象：tomcat服务器创建对象--反射

3.调用方法（方法执行）：tomcat会调用对应对象的service方法

通过URL-pattern找到对应的请求，找到注册名，然后注册名一一对应上，找到servlet，创建出来对象，然后去调用service方法。

多个请求----对应类中的代码（方法），多段 java代码（多个类中的“方法”）

思考：

1. tomcat服务器怎么正确地把一个请求对应到一段代码上

映射，配置文件，配置

2.类：多个对象--多个类，方法调用的问题

(接口).service调用方法规则，接口/抽象类，多态

用户通过浏览器url的形式访问动态资源(java)serlvet类

1.创建servlet：新建一个普通java类，继承或者实现相关的父类/接口，重写/实现指定的方法(service)。

父类/接口：javaEE规范中规定的jar包（tomcat服务器lib:servlet-api.jar）

2.编译--class--WEB-INF/classes--启动

3.访问：url（根据对应的配置url来访问，在web.xml中配置，配置的标签是servlet）

<servlet>:servlet类

<servlet-name>firstTest(注册名，名称唯一，不能重复)</servlet-name>

//<servlet-class>中写的是servlet的全类名

<servlet-class>com.briup.servlet.FirstServlet</servlet-class>

</servlet>

<servlet-mapping>：请求（与servlet类对应）

<servlet-name>firstTest</servlet-name>

请求路径: /（表示项目名下，必须写）

项目名下/指的是：url:http://localhost/8888/firstWebDemo/

<url-pattern>/firstServlet/a.do</url-pattern>

</servlet-mapping>

对应关系：通过URL-pattern找到对应的请求，找到注册名，然后注册名一一对应上，找到servlet，创建出来对象，然后去调用service方法。

路径

服务器根目录：

文件系统：tomcat/webapps

Url:http://localhost:8888

项目根目录：

文件系统：tomcat/webapps/项目名

Url:http://localhost:8888/项目名/a/a.do

Eclipse: WebContent,部署-处理成符合web项目的目录结构。

web服务器，web项目--java项目

用户通过浏览器url的形式访问web项目的html页面等静态资源

用户通过浏览器url的形式访问web项目的动态资源(java) serlvet类

ecplise--tomcat---创建web--部署....启动服务器--访问

1.解压

2.添加空白处右击 new server

3.修改配置 3处：空间，webapps，端口号

webapps:web项目的目录结构

桌面上web项目...

Eclipse:目录结构

eclipse中看到-----工作空间

tomcat---webapps:WEB项目的目录结构

Eclipse中要在web项目根目录下放静态文件，往WebContent下放，和WEB-INF是同一级。即要建一个html，jsp文件，文档等等就在WebContent中建立。

Eclipse中server启动的时候Tomcat中的webapps会部署项目，把工作空间中的项目处理成符合web项目的目录结构保存进来，做到信息更新。

删除服务器中的文件并不影响eclipse工作空间中的文件，eclipse中server中clear的是Tomcat中的项目，也不影响工作空间。

Publish：部署

WEB项目的目录结构：

项目名根目录

|--资源:任意其他的文件或者目录,可以直接访问

|--WEB-INF:java.class,配置文件，jar，资源

|--classes:web项目中java编译后的class

|--lib:web项目jar

|--web.xml：最终要配置的文件

|--资源:任意其他的文件或者目录,受保护，不能直接访问

路径：

服务器根目录:

文件系统:tomcat/webapps

url: http://localhost:8888

项目根目录:

文件系统:tomcat/webapps/项目名

url: http://localhost:8888/项目名/a/b.do

ecplise:WebContent,部署--处理，符合web项目的目录结构

1. 什么是servlet：

java类，有特殊的功能：能够被浏览器通过URL访问到。

2. 怎么在JavaEE规范下写servlet？

实现接口或继承父类，然后重写service方法。

3种方式，servlet-api:3个

javax.servlet.Servlet接口：5个方法：init(ServletConfig config)；getServletConfig();

service(ServletRequest req, ServletResponse res)；getServletInfo();destroy();

javax.servlet.GenericServlet:只实现了一个service方法。javax.servlet.http.HttpServlet:0个方法，继承之后重写。

按照JavaEE规范编写servlet：3种方式

1.实现javax.servlet.Servlet接口，实现其中的五个抽象方法。主要关注service方法，servlet容器接收到请求后，会根据请求映射加载对应的servlet类，创建其对象，经过一些步骤后，调用service方法。

2.继承javax.servlet.GenericServlet抽象类，GenericServlet实现了Servlet接口，实现了四个抽象方法（init，getServletConfig，getServletInfo，destory），其service方法由自定义servlet实现，servlet容器接收到请求后，会创建对应servlet对象，调用init方法进行初始化，然后调用其service方法。

注：在GenericServlet中有两个init方法：

init(ServletConfig config)与init()方法，在有参数的init方法中，servlet容器在调用的时候会给当前servlet对象的config对象赋值，config对象用来获取该servlet在web.xml中配置的初始化参数，然后调用无参的init方法。即我们要重写init方法的话，需要重写无参的init方法。

两个init方法

1.实现了servlet接口中的有参init：成员变量的赋值

public void init(ServletConfig config) throws ServletException {

this.config = config;

this.init();

}

2.重载了一个无参的init方法，继承之后可以重写，进行初始化设置：

public void init() throws ServletException {

// NOOP by default

}

重写init，做初始化设置，需重写无参init()

3.继承javax.servlet.http.HttpServlet抽象类，HttpServlet中没有抽象方法，继承自GenericServlet，且实现了GenericServlet中的service方法。servlet容器接收到请求后，创建对应servlet对象，调用其service方法：

注：HttpServlet中有两个Service方法，service(ServletRequest req, ServletResponse res)与service(HttpServletRequest req, HttpServletResponse resp)，在servlet容器接收到请求后，创建对应servlet对象，调用init方法进行初始化后，调用参数为ServletRequest ServletResponse的service方法，这个方法中将请求与响应对象类型转换为HttpServletRequest与HttpServletResponse，然后调用第二个service方法，在第二个service方法中，通过HttpServletRequest中封装的方法获取请求方式，如Get请求方式，则，调用对应的doGet方法，Post请求方式，调用对应的doPost方法，所以我们只需要重写doGet或者doPost方法即可。

注1：由于客户端是通过URL地址访问web服务器中的资源，所以Servlet程序若想被外界访问，必须把servlet程序映射到一个URL地址上，这个工作在web.xml文件中使用<servlet>元素和<servlet-mapping>元素完成。

<servlet>元素用于注册Servlet，它包含有两个主要的子元素：<servlet-name>和<servlet-class>，分别用于设置Servlet的注册名称和Servlet的完整类名。

一个<servlet-mapping>元素用于映射一个已注册的Servlet的一个对外访问路径，它包含有两个子元素：<servlet-name>和<url-pattern>，分别用于指定Servlet的注册名称和Servlet的对外访问路径。

注2：可以给一个servlet-mapping配置多个URL。

注3：在Servlet映射到的URL中也可以使用*通配符，但是只能有两种固定的格式：一种格式是"*.扩展名"，另一种格式是以正斜杠（/）开头并以"/*"结尾，否则报错。

注4：在eclipse中写javaee项目的目录结构，与部署到Tomcat服务器下webapps中的应用程序目录结构是不同的。

注5：HttpServlet中有两个service方法

1.实现了Servlet接口中定义的service

HttpServletRequest request;

HttpServletResponse response;

try {

request = (HttpServletRequest) req;

response = (HttpServletResponse) res;

} catch (ClassCastException e) {

throw new ServletException("non-HTTP request or response");

}

service(request, response);

类型强制转换，调用HttpServlet中重载的service

2.HttpServlet重载的service

service(HttpServletRequest req, HttpServletResponse resp)

判断请求方式，根据不同的XXX请求方式，调用对应的doXxx(res,resp)方法

Servlet的生命周期：分为初始化、运行和销毁阶段三个阶段。

创建-----初始化都是由Tomcat负责的

Servlet运行需要多线程环境

初始化：默认，第一次访问servlet的时候

根据配置文件中的配置去修改servlet初始化配置

初始化三步骤：

1）创建servlet对象，调用构造器

2）Init（ServletConfig）：GenericServlet

3）Init()：GenericServlet/自定义servlet重写

多次访问：不会多次创建

Servlet：单例（尽量不要写成员变量，应写局部变量）

运行:Tomcat服务器接收到请求后，封装与该请求相关的对象HttpServletRequest,HttpServletResponse传递给service方法。service--service--doX

4)service(ServletRequest):HttpServlet/[自定义servlet重写]

5)service(HttpServletRequest):HttpServlet/[自定义servlet重写]

6)doXxx(HttpServletRequest):HttpServlet/自定义servlet重写（推荐）

销毁:服务器正常关闭，重新加载

7)destory():GenericServlet/自定义servlet重写（默认空字符串）

getServletConfig():GenericServlet

getServletInfo():GenericServlet/自己重写（空实现）

HttpServlet

注1：可在web.xml中通过<load-on-startup>进行配置，修改servlet对象创建时机。

1)load-on-startup 元素标记容器是否应该在启动的时候加载这个servlet，(实例化并调用其init()方法)。

2)它的值必须是一个整数，表示servlet应该被载入的顺序

3)如果该元素不存在或者这个数为负时，则容器会当该Servlet被请求时，再加载。

4)当值为0或者大于0时，表示容器在应用启动时就加载并初始化这个servlet；

5)正数的值越小，该servlet的优先级越高，应用启动时就越先加载。当值相同时，容器自己选择顺序来加载

注2：servlet是单例模式,在web项目运行期间,一个servlet只会创建一个对象，web项目本身就需要在多线程的环境中运行,tomcat服务器会提供这样的多线程环境,当多个客户端并发访问同一个Servlet时，web服务器会为每一个客户端的访问请求创建一个线程，并在这个线程上调用Servlet的service方法，因此service方法内如果访问了同一个资源的话，就有可能引发线程安全问题。所以在servlet中声明的成员变量,就会有线程安全的问题。所以我们应该尽量少的在servlet中定义成员变量。建议定义局部变量。

4.Servlet接口中的方法：5个

destroy()：servlet销毁的时候调用

getServletConfig()：获取servletConfig对象，初始化参数信息

getServletInfo()：获取servlet相关信息,比如作者、版本、版权等。父类中(GenericServlet)默认返回一个空字符串""，如果需要返回信息的话,可以自己重写这个方法

init(ServletConfig config)：servlet初始化的时候调用

service(ServletRequest req, ServletResponse res)：服务器接受请求后，servlet运行的时候调用。即访问servlet对象的时候被调用。5.ServletConfig中的方法:servlet 4个

getInitParameter(java.lang.String name)：servlet可以在web.xml配置获取初始化参数的值（存在方式类似键值对，可以通过name获取value值）

getInitParameterNames()：获取所有初始化参数名，返回类型为Enumeration，类似于枚举，可以进行迭代遍历所有的初始化参数name，获取到所有的参数value。

getServletContext()：返回一个ServletContext类型的对象(上下文对象).

getServletName()：在web.xml配置的<servlet-name>中的注册名。

自定义的servlet使用servletConfig接口中的方法。

6.servlet的访问

1.地址栏url输入:GET

2.html 超链接 :GET

3.html <form method="GET/POST">（默认get）

4. js,ajax..... GET/POST

5. .......

4.ServletConfig中的方法

在Servlet的配置文件web.xml中，可以使用一个或多个<init-param>标签为servlet配置一些初始化参数。

<init-param>

<param-name></param-name>

<param-value></param-value>

</init-param>

当servlet配置了初始化参数后，web容器在创建servlet实例对象时，会自动将这些初始化参数封装到ServletConfig对象中，并在调用servlet的init方法时，将ServletConfig对象传递给servlet。进而，我们通过ServletConfig对象就可以得到当前servlet的初始化参数信息。

Servlet接受请求参数(在doGet（）{}中写，有四种方式request.get.....)

http://localhost:8888/Servlet/test1Param?name=yungege&age=123456&hobby=study&hobby=read

1.servlet中接收客户端传的参数

浏览器地址栏中直接输入url进行传参

http://127.0.0.1:8989/jd1617_servlet/ParamServlet?name=tom&age=20&like=0&like=1

1.1 getParameter(name):接收单一的参数,根据指定参数名获取参数值，如果多个参数值对应一个参数名，只取第一个。

String name = request.getParameter("name");

String age = request.getParameter("age");

1.2 getParameterValues(name):一个参数对应多个值，取得对应所有值。

String[] like = request.getParameterValues("like");

1.3 getParameterNames():获得客户端本次传参中的所有参数名

Enumeration<String> names = request.getParameterNames();

while(names.hasMoreElements()){

String name = names.nextElement();

System.out.println(name);

}

2.4 getParameterMap():获取所有参数封装到Map中，其中key为参数名，value为参数值，因为一个参数名称可能有多个值，所以参数值是String[]，而不是String。

Map<String, String[]>map = request.getParameterMap();

for(String key:map.keySet()){

System.out.println(key+" : "+Arrays.toString(map.get(key)));

}

Get与Post传参：

url:get

超链接：get

form表单：get/post

readLine()

浏览器中发送字符串的请求格式：

请求行 \r\n

get/post a.html?k=v(get)/a.html(post) HTTP/1.1(协议和协议版本)

请求头 {}\r\n k:v

k2:v2

空行 \r\n

请求体：get方式没有请求体，post k=v

GET请求：

1.请求参数会在浏览器的地址栏中显示，所以不安全；

2.请求参数长度有一定的长度限制(浏览器决定，而且是限制的是整个URI长度，而不仅仅是参数值数据长度，不同浏览器不同版本支持的长度不同)；

3.GET请求没有请求体，无法通过request.setCharacterEncoding()来设置参数的编码；

以下方式发送的请求都是GET请求

1.超链接

2.直接在浏览器地址栏输入回车

3.form表单上Method指明为GET

POST请求：

1.请求参数不会显示浏览器的地址栏，相对安全；

2.请求参数长度取决于服务器；

一般在常见的方式是在Form表单上指明method为POST。

2.中文参数乱码问题

2.1 前台页面不乱码，提交到后台代码乱码

2.1 1get方式传参

修改tomcat中的配置tomcat/conf/server.xml,在修改端口的标签中添加属性URIEncoding="utf-8"

2.12 post方式传参

获取参数之前,先设置一下request中的编码:

request.setCharacterEncoding("UTF-8");此设置只对Post方式有效。

2.2后台代码输出不乱码，前台页面显示乱码

servlet中使用io流给浏览器写回数据,浏览器显示中文乱码

在response获得out输出流，读取参数之前,我们需要设置一下这个输出流是用什么编码来输入内容。之后不起作用。

输出：response.setCharacterEncoding("UTF-8");

默认情况下浏览器会采用中文简体(GBK)来解析响应正文
我们可以在servlet设置响应的头部,来通知浏览器本次响应正文中的内容编码是什么，以让浏览器采用某种解码方式。

response.setContentType("text/html;charset=utf-8");

//第一个参数表示文件的类型，第二个表示解码方式

/有2个作用：1.生成响应头 2.设置输出内容的编码方式

注意:响应内容的整体格式(格式的控制由tomcat负责)

1.响应状态行

2.消息报头/响应头部

3.\r\n

4.响应正文

给浏览器传输的内容都在响应正文中放着。

加/的叫绝对路径，不加/的叫相对路径。

Servlet请求跳转

通过地址栏，a标签,form表单发送请求访问servlet，servlet接收到请求之后希望用流（pw.writer(),边看边写，边读边写，封装）来输出一个页面（response），但如果要跳转到页面：

1. web项目中已有的另一个静态HTML，img

2. Web项目中另一个servlet--servlet-pw/页面

服务器内部跳转（请求转发）：由服务器在执行完一个servlet之后，再继续访问下一个资源。内部跳转尽量使用绝对路径。

特征：1)客户端只发出一次请求；

2)服务器内部进行跳转的时候会把本次请求继续往下传递，request中的参数保留，可以传递（因为请求还是同一个）；

3)客户端浏览器的地址栏中显示的是第一次访问的哪个servlet的访问路径（地址栏不发生变化）

4)服务器内部跳转需要使用request来完成。

操作：服务器内部跳转主要借助于RequestDispatccher对象。

RequestDispatcher dispatcher = request.getRequestDispatcher("资源路径")；

获得一个指定Web资源的包装器。资源可以使页面也可以是其他的servlet。

通过RequestDispatcher进行跳转的方式有两种:

1.forward(request,response)会清空response里边的信息.

dispacher.forword(request,response);

2.include(request,response)不会清空。而是将要跳转到的资源的信息包含到当前response里边，进行追加

dispacher.include(request,response);

注：WEB-INF目录中的内容，要使用服务器内部跳转访问。

3.2外部跳转：客户端重定向

重定向是指页面重新定位到某个新地址，之前的请求失效，进入一个新的请求，且跳转后浏览器地址栏内容将变为新的指定地址。外部跳转尽量使用相对路径。

特征：1.假设浏览器发送请求访问我们的一个servlet,然后这个servlet里面又完成了客户端重定向,重定向到另一个资源中(可能是页面也能servlet),那么浏览器的地址栏中显示的是重定向到的那个资源的地址,浏览器的窗口中显示的重定向到的那个资源信息（浏览器地址发生改变）。

2.每次进行客户端重定向相当于重新发送一次请求,都会是一个全新的request和response。

3.客户端重定向需要使用response来完成，发生多次请求request中的参数无法传递。

操作：response.sendRedirect("资源路径")

4.请求路径：

服务器：内部跳转

相对：当前请求/最近的一次请求

绝对: /：项目名

协议://ip:port/项目名

客户端：外部跳转，前台页面

相对:

绝对：/: //ip:port

4.1.相对路径：请求路径不以"/"开头的，是相对路径，相对路径的相对点是指当前请求所在的路径下。

如果是在请求内部跳转结束后，跳转到浏览器页面上的静态资源,即静态页面，如果使用相对路径的话，则是相对当前浏览器上显示的地址。

4.2绝对路径：指以"/"开头的路径，“/”在不同位置表示的含义不同

1) 前台页面 “/”代表服务器根目录

/ 表示：http://ip:port/

resp.sendRedirect("/");

2) 后台servlet中如果是内部跳转：“/”代表项目名下

/ 表示： http://ip:port/项目名

req.getRequestDispatcher("/……….")

如果是服务器重定向：“/”代表服务器根目录

resp.sendRedirect("/….");

基路径：base（之后所有的路径默认都是以它为基础，在他的路径下找。

前端页面（登录，注册）----servlet----java代码（获取参数，封装对象，处理逻辑，持久化数据库）-----jdbc/mybtis---数据库

三种请求范围：request,session,application

域对象	作用范围	类型
request	一次请求	javax.servlet.http.HttpServletRequesst
session	一次会话	javax.servlet.http.HttpSession
application	当前应用/项目	javax.servlet.ServletContext

1.所有的这些范围都提供一些存取数据的方法：

1.1.存储数据的方法：voidsetAttribute(String key,Object value)

1.2.获取数据的方法：Object value =getAttribute(String key)；

1.3.移除数据的方法：voidremoveAttribute(String key);

1.4.获取所有属性名的方法：Enumeration<String> ns =getAttributeNames();

2. 怎么在doGet或者doPost方法中获取这三种对象呢

request对象：在doGet或者doPost方法的参数中作为参数已经传进来了。

session对象：HttpSession session = request.getSession();

application对象：request.getServletContext();（servletConfig接口）或者

request.getSession().getServletContext();或者

this.getServletContext();或者

this.getServletConfig().getServletContext();

3三种对象的生命周期与作用范围。

Request:生命周期：客户端每次发请求,服务器就会创建一个新的request对象,本次访问结束后,该request对象就会被销毁。所以说在request中存放的数据只在当前请求中起作用。

注:客户端重定向相当于发送不同的请求(多个request对象)

用处：常用于服务器间同一请求不同页面之间的参数传递，常应用于表单的控件值传递。

Session:session表示客户端与服务器的一次会话过程，这个过程是连续的，也可以时断时续的，服务器会为每个会话创建一个session对象，所以session中的数据可供当前会话中所有servlet共享。会话的单位是浏览器。

创建：第一次获取session时创建，创建session对象的三种情况:

1）如果request有对应的session,则返回这个session,如果request没有对应的session,则创建一个新的session并返回。

HttpSession session = request.getSession(true);（有就使用，没有就创建）

2）如果request有对应的session,则返回这个session,如果request没有对应的session,则返回null，也不创建session。

HttpSession session = request.getSession(false);（有就使用，没有就没有）

3）等同于request.getSession(true);

HttpSession session = request.getSession();默认为真

销毁：session销毁有两种情况，一种是session超时，一种是主动销毁。

1、session超时：当客户端与服务端停止交互，不活动状态超过一定时间后，此客户端对应的session对象被销毁，默认30分钟（tomcat\conf\web.xml），可以更改：

1）session.setMaxInactiveInterval(5);单位为秒，对当前session起作用

2）在web.xml中设置：

<session-config>

<session-timeout>1</session-timeout>

</session-config>

单位为分钟，对当前应用中所有的session对象起作用,负数或者0为不限制时间。

优先级1)>2)>默认（即1更精确）

2、主动销毁：调用session.invalidate()的时候会销毁session.

注：当服务器正常关闭时session会被保留,实现序列化[接口]（正常关闭时在Tomcat下的work中会生成相关的序列化文件，重新启动反序列化，文件消失，若有的可以查出来，有的查不出来，那么查不出来的那部分实现序列化接口接好了即implements Serializable）

浏览器关闭，新打开，发现session新建（sessionId找不到了）。

session生命周期：用户打开浏览器会话，第一次获取session开始，直到关闭浏览器会话导致session过期或者主动销毁session结束。一次会话期间只会创建一个session对象。

用处:web开发中的登陆验证界面（当用户登录成功后浏览器分配其一个session键值对），还可以用在购物车，会话追踪。

application：WEB容器在启动时，它会为每个WEB应用程序都创建一个对应的ServletContext对象(application)，它代表当前web应用，ServletContext也被称为应用上下文/servlet上下文。一个JavaWeb应用只创建一个ServletContext对象，所有的客户端在访问服务器时都共享同一个ServletContext对象;ServletContext对象一般用于在多个客户端间共享数据时使用

生命周期：在服务器启动时创建，在服务器关闭时销毁

用处：保存整个Web应用程序共用的数据，如编码格式，用户名密码，网站的在线人数等等。

3. 三个对象的其他一些方法

Request:通过request对象提供的方法，可以获得客户端请求的所有信息。

"返回该请求使用的实际上下文路径(项目名): "+request.getContextPath();

"返回此servlet的映射路径: "+request.getServletPath();

"返回请求行中的资源名部分 "+request.getRequestURI();

"返回客户端发出请求时的完整URL: "+request.getRequestURL();

"返回请求行中的参数部分: "+request.getQueryString();

"返回发出请求的客户机的IP地址:"+request.getRemoteAddr();

"返回发出请求的客户机的完整主机名: "+request.getRemoteHost();

"返回客户机所使用的网络端口号: "+request.getRemotePort();

"返回WEB服务器的IP地址: "+request.getLocalAddr();

"返回WEB服务器的主机名: "+request.getLocalName();

"返回WEB服务器的端口号: "+request.getLocalPort();

"返回请求使用的协议的名字和版本 : "+request.getProtocol();

"返回当前连接使用的协议: "+request.getScheme();

"返回请求发送到服务器的主机名(ip): "+request.getServerName();

"返回请求发送到服务器的端口号: "+request.getServerPort();

request.getRealPath("MessageServlet");

request.getCharacterEncoding();

request.getContentLength();

request.getClass();

//session中常用的方法

HttpSession session = request .getSession();

System.out.println("获取Session创建的时间（返回时间戳）:"+session.getCreationTime());

System.out.println("创建时间："+new Date(session.getLastAccessedTime()));

System.out.println("创建时间："+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date(session.getLastAccessedTime())));

System.out.println("返回客户端最后一次发送与Session相关的请求的时间:"+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date(session.getLastAccessedTime())));

System.out.println("分配给Session的唯一标识符:"+session.getId());

System.out.println("以毫秒为单位的最大间隔时间/不活跃时间:"+session.getMaxInactiveInterval());

System.out.println("返回Session所属的ServletContext对象:"+session.getServletContext());

//application中常用的方法

ServletContext application = getServletContext();

System.out.println(" 实际上下文路径(项目名):"+application.getContextPath());

System.out.println("返回给定虚拟路径中的真实绝对路径:"+application.getRealPath("/index.html"));

System.out.println("返回给定路径下的所有资源列表:"+application.getResourcePaths("/"));

cookie：(JSESSIONID-本次会话的ID)k--v k--v…..

Cookie在服务端以一种java类的方式存在。

Cookies 是一种由服务器发送给客户的片段信息，存储在客户端浏览器的内容中或硬盘上在客户随后对该服务器的请求中发回它，Cookies以键值对的形式记录会话跟踪的内容，在Servlet规范中，用于会话跟踪的Cookie的名字是JSESSIONID。

session和cookie的位置:

session是保存在服务器端的一个对象.客户端是没有session的，cookie在客户端和服务器端都会有。但是存在的形式不一样.在客户端cookie是以本地文件(浏览器管理的文件)的形式存在的,在服务器端是以java对象的形式存在.我们平时说说的cookie都是指的客户端文件形式存在的cookie

session和cookie的作用

session是在服务器端保存用户的相关信息,如Web应用中，登录成功后将用户对象放到session中。cookie是在客户端保存用户的相关信息，以键值对的形式存储字符数据，同时cookie还可以在客户端保存特定的session的信息,例如session的id值,在cookie中，sessionId的键名叫JSESSIONID。