servlet-Tomcat

最新推荐文章于 2024-06-15 22:37:22 发布

风生u

最新推荐文章于 2024-06-15 22:37:22 发布

阅读量237

点赞数 2

文章标签： servlet tomcat java

本文链接：https://blog.csdn.net/m0_56182317/article/details/129743425

版权

目录结构

1.bin：存放Tomcat服务器的可执行程序，主要有两大类，一类是以.sh结尾的（linux命令），另一类是以.bat结尾的（windows命令）。
2.conf：存放文件
3.lib：存放运行依赖jar包
4.logs：存放日志信息
5.temp：存放Tomcat服务器运行时产生的临时数据
6.webapps：用来存放Tomcat服务器部署的工程
7.work：是Tomcat工作时的目录，用来存放Tomcat运行时jsp翻译为Servlet的源码和编译后的文件

配置文件

Tomcat 的配置文件主要由4个xml组成，分别是 context.xml、web.xml、server.xml、tomcat-users.xml。

1.context.xml:
Tomcat 公用的环境配置.
Tomcat 服务器会定时去扫描这个文件。一旦发现文件被修改（时间戳改变了），就会自动重新加载这个文件，而不需要重启服务器。
2.web.xml: (重要)
Web应用程序描述文件，都是关于是Web应用程序的配置文件。所有Web应用的 web.xml 文件的父文件。
3.server.xml: (重要)
tomcat 服务器的核心配置文件，server.xml的每一个元素都对应了 tomcat中的一个组件(pojo对象)，通过对xml中元素的配置，实现对 tomcat中的各个组件和端口的配置。
详解:
访问时会先找到服务->找到连接器->执行引擎找到虚拟主机去对应的appBase(默认是webapps)找到对应war包解压并部署

注: 在webapps下放静态资源时,应在webapps下创建一个文件夹,放在该文件夹中,不能直接放在webapps下,否则会访问不到.

  <Service name="Catalina">//找到服务
  //连接器,访问端口号8080,http协议及版本, 连接超时时间,重定向端口还好
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
     //执行引擎,虚拟主机,默认是localhost
	<Engine name="Catalina" defaultHost="localhost">
      <Realm className="org.apache.catalina.realm.LockOutRealm">
        <Realm className="org.apache.catalina.realm.UserDatabaseRealm" resourceName="UserDatabase"/>
      </Realm>
//Host组件
name和执行引擎中的name对应,虚拟主机的名称，Tomcat通过在请求URL中的域名与name中的值匹配，用于查找能够处理该请求的虚拟主机。如果未找到则交给在Engine中defaultHost指定的主机处理；
appBase是指定存放web应用程序的目录的路径,执行引擎会执行wbapps目录下的war包, 
unpackWARs="true" autoDeploy="true": 自动解压,自动部署
      <Host name="localhost"  appBase="webapps" unpackWARs="true" autoDeploy="true">
       //directory日志文件夹
        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
               prefix="localhost_access_log" suffix=".txt"
               pattern="%h %l %u %t &quot;%r&quot; %s %b" />
      </Host>
		//如果访问这个域名成功解析就会去E:/fs下找文件执行,否则就会去默认的localhost下找并执行
		http://www.fs.com/fs/test/index.html
	  <Host name="www.fs.com"  appBase="E:/fs/test" unpackWARs="true" autoDeploy="true">
       		<!-- 配置了Context, 可以自动到D:\bjsxt\test中寻找访问的资源 -->
       		//http://www.fs.com/就可以访问到了
   			 <Context path="/" docBase="D:\fs\test" />	
       </Host>
    </Engine>
  </Service>

4.tomcat-users.xml:
配置访问Tomcat的用户以及角色的配置文件。

解决控制台乱码

Tomcat在输出日志中使用的是UTF-8编码，而我们中文的Windows操作系统使用的是GBK编码。由于编码格式不统一，所以出现了乱码。
解决方式：修改conf目录中的logging.properties文件重新指定的编码方式。
如果还是不行,那么就删除该行即可:
java.util.logging.ConsoleHandler.encoding = GBK

配置Tomcat并发数

最大并发数: maxThreads=“1000”
初始化时创建的线程数: minSpareThreads=“100”
一旦创建的线程超过这个值，Tomcat就会关闭不再需要的socket线程:maxSpareThreads=“500”
指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理: acceptCount=“700”
例:在连接器中配置

<Connector port="8080" protocol="HTTP/1.1"  minSpareThreads="100"  maxSpareThreads="500" maxThreads="1000" acceptCount="700" connectionTimeout="20000" redirectPort="8443" />

idae集成tomcat

集成后ided会拷贝tomcat中的conf,logs,work文件夹一份,自己用.
在这里插入图片描述
原来tomcat部署位置是webapps,现在变成了如下位置

访问路径层次默认一致

在这里插入图片描述

Tomcat服务器在IDEA中的配置介绍:

update resources：表示当你是修改了静态资源，比如HTML、css等，就可以使用它来启动
update classes and resources：对类的修改使用它不生效，所以不建议使用
Redeploy：重部署，这个适合于你修改了代码，可以重新部署项目到服务器
restart server：重启服务器，修改了web.xml，重启服务器

Servlet的概念

Servlet是Server Applet的简称，称为服务端小程序，是JavaEE平台下的技术标准，基于Java语言编写的服务端程序。

Servlet指的是一个接口规范，具体的体现为接口及其接口的实现类。该接口的名字就是Servlet
Servlet是JavaWeb开发的三大组件之一（另外两个是过滤器filter与监听器listener）

hello world

创建一个类继承Httpservlet

public class Hello extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("hello agc");
    }
}

web.xml
servlet-name：配置Servlet在容器中的一个代号，可以随便写。一般写成类名即可
servlet-class：配置你的Servlet所在的全路径名字
servlet-name：这里的名字一定要和上面配置的servlet-name 一样！！！
url-pattern：配置url的映射路径，也就是你的这个Servlet需要浏览器通过什么请求路径访问你浏览器路径需要这样写：
http://ip地址:端口号/项目名/你的url-pattern

访问流程: 浏览器访问http://localhost:8080/test,servlet-mapping中的url-pattern匹配到后,根据servlet-name中去servlet中找对应的
servlet-name,最后找到servlet-class,通过反射执行servlet方法

<!--    指定servlet类所在路径-->
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.controller.Hello</servlet-class>
    </servlet>
<!--    指定servlet访问路径-->
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/test</url-pattern>
    </servlet-mapping>

Servlet-Tomcat运行过程

一.tomcat运行原理: 连接器(connector) -> 执行引擎(Engine) -> 虚拟主机(host) -> 当前部署项目 -> 执行servlet后一层一层的返回
在这里插入图片描述

二.Servlet在Tomcat中运行的原理:
1.启动Tomcat服务器（以下动作只在服务器启动的时候执行) -> 解析web项目的web.xml文件
2.Tomcat服务器接收请求 -> 请求地址: http://localhost:8080/demo/query
3.Tomcat服务器解析请求 -> Tomcat服务器解析请求后，会诞生两个对象分别为:
HttpServletRequest对象: 存储此次请求的所有相关信息(行、头、体)，每次请求重新创建
HttpServletResponse对象:存储了此次请求的响应流对象，每次请求重新创建
4.Tomcat服务器查找请求的资源
-> 通过反射创建Servlet对象:Class clazz=Class.forName(“包名+类名”) -> 获取实例: Servlet servlet= clazz.newInstance();
将创建好的Servlet对象放到Map集合中：
key是web.xml配置文件中的映射路径（url-pattern）
value是Servlet对象
Tomcat服务器根据请求地址从map集合中获取要调用的Servlet对象
Servlet servlet=map.get(“/query”);
5.Tomcat服务器调用Servlet对象的过程:

	Class clazz= servlet.getClass();
	Method method = clazz.getMethod(“service”,HttpServletRequest.class,HttpServletResponse.class);
	//通过反射调用
	method.invoke(servlet,request,response);

注意:
该流程由Tomcat底层接收请求后自动执行，我们是看不到的，我们需要做的是将实现了Servlet接口的代码提前放到Tomcat服务器中，这样请求被接收后就可以反射调用了。

servlet的使用

代码编写流程

打开IDEA
在IDEA中创建一个Java Enterprise项目
在项目的src目录下创建一个com.bjsxt.servlet包，在包中创建自己的类继承HttpServlet
重写service方法，在service方法中写的就是处理请求的业务逻辑代码
在web.xml中配置映射关系
启动tomcat服务器
在浏览器输入路径访问Servle

默认欢迎页的设置

启动tomcat默认打开的页面
欢迎页可以配置多个,匹配优先级自上而下。

<welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
</welcome-file-list>

一般在我们项目中要设置默认欢迎页的话，在自己项目的web.xml中设置即可！不要改Tomcat中的conf/web.xml进行设置。

<welcome-file-list>
    <welcome-file>hello.html</welcome-file>
</welcome-file-list>

Servlet的生命周期

1.创建
Servlet对象在第一次被浏览器访问的时候创建与初始化的（默认）
Servlet在启动服务器的时候被创建与初始化的（该方式需要做一些配置，告诉Tomcat服务器在启动的时候就创建Servlet对象）
2.创建完后会驻留在内存当中,处理各种请求,处理完后,不会销毁
3.销毁
服务器停止(关闭tomcat)就会销毁

构造器: public 继承Httpservlet类名() 服务开启到结束只执行一次
初始化方法: public void init(ServletConfig config)服务开启到结束只执行一次
处理请求的方法: protected void service(HttpServletRequest req, HttpServletResponse resp)
销毁servlet方法: public void destroy()服务器关闭

在web.xml中添加load-on-startup的配置:
配置了load-on-startup的情况：
服务器启动的时候就会执行：构造方法，然后执行初始化方法。(创建servlett对象)
之后有请求过来，就直接走service方法进行处理。
服务器停止的时候，执行销毁方法。

 <servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>com.bjsxt.controller.HelloServlet</servlet-class>
    <!--    
        load-on-startup就是在启动服务器时就创建并初始化Servlet对象
        数字越小，优先级越高。   
    -->
    <load-on-startup>1</load-on-startup>
</servlet>

在这里插入图片描述

web.xml详解

web.xml的作用：配置了Servlet所在类的全路径；配置了Servlet访问的映射路径
web.xml的加载时机：在服务器启动的时候完成web.xml文件的加载

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0"
         metadata-complete="ture">

         <!-- metadata-complete取值为true，表示关闭注解支持 -->
         <!-- **metadata-complete取值为false，表示启用注解支持** -->
		<!--    指定servlet类所在路径-->
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.controller.Hello</servlet-class>
    </servlet>
<!--    指定servlet访问路径-->
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/test</url-pattern>
    </servlet-mapping> 
</web-app>

当metadata-complete取值为false时,开启注解支持
等价于

@WebServlet("/abc")
public class Hello extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("hello agc");
    }
}

<servlet>
        <servlet-name>UserServlet</servlet-name>
        <servlet-class>com.bjsxt.controller.UserServlet</servlet-class>
</servlet>
<servlet-mapping>
        <servlet-name>UserServlet</servlet-name>
            1. url-pattern的值是 /字符 的方式
              比如  /UserServlet，那访问该Servlet的时候url这么写：http://ip:port/项目名/UserServlet
        <url-pattern>/UserServlet</url-pattern>
            2. url-pattern的值是 *.do的方式，
              比如 *.do  那访问该Servlet的时候url这么写：http://ip:port/项目名/xxx.do 只要以.do结尾就行
        <url-pattern>*.do</url-pattern>
            3. url-pattern的值是 多级目录的方式
              比如 /user/UserServlet，那访问该Servlet的时候url这么写：http://ip:port/项目名/user/UserServlet
        <url-pattern>/user/UserServlet</url-pattern>
            4. url-pattern的值是 /*，表示拦截所有请求
               那随便写个访问到该项目的url地址，都会访问该Servlet
        <url-pattern>/*</url-pattern>
            5. url-pattern的值是 /，表示拦截所有请求，但是不拦截 jsp文件
               除了访问jsp外，访问其他的资源都会访问到该Servlet
        <url-pattern>/</url-pattern>
    </servlet-mapping>

说明：一个Servlet可以配置多个url-pattern，但是多个Servlet不能配置相同的url-pattern，这样的话请求过来后tomcat不知道该调用哪个Servlet进行处理

Servlet的继承结构

在这里插入图片描述

请求(HttpServletRequest)

service方法中写业务逻辑代码的话，大概是如下三步：
获取请求数据
处理请求数据
响应结果
1.request对象的来源
浏览器发送请求后，由tomcat服务器接收到，然后对请求的信息进行解析，将解析结果封装到HttpServletRequest和HttpServletResponse两个对象中。

2.request对象的特点
每次请求，tomcat服务器对请求进行解析后都会创建一个新的,一个请求对应一个,request对象存储了此次请求的所有数据（http协议中的请求行、头、体）

3.request对象的使用

1.request对象获取请求行数据
//获取请求方式
String method = req.getMethod();
//获取请求的URI
String uri = req.getRequestURI();
 //获取请求协议
String scheme = req.getScheme();

2.request对象获取请求头数据
//获取请求头信息，根据键名去获取
//获取请求的主机信息
String host = req.getHeader("host");
//获取浏览器信息
String userAgent = req.getHeader("User-Agent");
Enumeration<String> headerNames = req.getHeaderNames();
获取所有的请求头信息
//拿到所有请求头的名字
Enumeration<String> headerNames = req.getHeaderNames();
 
3.request对象获取请求体数据
//获取请求体数据, getParameter()方法的参数必须和请求中的参数名一致！！！
String name = req.getParameter("name");

4.request对象获取其他数据
//获取其他数据
//获取项目路径, 格式是 /项目名
String contextPath = req.getContextPath();

请求数据乱码问题解决
在Tomcat8.0及以后，不管是get请求还是post请求，
都只需要设置req.setCharacterEncoding(“utf-8”);即可解决请求乱码。

在Tomcat8.0之前，如果是通过get请求接收到的参数发生乱码的话，可以通过如下方式解决：
String s = new String(req.getParameter(“name”).getBytes(“iso-8859-1”),“utf-8”);

响应(HttpServletResponse)

响应数据乱码问题解决:
原因: Tomcat服务器默认使用utf-8的编码格式编码响应数据，而浏览器默认使用ISO-8859-1来解析响应数据。
解决: resp.setContentType(“text/html;charset=utf-8”);
response对象:
1.作用:
用来响应浏览器发起的请求，其中封装了响应结果数据及客户端的一些信息等。
2.response对象的特点
由Tomcat接收到请求后完成创建，并作为实参传递给对应的service方法使用,每次请求都会重新创建，请求结束后即销毁。
程序员在service方法中直接调用即可。HttpServletResponse是一个接口，service方法接收到的是实例化对象。
3.response对象的使用

1.使用respose对象完成数据的响应
response.getWriter().write(“响应内容”);//底层是本质就是网络编程的流输出。
注意：响应内容可以直接是数据，也可以是数据+HTML标签+CSS样式+JS脚本。

2.使用response对象设置响应头
//setHeader()方法作用：设置响应头，key相同的话，后面设置的值会覆盖前面设置的
resp.setHeader("key1", "value1");
//addHeader()方法作用：设置响应头，key相同的话，后面设置的值不会覆盖前面设置的
resp.addHeader("name1", "value1");

//下面两行代码是等价的
resp.setContentType("text/html;charset=utf-8");//设置响应的数据类型及解码方式
resp.setHeader("Content-Type", "text/html;charset=utf-8");//设置响应的数据类型及解码方式

请求转发和请求重定向

1.请求转发: 服务器行为,服务器获取资源返回给客户端(一般是servlet之间互相跳)
在Servlet的service方法中完成其他Servlet的调用。
req.getRequestDispatcher(“/Servlet2”).forward(req,resp);
请求转发的特点

请求转发是一次请求，地址栏地址不变，还是访问第一个Servlet的地址
请求转发是一次请求，所以转发内的各个Servlet共享一个request对象
请求转发是Tomcat服务器内部的行为，用户是看不到的
可以使用req.setAttribute(key,value)和getAttribute(key)实现请求转发内的Servlet的数据的流转
注意：在学习的请求转发后，每个Servlet的访问方式就会有两种：
浏览器直接发起请求访问
其他Servlet通过请求转发访问
总结：请求转发可以实现在后端Servlet之间的相互调用，一个请求由一个Servlet处理，转变为了多个Servlet的协同处理。

2.请求重定向: 客户端行为,客户端访问服务器后,服务器告诉客户单正确的资源地址,客户端重新访问新地址(一般是跳转到其他页面)
resp.sendRedirect(req.getContextPath() + “/MainServlet”);
请求重定向的特点

重定向是两次请求，地址栏信息改变，地址会变成第二次请求的地址
重定向的地址是浏览器收到第一次请求响应回来的地址，自动跳转的，用户不参与
重定向的两次请求，request对象是不同的

Cookie

解决用户访问时的信息认证沉余.
1.特点:
Cookie是浏览器端的数据存储技术,浏览器每次发起请求的时候，请求信息中就包含了Cookie中存储的数据
Cookie不适合大量数据的存储（每个Cookie存储的数据不超过4KB）,不安全，不适合存储重要的数据到浏览器端

2.Cookie的创建及响应

//创建Cookie，Cookie中保存的数据是键值对的方式
Cookie cookie = new Cookie("username", "root");

//将创建好的Cookie添加到响应中，这样浏览器就会将Cookie中的信息保存起来了
resp.addCookie(cookie);

3.Cookie的获取:

Cookie[] cookies = req.getCookies();

4.Cookie的存活设置:
Cookie是可以设置在浏览器的存活时间的。
使用setMaxAge()方法可以设置存活时间:
正数：表示在指定的秒数后过期,Cookie的持久化
负数：表示浏览器关闭，Cookie自动被删除（默认是-1）
零：表示马上删除Cookie
例:
Cookie cookie = new Cookie(“life60”, “life60”);
cookie.setMaxAge(60);
resp.addCookie(cookie);

5.Cookie的path属性
Cookie的path属性可以有效的过滤哪些Cookie可以发送给服务器，哪些不发
指定访问哪个路径携带cookie
访问同一个tomcat服务器中部署的资源会携带
/项目名:访问项目中所有资源都会携带(默认)
/项目名/资源名:访问项目中指定资源会携带

只有访问该路径才会携带该Cookie

Cookie cookie = new Cookie("path1","path1");
cookie.setPath(req.getContextPath() + "/abc");// 路径是  /工程路径/abc
resp.addCookie(cookie);

6.Cookie有domain属性
可以通过domain属性设置访问该Cookie的域名。如果设置为“www.fs.com”，则只能是 “www.fs.com” 可以访问。如果设置为 “.itbz.com”，则以 “.itbz.com” 结尾的域名都可以访问到该Cookie。

Cookie cookie = new Cookie(“a”, “b”);
cookie.setDomain(“.abc.com”);

HttpSession对象

Session和Cookie是HTTP协议无状态的两种解决方案
Cookie将数据保存在客户端
Session将数据保存在服务器端

Session技术解决用户发送不同请求时数据共享的问题,一个用户(一个浏览器)在服务器中只会创建一个Session对象。不同用户的Session对象之间是互相独立的
在服务器中创建Session对象，创建完成后会将Session对象的Id(JSESSIONID)以Cookie的形式保存在客户端(浏览器)，用户再次发请求时，会携带该Cookie，也就是JSESSIONID到服务器，服务器会根据该id找到用户的Session对象
如果请求中没有携带JSESSIONID，则会创建一个Session对象, 会将JSESSIONID存储在Cookie中响应回浏览器
用户JSESSIONID的Cookie丢失或者服务器中存储的Session对象被销毁，服务器接收到用户的请求后，如果找不到对应的Session对象，会重新创建，并将新的JSESSIONID以Cookie的形式保存到浏览器中
存储JSESSIONID的Cookie不需要手动创建，Session对象创建完成，Tomcat服务器会自动创建Cookie, 将JESSIONID存储在Cookie中响应回浏览器。
6. Cookie默认的有效期为一次会话(浏览器不能关闭)，浏览器关闭，Cookie即失效
7. Session对象在Tomcat服务器的默认有效期为30分钟

1.创建session,Httpsession不会自动创建,只用调用该方法才会创建session
该方法作用: req.getSession()
如果请求的Cookie中携带了JSESSIONID，则根据JSESSIONID找对应的Session对象

找到, 返回该Session
没有找到, 创建新的Session对象, 会将JSESSIONID存储在Cookie中响应回浏览器
服务器中能找到对应的Session对象，那就使用该Session对象，如果找不到，就会新创建。

HttpSession session = req.getSession();

2.HttpSession存储数据

session.setAttribute("user", user);

3.HttpSession获取数据

session.getAttribute("user");

4.HttpSession的销毁方式
达到超时时间后会销毁, 默认30分钟, 时间的计算方式是根据最后一次请求时间作为起始时间开始计算
Tomcat服务器的conf/web.xml文件中配置HttpSession的超时时间。这个文件是所有项目web.xml的父文件，不建议修改

可以修改项目的web.xml中的HttpSession的超时时间。该时间对整个web项目中的所有HttpSession对象有效

<session-config>
    <!--设置Session的超时时间，单位是分钟-->
    <session-timeout>10</session-timeout>
</session-config>

注意:
客户端关闭浏览器后，再次打开浏览器并发起请求，由于存储JSESSIONID的Cookie会销毁，服务器会重新创建Session对象。服务器端的旧的Session对象还在，存储的数据也在，过了超时时间后，就销毁了！

5.Session相关方法

String id = session.getId();//获取JSESSIONID
long creationTime = session.getCreationTime();//获取创建时间
long lastAccessedTime = session.getLastAccessedTime();//获取最后一次访问时间	
session.setMaxInactiveInterval(10);//设置最大非活动时间
int maxInactiveInterval = session.getMaxInactiveInterval();//获取最大非活动时间
session.invalidate();//销毁session对象

HttpSession对象总结

Session和Cookie的区别：

Cookie数据存储在客户端，而HttpSession中的数据存储在服务器
Cookie不安全，而HttpSession是安全的
单个cookie保存的数据不能超过4KB，很多浏览器都限制一个域名保存cookie的数量,HttpSession没有容量以及数量的限制, 随着Session中存储的内容增多，会比较占用服务器内存, Session不存放业务数据
Cookie的数据都以字符串的形式保存。Session中可以保存对象
Cookie实现, 如: 记住我最近浏览商品网页皮肤等
Session实现, 如: 登录信息错误信息购物车等
Session和Cookie的关系：Session依赖于Cookie

ServletContext对象

项目中可以使用Session对象在服务器端存储数据，它解决了一个用户不同请求的数据共享问题。
所有用户都可以获取及使用，可以实现不同用户请求的数据共享

1.特点:

ServletContext对象由Tomcat服务器在启动加载项目的时候完成创建
2. ServletContext对象一个项目中只有一个，以任意方式获取到的都是同一个
ServletContext对象中保存的数据是所有用户共享的

2.获取ServletContext对象

//方式一：
ServletContext servletContext = this.getServletContext();
//方式二：
ServletContext servletContext1 = req.getSession().getServletContext();
**//方式三：
ServletContext servletContext2 = req.getServletContext();**

3.使用ServletContext对象存取数据

 //往ServletContext对象中存数据，键值对的方式
servletContext.setAttribute("name", "root");
//从ServletContext对象中获取数据
String name = (String)servletContext.getAttribute("name");

4.ServletContext对象获取web.xml中配置的上下文参数
可以在web.xml中配置一些参数，可以通过ServletContext对象获取。经常出现在框架的底层。

<!--配置上下文参数-->
<context-param>
    <param-name>name</param-name>
    <param-value>admin</param-value>
</context-param>

<context-param>
    <param-name>age</param-name>
    <param-value>18</param-value>
</context-param>

String name1 = servletContext.getInitParameter("name");
String age = servletContext.getInitParameter("age");
System.out.println("name:" + name1 + ", age:" + age);

5.ServletContext对象的生命周期
当服务器启动时会创建ServletContext对象。服务器关闭后该对象销毁。
ServletContext对象的生命周期很长，仅存放所有用户共享的数据

域

三大域对象
request域对应HttpServeltRequest对象也叫请求域
Session域对应HttpSession对象也叫会话域
application域对应ServletContext对象也叫应用域
常用方法:
setAttribute(key, value) 向域中添加/修改数据，无则添加，有则修改
getAttribute(key) 获取域中的数据
removeAttribute(key) 从域中移除指定key的数据

1.request域
有效范围:
在一次请求内有效，比如：转发。一般用于存储单次请求之内的业务数据。
生命周期:
创建：浏览器每次请求，服务器都会重新创建
使用：在请求的Servlet中或者请求转发后的Servlet中使用
销毁：请求响应结束后，该请求对象就会被销毁

2.Session域
有效范围:
单次会话内有效，多次请求。
一般用来存储用户状态数据，比如用户的登录信息。
生命周期:
创建：从第一次发出请求，会话开始
使用：一次会话内，浏览器和服务器之间发生多次请求和响应都有效
销毁：会话结束，比如：达到最大不活动时间、手动销毁
3.Application域
有效范围
当前web项目内都有效，可以跨请求，跨会话访问。
一般放一些全局的和项目本身相关所有用户共享的数据，如在线人数，不建议存放业务数据。
生命周期
创建：服务器启动
使用：服务器运行期间都有效
销毁：服务器关闭

风生u

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
servlet-Tomcat

用户JSESSIONID的Cookie丢失或者服务器中存储的Session对象被销毁，服务器接收到用户的请求后，如果找不到对应的Session对象，会重新创建，并将新的JSESSIONID以Cookie的形式保存到浏览器中。tomcat 服务器的核心配置文件，server.xml的每一个元素都对应了 tomcat中的一个组件(pojo对象)，通过对xml中元素的配置，实现对 tomcat中的各个组件和端口的配置。Tomcat服务器的conf/web.xml文件中配置HttpSession的超时时间。
复制链接

扫一扫