Servlet开发与生命周期详解-2

news2025/3/31 10:31:22

一、在集成开发环境当中开发Servlet程序

1.集成开发工具很多，其中目前使用比较多的是：

  • IntelliJ IDEA（这个居多，IDEA在提示功能方面要强于Eclipse，也就是说IDEA使用起来比Eclipse更加智能，更好用。JetBrain公司开发的。收费的。）

  • Eclipse（这个少一些），Eclipse目前还是有团队使用，只不过处于减少的趋势，自己从事工作之后，可能会遇到。Eclipse是IBM团队开发的。Eclipse寓意是“日食”。“日食”表示将太阳吃掉。太阳是SUN。IBM团队开发Eclipse的寓意是吞并SUN公司，但是2009年的时候SUN公司被Oracle公司并购了。IBM并没有成功并购SUN公司。

2.使用IDEA集成开发工具开发Servlet

  • 第一步：New Project（我比较习惯先创建一个Empty Project【空工程】，然后在空工程下新建Module【模块】，这不是必须的，只是一种习惯，你可以直接新建非空的Project），这个Empty Project起名为：javaweb（不是必须的，只是一个名字而已。一般情况下新建的Project的名字最好和目录的名字一致。）

  • 第二步：新建模块（File --> new --> Module...）

    • 这里新建的是一个普通的JavaSE模块（这里先不要新建Java Enterprise模块）

    • 这个Module自动会被放在javaweb的project下面。

    • 这个Module起名：servlet01

  • 第三步：让Module变成JavaEE的模块。（让Module变成webapp的模块。符合webapp规范。符合Servlet规范的Module）

    • 在Module上点击右键：Add Framework Support...（添加框架支持）

    • 在弹出的窗口中，选择Web Application（选择的是webapp的支持）

    • 选择了这个webapp的支持之后，IDEA会自动给你生成一个符合Servlet规范的webpp目录结构。

    • 重点，需要注意的：在IDEA工具中根据Web Application模板生成的目录中有一个web目录，这个目录就代表webapp的根

  • 第四步（非必须）：根据Web Application生成的资源中有index.jsp文件，这里我选择删除这个index.jsp文件。

  • 第五步：编写Servlet（StudentServlet）

    • class StudentServlet implements Servlet

    • 这个时候发现Servlet.class文件没有。怎么办？将CATALINA_HOME/lib/servlet-api.jar和jsp-api.jar添加到classpath当中（这里的classpath说的是IDEA的classpath）

      • File --> Project Structrue --> Modules --> + 加号 --> Add JARS....

    • 实现jakarta.servlet.Servlet接口中的5个方法。

  • 第六步：在Servlet当中的service方法中编写业务代码（我们这里连接数据库了。）

  • 第七步：在WEB-INF目录下新建了一个子目录：lib（这个目录名可不能随意，必须是全部小写的lib），并且将连接数据库的驱动jar包放到lib目录下。

  • 第八步：在web.xml文件中完成StudentServlet类的注册。（请求路径和Servlet之间对应起来）

    <?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">


    <!-- 定义一个 Servlet 配置 -->
    <servlet>
        <!-- 为 Servlet 定义一个名称，这个名称用于在后续的映射配置中引用该 Servlet -->
        <servlet-name>studentServlet</servlet-name>
        <!-- 指定 Servlet 类的全限定名，即包含包名的类名，服务器会根据这个类名来实例化 Servlet -->
        <servlet-class>oop1.StudentServlet</servlet-class>
    </servlet>
    <!-- 定义 Servlet 的映射配置，将一个 URL 模式映射到之前定义的 Servlet 上 -->
    <servlet-mapping>
        <!-- 指定要映射的 Servlet 的名称，这个名称必须与上面 <servlet> 标签中定义的名称一致 -->
        <servlet-name>studentServlet</servlet-name>
        <!-- 定义一个 URL 模式，当客户端请求的 URL 匹配这个模式时，服务器会将请求转发给对应的 Servlet 进行处理 -->
        <url-pattern>/servlet/student</url-pattern>
    </servlet-mapping>
</web-app>

    当客户端请求的 URL 为 /servlet/student 时，服务器会找到 oop1.StudentServlet 类的实例来处理该请求。

第九步：给一个html页面，在HTML页面中编写一个超链接，用户点击这个超链接，发送请求，Tomcat执行后台的StudentServlet。

  • student.html

  • 这个文件不能放到WEB-INF目录里面，只能放到WEB-INF目录外面。

  • student.html文件的内容

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>student page</title>
</head>
<body>
    <!--这里的项目名是 /xmm ，无法动态获取，先写死-->
    <a href="/xmm/servlet/student">student list</a>
</body>
</html>

  • 第十步：让IDEA工具去关联Tomcat服务器。关联的过程当中将webapp部署到Tomcat服务器当中。

    • IDEA工具右上角，绿色小锤子右边有一个：Add Configuration

    • 左上角加号，点击Tomcat Server --> local

    • 在弹出的界面中设置服务器Server的参数（基本上不用动）

    • 在当前窗口中有一个Deployment（点击这个用来部署webapp），继续点击加号，部署即可。

    • 修改 Application context为：/xmm

  • 第十一步：启动Tomcat服务器

    • 在右上角有绿色的箭头，或者绿色的小虫子，点击这个绿色的小虫子，可以采用debug的模式启动Tomcat服务器。

    • 我们开发中建议适用debug模式启动Tomcat

  • 第十二步：打开浏览器，在浏览器地址栏上输入：http://localhost:8080/xmm/student.html

3.tomcat配置的解释

⑴.通用设置

  • Name
    翻译：名称
    解释：给当前运行 / 调试配置设置一个自定义名称，方便区分不同配置。
  • Store as project file
    翻译：存储为项目文件
    解释：勾选后，该配置会保存为项目文件，便于团队共享或重复使用。

⑵.标签页

  • Server
    翻译：服务器
    解释：配置服务器相关参数，如端口、浏览器打开设置等。
  • Deployment
    翻译：部署
    解释：设置项目如何部署到服务器（如部署目录、war 包等）。
  • Logs
    翻译：日志
    解释：查看服务器日志相关设置或直接查看日志内容。
  • Code Coverage
    翻译：代码覆盖率
    解释：分析代码在运行时的执行覆盖情况（需额外工具支持）。
  • Startup/Connection
    翻译：启动 / 连接
    解释：配置服务器启动参数、连接超时等与启动和连接相关的设置。

⑶.Server 标签页内容

  • Application server
    翻译：应用服务器
    解释：下拉选择已配置的应用服务器（如 Tomcat），若未配置，需点击右侧 Configure 配置。
  • Open browser
    翻译：打开浏览器
    解释：设置服务器启动后是否自动打开浏览器。
    • After launch：翻译：启动后；解释：勾选表示服务器启动后执行后续操作（如打开浏览器）。
    • with JavaScript debugger：翻译：使用 JavaScript 调试器；解释：调试时启用 JavaScript 调试功能。
  • URL
    翻译：统一资源定位符
    解释：设置服务器启动后自动打开的网址（如项目访问地址）。
  • VM options
    翻译：虚拟机选项
    解释：填写 JVM 运行参数（如内存分配 -Xmx512m 等）。
  • On 'Update' action
    翻译：在 “更新” 操作时
    解释：选择对项目更新时服务器的响应动作。
    • Restart server：翻译：重启服务器；解释：代码更新时重启服务器。
    • Show dialog：翻译：显示对话框；解释：执行更新操作时弹出确认对话框。
  • JRE
    翻译：Java 运行时环境
    解释：选择项目运行所需的 JRE（Java Runtime Environment）。

⑷Tomcat Server Settings（Tomcat 服务器设置）

  • HTTP port
    翻译：HTTP 端口
    解释：设置 Tomcat 用于 HTTP 通信的端口（默认 8080）。
  • Deploy applications configured in Tomcat instance
    翻译：部署 Tomcat 实例中配置的应用
    解释：勾选后，会部署 Tomcat 自身配置的应用（而非通过 IDE 配置的应用）。
  • HTTPS port
    翻译：HTTPS 端口
    解释：设置 Tomcat 用于 HTTPS 通信的端口（需配置 SSL 证书）。
  • Preserve sessions across restarts and redeploys
    翻译：在重启和重新部署时保留会话
    解释：勾选后，服务器重启或重新部署时保留用户会话信息（如登录状态）。
  • AJP port
    翻译：AJP 端口
    解释：设置 Tomcat 用于 AJP（Apache JServ Protocol）协议的端口，用于与其他服务器通信。

二、Servlet对象的生命周期

1.什么是Servlet对象生命周期？

  • Servlet对象什么时候被创建。

  • Servlet对象什么时候被销毁。

  • Servlet对象创建了几个？

  • Servlet对象的生命周期表示：一个Servlet对象从出生在最后的死亡，整个过程是怎样的。

2.Servlet对象是由谁来维护的？

  • Servlet对象的创建，对象上方法的调用，对象最终的销毁，Javaweb程序员是无权干预的。

  • Servlet对象的生命周期是由Tomcat服务器（WEB Server）全权负责的。

  • Tomcat服务器通常我们又称为：WEB容器。（这个叫法你要知道【WEB Container】）

  • WEB容器来管理Servlet对象的死活。

3.思考：我们自己new的Servlet对象受WEB容器的管理吗？

Web容器中的Map集合

  • 我们自己new的Servlet对象是不受WEB容器管理的。

  • WEB容器创建的Servlet对象，这些Servlet对象都会被放到一个集合当中（HashMap），只有放到这个HashMap集合中的Servlet才能够被WEB容器管理，自己new的Servlet对象不会被WEB容器管理。（自己new的Servlet对象不在容器当中）

  • web容器底层应该有一个HashMap这样的集合，在这个集合当中存储了Servlet对象和请求路径之间的关系

4.研究：服务器在启动的Servlet对象有没有被创建出来（默认情况下）？

  • 在Servlet中提供一个无参数的构造方法，启动服务器的时候看看构造方法是否执行。

  • 经过测试得出结论：默认情况下，服务器在启动的时候Servlet对象并不会被实例化。

  • 这个设计是合理的。用户没有发送请求之前，如果提前创建出来所有的Servlet对象，必然是耗费内存的，并且创建出来的Servlet如果一直没有用户访问，显然这个Servlet对象是一个废物，没必要先创建。

使用简单代码验证：

⑴创建新模块：

oop1包下的AServlet

package oop1;

import jakarta.servlet.*;

import java.io.IOException;

public class AServlet implements Servlet {

    // 无参数构造方法
    public AServlet() {
        System.out.println("AServlet无参数构造方法执行了");
    }

    // 程序员手动提供Servlet类的有参数的构造方法，会怎么样？
    /*public AServlet(String s){

    }*/

    // init被翻译为初始化
    // init方法只执行一次
    // 在AServlet对象第一次被创建之后执行。
    // init方法通常是完成初始化操作的。
    // init方法在执行的时候AServlet对象已经被创建出来了。
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("AServlet's init method execute!");
    }

    // service方法：是处理用户请求的核心方法。
    // 只要用户发送一次请求，service方法必然会执行一次。
    // 发送100次请求，service方法则执行100次。
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("AServlet's service method execute!");
    }

    // destroy方法也是只执行一次。
    // Tomcat服务器在销毁AServlet对象之前会调用一次destroy方法
    // destroy方法在执行的时候，AServlet对象的内存还没有被销毁。即将被销毁。
    // destroy方法中可以编写销毁前的准备。
    // 比如说，服务器关闭的时候，AServlet对象开启了一些资源，这些资源可能是流，可能是数据库连接
    // 那么，关闭服务器的时候，要关闭这些流，关闭这些数据库连接，那么这些关闭资源的代码就可以写到destroy方法当中。
    @Override
    public void destroy() {
        System.out.println("AServlet's destroy method execute!");
    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public String getServletInfo() {
        return null;
    }
}

oop1包下的BServlet

package oop1;

import jakarta.servlet.*;

import java.io.IOException;

public class BServlet implements Servlet {

    // 无参数构造方法
    public BServlet() {
        System.out.println("BServlet无参数构造方法执行了");
    }

    @Override
    public void init(ServletConfig servletConfig) throws ServletException {

    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {

    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {

    }
}

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">

    <servlet>
        <servlet-name>aservlet</servlet-name>
        <servlet-class>oop1.AServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>aservlet</servlet-name>
        <url-pattern>/a</url-pattern>
    </servlet-mapping>
    <servlet>
        <servlet-name>bservlet</servlet-name>
        <servlet-class>oop1.BServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>bservlet</servlet-name>
        <url-pattern>/b</url-pattern>
    </servlet-mapping>
</web-app>

中间忽略红字

 生命周期流程图

容器启动
  ↓
创建 Servlet 实例 → 若失败 → 标记为不可用
  ↓
调用 init(config) → 若抛出异常 → 销毁实例
  ↓
等待请求 → 调用 service(req, res)
  ↓
容器关闭/卸载应用
  ↓
调用 destroy() → 清理资源
  ↓
Servlet 实例被回收

5.怎么让服务器启动的时候创建Servlet对象呢？

  • 在servlet标签中添加<load-on-startup>子标签，在该子标签中填写整数，越小的整数优先级越高。

<servlet>
    <servlet-name>aservlet</servlet-name>
    <servlet-class>oop1.AServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>aservlet</servlet-name>
    <url-pattern>/a</url-pattern>
</servlet-mapping>

越小的整数优先级越高。

6.Servlet对象生命周期

  • 默认情况下服务器启动的时候AServlet对象并没有被实例化

  • 用户发送第一次请求的时候，控制台输出了以下内容：

AServlet无参数构造方法执行了
AServlet's init method execute!
AServlet's service method execute!

只要在网页上输入http://127.0.0.1:8080/lifecycle/a

就会显示

AServlet's service method execute!

  • 根据以上输出内容得出结论：

    • 用户在发送第一次请求的时候Servlet对象被实例化（AServlet的构造方法被执行了。并且执行的是无参数构造方法。）

    • AServlet对象被创建出来之后，Tomcat服务器马上调用了AServlet对象的init方法。（init方法在执行的时候，AServlet对象已经存在了。已经被创建出来了。）

    • 用户发送第一次请求的时候，init方法执行之后，Tomcat服务器马上调用AServlet对象的service方法。

  • 用户继续发送第二次请求，控制台输出了以下内容：

AServlet's service method execute!

  • 根据以上输出结果得知，用户在发送第二次，或者第三次，或者第四次请求的时候，Servlet对象并没有新建，还是使用之前创建好的Servlet对象，直接调用该Servlet对象的service方法，这说明：

    • 第一：Servlet对象是单例的（单实例的。但是要注意：Servlet对象是单实例的，但是Servlet类并不符合单例模式。我们称之为假单例。之所以单例是因为Servlet对象的创建我们javaweb程序员管不着，这个对象的创建只能是Tomcat来说了算，Tomcat只创建了一个，所以导致了单例，但是属于假单例。真单例模式，构造方法是私有化的。）

    • 第二：无参数构造方法、init方法只在第一次用户发送请求的时候执行。也就是说无参数构造方法只执行一次。init方法也只被Tomcat服务器调用一次。

    • 第三：只要用户发送一次请求：service方法必然会被Tomcat服务器调用一次。发送100次请求，service方法会被调用100次。

  • 关闭服务器的时候，控制台输出了以下内容：

AServlet's destroy method execute!

  • 通过以上输出内容，可以得出以下结论：

    • Servlet的destroy方法只被Tomcat服务器调用一次。

    • destroy方法是在什么时候被调用的？

      • 在服务器关闭的时候。

      • 因为服务器关闭的时候要销毁AServlet对象的内存。

      • 服务器在销毁AServlet对象内存之前，Tomcat服务器会自动调用AServlet对象的destroy方法。

  • 请问：destroy方法调用的时候，对象销毁了还是没有销毁呢？

    • destroy方法执行的时候AServlet对象还在，没有被销毁。destroy方法执行结束之后，AServlet对象的内存才会被Tomcat释放。

  • Servlet对象更像一个人的一生：

    • Servlet的无参数构造方法执行：标志着你出生了。

    • Servlet对象的init方法的执行：标志着你正在接受教育。

    • Servlet对象的service方法的执行：标志着你已经开始工作了，已经开始为人类提供服务了。

    • Servlet对象的destroy方法的执行：标志着临终。有什么遗言，抓紧的。要不然，来不及了。

  • 关于Servlet类中方法的调用次数？

    • 构造方法只执行一次。

    • init方法只执行一次。

    • service方法：用户发送一次请求则执行一次，发送N次请求则执行N次。

    • destroy方法只执行一次。

  • 当我们Servlet类中编写一个有参数的构造方法，如果没有手动编写无参数构造方法会出现什么问题？

    • 报错了：500错误。

    • 注意：500是一个HTTP协议的错误状态码。

    • 500一般情况下是因为服务器端的Java程序出现了异常。（服务器端的错误都是500错误：服务器内部错误。）

    • 如果没有无参数的构造方法，会导致出现500错误，无法实例化Servlet对象。

    • 所以，一定要注意：在Servlet开发当中，不建议程序员来定义构造方法，因为定义不当，一不小心就会导致无法实例化Servlet对象。

  • 思考：Servlet的无参数构造方法是在对象第一次创建的时候执行，并且只执行一次。init方法也是在对象第一次创建的时候执行，并且只执行一次。那么这个无参数构造方法可以代替掉init方法吗？

    • 不能。

    • Servlet规范中有要求，作为javaweb程序员，编写Servlet类的时候，不建议手动编写构造方法，因为编写构造方法，很容易让无参数构造方法消失，这个操作可能会导致Servlet对象无法实例化。所以init方法是有存在的必要的。

  • init、service、destroy方法中使用最多的是哪个方法？

    • 使用最多就是service方法，service方法是一定要实现的，因为service方法是处理用户请求的核心方法。

    • 什么时候使用init方法呢？

      • init方法很少用。

      • 通常在init方法当中做初始化操作，并且这个初始化操作只需要执行一次。例如：初始化数据库连接池，初始化线程池....

    • 什么时候使用destroy方法呢？

      • destroy方法也很少用。

      • 通常在destroy方法当中，进行资源的关闭。马上对象要被销毁了，还有什么没有关闭的，抓紧时间关闭资源。还有什么资源没保存的，抓紧时间保存一下。

三、GenericServlet

1.我们编写一个Servlet类直接实现Servlet接口有什么缺点？

  • 我们只需要service方法，其他方法大部分情况下是不需要使用的。代码很丑陋。

接口MyInterface

package adapter;

public interface MyInterface {
    void m1();
    void m2();
    void m3();
    void m4();
    void m5();
    void m6();
    void m7();

    /**
     * 最常用的是这个方法。
     */
    void core();
}

CustomerService类
package adapter;

/**
 * 对于CustomerService来说，最主要的方法是m2
 */
public class CustomerService implements MyInterface{
    @Override
    public void m1() {

    }

    @Override
    public void m2() {
        System.out.println("CustomerService's m2 method execute!");
    }

    @Override
    public void m3() {

    }

    @Override
    public void m4() {

    }

    @Override
    public void m5() {

    }

    @Override
    public void m6() {

    }

    @Override
    public void m7() {

    }

    @Override
    public void core() {

    }
}
CustomerService2类
package adapter;

/**
 * 对于CustomerService2来说，最主要的方法是m2
 */
public class CustomerService2 implements MyInterface{
    @Override
    public void m1() {

    }

    @Override
    public void m2() {
        System.out.println("CustomerService2's m2 method execute!");
    }

    @Override
    public void m3() {

    }

    @Override
    public void m4() {

    }

    @Override
    public void m5() {

    }

    @Override
    public void m6() {

    }

    @Override
    public void m7() {

    }

    @Override
    public void core() {

    }
}
UserService类
package adapter;

/**
 * 对于UserService来说，core方法是最主要的方法。
 */
public class UserService implements MyInterface{
    @Override
    public void m1() {

    }

    @Override
    public void m2() {

    }

    @Override
    public void m3() {

    }

    @Override
    public void m4() {

    }

    @Override
    public void m5() {

    }

    @Override
    public void m6() {

    }

    @Override
    public void m7() {

    }

    @Override
    public void core() {
        System.out.println("UserService's core method execute!");
    }
}
UserService2类
package adapter;

/**
 * 对于UserService2来说，core方法是最主要的方法。
 */
public class UserService2 implements MyInterface{
    @Override
    public void m1() {

    }

    @Override
    public void m2() {

    }

    @Override
    public void m3() {

    }

    @Override
    public void m4() {

    }

    @Override
    public void m5() {

    }

    @Override
    public void m6() {

    }

    @Override
    public void m7() {

    }

    @Override
    public void core() {
        System.out.println("UserService2's core method execute!");
    }
}

2.适配器设计模式Adapter

  • 手机直接插到220V的电压上，手机直接就报废了。怎么办？可以找一个充电器。这个充电器就是一个适配器。手机连接适配器。适配器连接220V的电压。这样问题就解决了。

接口MyInterface

package adapter2;

public interface MyInterface {
    void m1();
    void m2();
    void m3();
    void m4();
    void m5();
    void m6();
    void m7();
    void core();
}
CustomerService专用的适配器
package adapter2;

/**
 * CustomerService专用的适配器。
 */
public abstract class CustomerAdapter implements MyInterface {
    @Override
    public void m1() {

    }

    public abstract void m2() ;

    @Override
    public void m3() {

    }

    @Override
    public void m4() {

    }

    @Override
    public void m5() {

    }

    @Override
    public void m6() {

    }

    @Override
    public void m7() {

    }

    @Override
    public void core() {

    }
}

CustomerService类

package adapter2;

public class CustomerService extends CustomerAdapter{
    @Override
    public void m2() {

    }
}
UserService类的适配器
package adapter2;

// UserService类的适配器。
public abstract class UserAdapter implements MyInterface {
    @Override
    public void m1() {

    }

    @Override
    public void m2() {

    }

    @Override
    public void m3() {

    }

    @Override
    public void m4() {

    }

    @Override
    public void m5() {

    }

    @Override
    public void m6() {

    }

    @Override
    public void m7() {

    }

    public abstract void core();
}

UserService

package adapter2;

public class UserService extends UserAdapter {
    @Override
    public void core() {

    }
}

3.编写一个GenericServlet类，这个类是一个抽象类，其中有一个抽象方法service。

  • GenericServlet实现Servlet接口。

  • GenericServlet是一个适配器。

  • 以后编写的所有Servlet类继承GenericServlet，重写service方法即可。

GenericServlet类
package oop1;

import jakarta.servlet.*;

import java.io.IOException;

/**
 * 编写一个标准通用的Servlet，起名：GenericServlet
 * 以后所有的Servlet类都不要直接实现Servlet接口了。
 * 以后所有的Servlet类都要继承GenericServlet类。
 * GenericServlet 就是一个适配器。
 */
public abstract class GenericServlet implements Servlet {

@Override
public void init(ServletConfig servletConfig) throws ServletException{
    System.out.println("servletConfig对象，小猫咪创建好的：" + servletConfig);
}

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    /**
     * 抽象方法，这个方法最常用。所以要求子类必须实现service方法。
     * @param servletRequest
     * @param servletResponse
     * @throws ServletException
     * @throws IOException
     */
    public abstract void service(ServletRequest servletRequest, ServletResponse servletResponse)
            throws ServletException, IOException;

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {

    }
}
LoginServlet类
package oop1;

import jakarta.servlet.ServletConfig;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;

import java.io.IOException;

public class LoginServlet extends GenericServlet{





    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("正在处理用户登录请求，请稍后。。。。。");



    }
}
VipServlet 类
package oop1;

import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;

import java.io.IOException;

public class VipServlet extends GenericServlet{
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("Vip可以享受更好的服务。。。。。");
    }
}

运行结果：

4.思考：GenericServlet类是否需要改造一下？怎么改造？更利于子类程序的编写？

  • 思考第一个问题：我提供了一个GenericServlet之后，init方法还会执行吗？

    • 还会执行。会执行GenericServlet类中的init方法。

  • 思考第二个问题：init方法是谁调用的？

    • Tomcat服务器调用的。

  • 思考第三个问题：init方法中的ServletConfig对象是谁创建的？是谁传过来的？

    • 都是Tomcat干的。

    • Tomcat服务器先创建了ServletConfig对象，然后调用init方法，将ServletConfig对象传给了init方法。

  • 思考一下Tomcat服务器伪代码：

public class Tomcat {
    public static void main(String[] args){
        // .....
        // Tomcat服务器伪代码
        // 创建LoginServlet对象（通过反射机制，调用无参数构造方法来实例化LoginServlet对象）
        Class clazz = Class.forName("oop1.LoginServlet");
        Object obj = clazz.newInstance();
        
        // 向下转型
        Servlet servlet = (Servlet)obj;
        
        // 创建ServletConfig对象
        // Tomcat服务器负责将ServletConfig对象实例化出来。
        // 多态（Tomcat服务器完全实现了Servlet规范）
        ServletConfig servletConfig = new org.apache.catalina.core.StandardWrapperFacade();
        
        // 调用Servlet的init方法
        servlet.init(servletConfig);
        
        // 调用Servlet的service方法
        // ....
        
    }
}

如何保证servletConfig不仅可以在init方法中用，但是

init方法中的ServletConfig对象是小猫咪创建好的。
* 这个ServletConfig对象目前在init方法的参数上，属于局部变量。
那么ServletConfig对象肯定以后要在service方法中使用，怎么才能保证ServletConfig对象在service方法中能够使用呢？

答：使用成员变量

改造GenericServlet代码：

package oop1;

import jakarta.servlet.*;

import java.io.IOException;

/**
 * 编写一个标准通用的Servlet，起名：GenericServlet
 * 以后所有的Servlet类都不要直接实现Servlet接口了。
 * 以后所有的Servlet类都要继承GenericServlet类。
 * GenericServlet 就是一个适配器。
 */
public abstract class GenericServlet implements Servlet {

    // 成员变量
    private ServletConfig config;

    /**
     * init方法中的ServletConfig对象是小猫咪创建好的。
     * 这个ServletConfig对象目前在init方法的参数上，属于局部变量。
     * 那么ServletConfig对象肯定以后要在service方法中使用，怎么才能保证ServletConfig对象在service方法中能够使用呢？
     */
    //加final是为了不让子类重写init

    @Override
    public final void init(ServletConfig config) throws ServletException {
        //System.out.println("servletConfig对象，小猫咪创建好的：" + config);
        this.config = config;
        // 调用init()方法
        this.init();
    }

    /**
     * 这个init方法是供子类重写的。
     */
    public void init(){

    }

    @Override
    public ServletConfig getServletConfig() {
        return config;
    }

    /**
     * 抽象方法，这个方法最常用。所以要求子类必须实现service方法。
     * @param servletRequest
     * @param servletResponse
     * @throws ServletException
     * @throws IOException
     */
    public abstract void service(ServletRequest servletRequest, ServletResponse servletResponse)
            throws ServletException, IOException;

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {

    }
}

改造的LoginServlet代码

package oop1;

import jakarta.servlet.ServletConfig;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;

import java.io.IOException;

public class LoginServlet extends GenericServlet{


    // 思考一个问题：
    // 有没有一种可能，需要我在LoginServlet类中重写init方法？
    // 当然有可能，于是乎就重写了init方法。
    /*public void init(ServletConfig config) throws ServletException {
        System.out.println("重写我自己的规则。。。。。");
    }*/

    // 父类将原始的init方法final了，我子类没有办法重写这个init方法了。
    // 如果这个时候我还是希望能够重写init方法，该怎么办呢？
    @Override
    public void init(){
        System.out.println("LoginServlet's init() method execute!");
    }


    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("正在处理用户登录请求，请稍后。。。。。");

        // 想在LoginServlet子类中使用ServletConfig对象怎么办？
        ServletConfig config = this.getServletConfig();
        System.out.println("service方法中是否可以获取到ServletConfig对象？" + config);

    }
}

运行结果：

四、ServletConfig接口详解

1.


ServletConfig
*   1. ServletConfig是什么？
*      jakarta.servlet.ServletConfig
*      显然ServletConfig是Servlet规范中的一员。
*      ServletConfig是一个接口。（jakarta.servlet.Servlet是一个接口。）
*   2. 谁去实现了这个接口呢？ WEB服务器实现了
*      public class org.apache.catalina.core.StandardWrapperFacade implements ServletConfig {}
*      结论：Tomcat服务器实现了ServletConfig接口。
*      思考：如果把Tomcat服务器换成jetty服务器，输出ServletConfig对象的时候，还是这个结果吗？
*          不一定一样，包名类名可能和Tomcat不一样。但是他们都实现了ServletConfig这个规范。
ConfigTestServlet 类
package oop1;

import jakarta.servlet.*;

import java.io.IOException;
import java.io.PrintWriter;

/*
* ServletConfig
 *   1. ServletConfig是什么？
 *      jakarta.servlet.ServletConfig
 *      显然ServletConfig是Servlet规范中的一员。
 *      ServletConfig是一个接口。（jakarta.servlet.Servlet是一个接口。）
 *   2. 谁去实现了这个接口呢？ WEB服务器实现了
 *      public class org.apache.catalina.core.StandardWrapperFacade implements ServletConfig {}
 *      结论：Tomcat服务器实现了ServletConfig接口。
 *      思考：如果把Tomcat服务器换成jetty服务器，输出ServletConfig对象的时候，还是这个结果吗？
 *          不一定一样，包名类名可能和Tomcat不一样。但是他们都实现了ServletConfig这个规范。
* */
public class ConfigTestServlet extends GenericServlet {
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        servletResponse.setContentType("text/html");
        PrintWriter out=servletResponse.getWriter();

        //获取ServletConfig对象
        ServletConfig config=this.getServletConfig();

        //输出该对象
        out.print("Servlet对象是"+config);
    }
}

运行结果：

2.

*   3. 一个Servlet对象中有一个ServletConfig对象。（Servlet和ServletConfig对象是一对一。）
*      100个Servlet，就应该有100个ServletConfig对象。
*   4. ServletConfig对象是谁创建的？在什么时候创建的？
*      Tomcat服务器（WEB服务器）创建了ServletConfig对象。
*      在创建Servlet对象的时候，同时创建ServletConfig对象。
*   5. ServletConfig接口到底是干啥的？有什么用呢？
*      Config是哪个单词的缩写？
*          Configuration
*      ServletConfig对象被翻译为：Servlet对象的配置信息对象。
*      一个Servlet对象就有一个配置信息对象。
*      两个Servlet对象就有两个配置信息对象。

验证：

ConfigTestServlet2类

package oop1;

import jakarta.servlet.*;

import java.io.IOException;
import java.io.PrintWriter;

public class ConfigTestServlet2 extends GenericServlet {
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        servletResponse.setContentType("text/html");
        PrintWriter out=servletResponse.getWriter();

        //获取ServletConfig对象
        ServletConfig config=this.getServletConfig();

        //输出该对象
        out.print("Servlet对象是"+config);
    }
}

运行结果：

可以看到重启服务器后，2个ServletConfig对象的地址不一致

3.

6. ServletConfig对象中到底包装了什么信息呢？

package oop1;

import jakarta.servlet.*;

import java.io.IOException;
import java.io.PrintWriter;

/*
* ServletConfig
 *   1. ServletConfig是什么？
 *      jakarta.servlet.ServletConfig
 *      显然ServletConfig是Servlet规范中的一员。
 *      ServletConfig是一个接口。（jakarta.servlet.Servlet是一个接口。）
 *   2. 谁去实现了这个接口呢？ WEB服务器实现了
 *      public class org.apache.catalina.core.StandardWrapperFacade implements ServletConfig {}
 *      结论：Tomcat服务器实现了ServletConfig接口。
 *      思考：如果把Tomcat服务器换成jetty服务器，输出ServletConfig对象的时候，还是这个结果吗？
 *          不一定一样，包名类名可能和Tomcat不一样。但是他们都实现了ServletConfig这个规范。
 *
 *  *   3. 一个Servlet对象中有一个ServletConfig对象。（Servlet和ServletConfig对象是一对一。）
 *      100个Servlet，就应该有100个ServletConfig对象。
 *   4. ServletConfig对象是谁创建的？在什么时候创建的？
 *      Tomcat服务器（WEB服务器）创建了ServletConfig对象。
 *      在创建Servlet对象的时候，同时创建ServletConfig对象。
 *   5. ServletConfig接口到底是干啥的？有什么用呢？
 *      Config是哪个单词的缩写？
 *          Configuration
 *      ServletConfig对象被翻译为：Servlet对象的配置信息对象。
 *      一个Servlet对象就有一个配置信息对象。
 *      两个Servlet对象就有两个配置信息对象。
* */
public class ConfigTestServlet extends GenericServlet {
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        servletResponse.setContentType("text/html");
        PrintWriter out=servletResponse.getWriter();

        //获取ServletConfig对象
        ServletConfig config=this.getServletConfig();

        //输出该对象
        out.print("Servlet对象是"+config);

        out.print("<br>");

        // 获取<servlet-name></servlet-name>
        String servletName = config.getServletName();
        out.print("<servlet-name>"+servletName+"</servlet-name>");
        out.print("<br>");
    }
}

sevlet初始化参数信息

<?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">

    <servlet>
        <servlet-name>config2</servlet-name>
        <servlet-class>oop1.ConfigTestServlet</servlet-class>
        <!--<load-on-startup>0</load-on-startup>-->
    </servlet>
    <servlet-mapping>
        <servlet-name>config2</servlet-name>
        <url-pattern>/con2</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>config</servlet-name>
        <servlet-class>oop1.ConfigTestServlet</servlet-class>
        <!--<load-on-startup>0</load-on-startup>-->
        <!--这里是可以配置一个Servlet对象的初始化信息的。-->
        <init-param>
            <param-name>driver</param-name>
            <param-value>com.mysql.cj.jdbc.Driver</param-value>
        </init-param>
        <init-param>
            <param-name>url</param-name>
            <param-value>jdbc:mysql://localhost:3306/bjpowernode</param-value>
        </init-param>
        <init-param>
            <param-name>user</param-name>
            <param-value>root</param-value>
        </init-param>
        <init-param>
            <param-name>password</param-name>
            <param-value>abc123</param-value>
        </init-param>


        
    </servlet>
    <servlet-mapping>
        <servlet-name>config</servlet-name>
        <url-pattern>/con</url-pattern>
    </servlet-mapping>
</web-app>

4.

*   6. ServletConfig对象中到底包装了什么信息呢？
*      <servlet>
*         <servlet-name>configTest</servlet-name>
*         <servlet-class>com.bjpowernode.javaweb.servlet.ConfigTestServlet</servlet-class>
*     </servlet>
*     ServletConfig对象中包装的信息是：
*          web.xml文件中<servlet></servlet>标签的配置信息。
*
*     Tomcat小猫咪解析web.xml文件，将web.xml文件中<servlet></servlet>标签中的配置信息自动包装到ServletConfig对象中。
*
*   7. ServletConfig接口中有哪些方法？
*      <servlet>
*         <servlet-name>configTest</servlet-name>
*         <servlet-class>com.bjpowernode.javaweb.servlet.ConfigTestServlet</servlet-class>
*         <!--这里是可以配置一个Servlet对象的初始化信息的。-->
*         <init-param>
*             <param-name>driver</param-name>
*             <param-value>com.mysql.cj.jdbc.Driver</param-value>
*         </init-param>
*         <init-param>
*             <param-name>url</param-name>
*             <param-value>jdbc:mysql://localhost:3306/bjpowernode</param-value>
*         </init-param>
*         <init-param>
*             <param-name>user</param-name>
*             <param-value>root</param-value>
*         </init-param>
*         <init-param>
*             <param-name>password</param-name>
*             <param-value>root1234</param-value>
*         </init-param>
*     </servlet>
*     以上<servlet></servlet>标签中的<init-param></init-param>是初始化参数。这个初始化参数信息会自动被小猫咪封装到ServletConfig对象当中

ConfigTestServlet类：

package oop1;

import jakarta.servlet.*;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;

/*
* ServletConfig
 *   1. ServletConfig是什么？
 *      jakarta.servlet.ServletConfig
 *      显然ServletConfig是Servlet规范中的一员。
 *      ServletConfig是一个接口。（jakarta.servlet.Servlet是一个接口。）
 *   2. 谁去实现了这个接口呢？ WEB服务器实现了
 *      public class org.apache.catalina.core.StandardWrapperFacade implements ServletConfig {}
 *      结论：Tomcat服务器实现了ServletConfig接口。
 *      思考：如果把Tomcat服务器换成jetty服务器，输出ServletConfig对象的时候，还是这个结果吗？
 *          不一定一样，包名类名可能和Tomcat不一样。但是他们都实现了ServletConfig这个规范。
 *
 *  *   3. 一个Servlet对象中有一个ServletConfig对象。（Servlet和ServletConfig对象是一对一。）
 *      100个Servlet，就应该有100个ServletConfig对象。
 *   4. ServletConfig对象是谁创建的？在什么时候创建的？
 *      Tomcat服务器（WEB服务器）创建了ServletConfig对象。
 *      在创建Servlet对象的时候，同时创建ServletConfig对象。
 *   5. ServletConfig接口到底是干啥的？有什么用呢？
 *      Config是哪个单词的缩写？
 *          Configuration
 *      ServletConfig对象被翻译为：Servlet对象的配置信息对象。
 *      一个Servlet对象就有一个配置信息对象。
 *      两个Servlet对象就有两个配置信息对象。
 * *   6. ServletConfig对象中到底包装了什么信息呢？
 *      <servlet>
 *         <servlet-name>configTest</servlet-name>
 *         <servlet-class>com.bjpowernode.javaweb.servlet.ConfigTestServlet</servlet-class>
 *     </servlet>
 *     ServletConfig对象中包装的信息是：
 *          web.xml文件中<servlet></servlet>标签的配置信息。
 *
 *     Tomcat小猫咪解析web.xml文件，将web.xml文件中<servlet></servlet>标签中的配置信息自动包装到ServletConfig对象中。
 *
 *   7. ServletConfig接口中有哪些方法？
 *      <servlet>
 *         <servlet-name>configTest</servlet-name>
 *         <servlet-class>com.bjpowernode.javaweb.servlet.ConfigTestServlet</servlet-class>
 *         <!--这里是可以配置一个Servlet对象的初始化信息的。-->
 *         <init-param>
 *             <param-name>driver</param-name>
 *             <param-value>com.mysql.cj.jdbc.Driver</param-value>
 *         </init-param>
 *         <init-param>
 *             <param-name>url</param-name>
 *             <param-value>jdbc:mysql://localhost:3306/bjpowernode</param-value>
 *         </init-param>
 *         <init-param>
 *             <param-name>user</param-name>
 *             <param-value>root</param-value>
 *         </init-param>
 *         <init-param>
 *             <param-name>password</param-name>
 *             <param-value>root1234</param-value>
 *         </init-param>
 *     </servlet>
 *     以上<servlet></servlet>标签中的<init-param></init-param>是初始化参数。这个初始化参数信息会自动被小猫咪封装到ServletConfig对象当中
* */
public class ConfigTestServlet extends GenericServlet {
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        servletResponse.setContentType("text/html");
        PrintWriter out=servletResponse.getWriter();

        //获取ServletConfig对象
        ServletConfig config=this.getServletConfig();

        //输出该对象
        out.print("Servlet对象是"+config);

        out.print("<br>");

        // 获取<servlet-name></servlet-name>
        String servletName = config.getServletName();
        out.print("<servlet-name>"+servletName+"</servlet-name>");
        out.print("<br>");

        // 通过ServletConfig对象的两个方法，可以获取到web.xml文件中的初始化参数配置信息。
        // java.util.Enumeration<java.lang.String>	getInitParameterNames() 获取所有的初始化参数的name
        Enumeration<String> initParameterNames = config.getInitParameterNames();
        // 遍历集合
        while(initParameterNames.hasMoreElements()) { // 是否有更多元素
            String parameterName = initParameterNames.nextElement(); // 取元素
            String parameterVal = config.getInitParameter(parameterName); // 通过name获取value
            out.print(parameterName + "=" + parameterVal);
            out.print("<br>");
        }
        // java.lang.String	getInitParameter(java.lang.String name) 通过初始化参数的name获取value
        /*String driver = config.getInitParameter("driver");
        out.print(driver);*/


    }
}

ConfigTestServlet2类：

package oop1;

import jakarta.servlet.*;

import java.io.IOException;
import java.io.PrintWriter;

public class ConfigTestServlet2 extends GenericServlet {
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        servletResponse.setContentType("text/html");
        PrintWriter out=servletResponse.getWriter();

        //获取ServletConfig对象
        ServletConfig config=this.getServletConfig();

        //输出该对象
        out.print("Servlet对象是"+config);



        String value = config.getInitParameter("key");
        out.print("<br>" + value);
    }
}

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">

    <servlet>
        <servlet-name>config2</servlet-name>
        <servlet-class>oop1.ConfigTestServlet</servlet-class>
        <!--<load-on-startup>0</load-on-startup>-->
        <init-param>
            <param-name>driver2</param-name>
            <param-value>com.mysql.cj.jdbc.Driver2</param-value>
        </init-param>
        <init-param>
            <param-name>url</param-name>
            <param-value>jdbc:mysql://localhost:3306/bjpowernode2</param-value>
        </init-param>
        <init-param>
            <param-name>user2</param-name>
            <param-value>root2</param-value>
        </init-param>
        <init-param>
            <param-name>password2</param-name>
            <param-value>abc123</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>config2</servlet-name>
        <url-pattern>/con2</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>config</servlet-name>
        <servlet-class>oop1.ConfigTestServlet</servlet-class>
        <!--<load-on-startup>0</load-on-startup>-->
        <!--这里是可以配置一个Servlet对象的初始化信息的。-->
        <init-param>
            <param-name>driver</param-name>
            <param-value>com.mysql.cj.jdbc.Driver</param-value>
        </init-param>
        <init-param>
            <param-name>url</param-name>
            <param-value>jdbc:mysql://localhost:3306/bjpowernode</param-value>
        </init-param>
        <init-param>
            <param-name>user</param-name>
            <param-value>root</param-value>
        </init-param>
        <init-param>
            <param-name>password</param-name>
            <param-value>abc123</param-value>
        </init-param>



    </servlet>
    <servlet-mapping>
        <servlet-name>config</servlet-name>
        <url-pattern>/con</url-pattern>
    </servlet-mapping>
</web-app>

上面代码照旧，ConfigTestServlet代码添加如下

package oop1;

import jakarta.servlet.*;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;

/*
* ServletConfig
 *   1. ServletConfig是什么？
 *      jakarta.servlet.ServletConfig
 *      显然ServletConfig是Servlet规范中的一员。
 *      ServletConfig是一个接口。（jakarta.servlet.Servlet是一个接口。）
 *   2. 谁去实现了这个接口呢？ WEB服务器实现了
 *      public class org.apache.catalina.core.StandardWrapperFacade implements ServletConfig {}
 *      结论：Tomcat服务器实现了ServletConfig接口。
 *      思考：如果把Tomcat服务器换成jetty服务器，输出ServletConfig对象的时候，还是这个结果吗？
 *          不一定一样，包名类名可能和Tomcat不一样。但是他们都实现了ServletConfig这个规范。
 *
 *  *   3. 一个Servlet对象中有一个ServletConfig对象。（Servlet和ServletConfig对象是一对一。）
 *      100个Servlet，就应该有100个ServletConfig对象。
 *   4. ServletConfig对象是谁创建的？在什么时候创建的？
 *      Tomcat服务器（WEB服务器）创建了ServletConfig对象。
 *      在创建Servlet对象的时候，同时创建ServletConfig对象。
 *   5. ServletConfig接口到底是干啥的？有什么用呢？
 *      Config是哪个单词的缩写？
 *          Configuration
 *      ServletConfig对象被翻译为：Servlet对象的配置信息对象。
 *      一个Servlet对象就有一个配置信息对象。
 *      两个Servlet对象就有两个配置信息对象。
 * *   6. ServletConfig对象中到底包装了什么信息呢？
 *      <servlet>
 *         <servlet-name>configTest</servlet-name>
 *         <servlet-class>com.bjpowernode.javaweb.servlet.ConfigTestServlet</servlet-class>
 *     </servlet>
 *     ServletConfig对象中包装的信息是：
 *          web.xml文件中<servlet></servlet>标签的配置信息。
 *
 *     Tomcat小猫咪解析web.xml文件，将web.xml文件中<servlet></servlet>标签中的配置信息自动包装到ServletConfig对象中。
 *
 *   7. ServletConfig接口中有哪些方法？
 *      <servlet>
 *         <servlet-name>configTest</servlet-name>
 *         <servlet-class>com.bjpowernode.javaweb.servlet.ConfigTestServlet</servlet-class>
 *         <!--这里是可以配置一个Servlet对象的初始化信息的。-->
 *         <init-param>
 *             <param-name>driver</param-name>
 *             <param-value>com.mysql.cj.jdbc.Driver</param-value>
 *         </init-param>
 *         <init-param>
 *             <param-name>url</param-name>
 *             <param-value>jdbc:mysql://localhost:3306/bjpowernode</param-value>
 *         </init-param>
 *         <init-param>
 *             <param-name>user</param-name>
 *             <param-value>root</param-value>
 *         </init-param>
 *         <init-param>
 *             <param-name>password</param-name>
 *             <param-value>root1234</param-value>
 *         </init-param>
 *     </servlet>
 *     以上<servlet></servlet>标签中的<init-param></init-param>是初始化参数。这个初始化参数信息会自动被小猫咪封装到ServletConfig对象当中
* */
public class ConfigTestServlet extends GenericServlet {
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        servletResponse.setContentType("text/html");
        PrintWriter out=servletResponse.getWriter();

        //获取ServletConfig对象
        ServletConfig config=this.getServletConfig();

        //输出该对象
        out.print("Servlet对象是"+config);

        out.print("<br>");

        // 获取<servlet-name></servlet-name>
        String servletName = config.getServletName();
        out.print("<servlet-name>"+servletName+"</servlet-name>");
        out.print("<br>");

        // 通过ServletConfig对象的两个方法，可以获取到web.xml文件中的初始化参数配置信息。
        // java.util.Enumeration<java.lang.String>	getInitParameterNames() 获取所有的初始化参数的name
        Enumeration<String> initParameterNames = config.getInitParameterNames();
        // 遍历集合
        while(initParameterNames.hasMoreElements()) { // 是否有更多元素
            String parameterName = initParameterNames.nextElement(); // 取元素
            String parameterVal = config.getInitParameter(parameterName); // 通过name获取value
            out.print(parameterName + "=" + parameterVal);
            out.print("<br>");
        }
        // java.lang.String	getInitParameter(java.lang.String name) 通过初始化参数的name获取value
        /*String driver = config.getInitParameter("driver");
        out.print(driver);*/


        // 实际上获取一个Servlet对象的初始化参数，可以不用获取ServletConfig对象。直接通过this也可以。
        Enumeration<String> names = this.getInitParameterNames();
        while(names.hasMoreElements()){
            String name = names.nextElement();
            String value = this.getInitParameter(name);
            // 打印到后台
            System.out.println(name + "=" + value);
        }




    }
}

5.

  8. ServletConfig接口中有4个方法：
*      第1个方法：
*          public String getInitParameter(String name);
*      第2个方法：
*          public Enumeration<String> getInitParameterNames();
*      第3个方法：
*          public ServletContext getServletContext();
*      第4个方法：
*          public String getServletName();
*
*      以上的4个方法，在自己编写的Servlet类当中也可以使用this去调用。（这个Servlet继承了GenericServlet）

上面代码照旧，ConfigTestServlet代码添加如下

package oop1;

import jakarta.servlet.*;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;

/*
* ServletConfig
 *   1. ServletConfig是什么？
 *      jakarta.servlet.ServletConfig
 *      显然ServletConfig是Servlet规范中的一员。
 *      ServletConfig是一个接口。（jakarta.servlet.Servlet是一个接口。）
 *   2. 谁去实现了这个接口呢？ WEB服务器实现了
 *      public class org.apache.catalina.core.StandardWrapperFacade implements ServletConfig {}
 *      结论：Tomcat服务器实现了ServletConfig接口。
 *      思考：如果把Tomcat服务器换成jetty服务器，输出ServletConfig对象的时候，还是这个结果吗？
 *          不一定一样，包名类名可能和Tomcat不一样。但是他们都实现了ServletConfig这个规范。
 *
 *  *   3. 一个Servlet对象中有一个ServletConfig对象。（Servlet和ServletConfig对象是一对一。）
 *      100个Servlet，就应该有100个ServletConfig对象。
 *   4. ServletConfig对象是谁创建的？在什么时候创建的？
 *      Tomcat服务器（WEB服务器）创建了ServletConfig对象。
 *      在创建Servlet对象的时候，同时创建ServletConfig对象。
 *   5. ServletConfig接口到底是干啥的？有什么用呢？
 *      Config是哪个单词的缩写？
 *          Configuration
 *      ServletConfig对象被翻译为：Servlet对象的配置信息对象。
 *      一个Servlet对象就有一个配置信息对象。
 *      两个Servlet对象就有两个配置信息对象。
 * *   6. ServletConfig对象中到底包装了什么信息呢？
 *      <servlet>
 *         <servlet-name>configTest</servlet-name>
 *         <servlet-class>com.bjpowernode.javaweb.servlet.ConfigTestServlet</servlet-class>
 *     </servlet>
 *     ServletConfig对象中包装的信息是：
 *          web.xml文件中<servlet></servlet>标签的配置信息。
 *
 *     Tomcat小猫咪解析web.xml文件，将web.xml文件中<servlet></servlet>标签中的配置信息自动包装到ServletConfig对象中。
 *
 *   7. ServletConfig接口中有哪些方法？
 *      <servlet>
 *         <servlet-name>configTest</servlet-name>
 *         <servlet-class>com.bjpowernode.javaweb.servlet.ConfigTestServlet</servlet-class>
 *         <!--这里是可以配置一个Servlet对象的初始化信息的。-->
 *         <init-param>
 *             <param-name>driver</param-name>
 *             <param-value>com.mysql.cj.jdbc.Driver</param-value>
 *         </init-param>
 *         <init-param>
 *             <param-name>url</param-name>
 *             <param-value>jdbc:mysql://localhost:3306/bjpowernode</param-value>
 *         </init-param>
 *         <init-param>
 *             <param-name>user</param-name>
 *             <param-value>root</param-value>
 *         </init-param>
 *         <init-param>
 *             <param-name>password</param-name>
 *             <param-value>root1234</param-value>
 *         </init-param>
 *     </servlet>
 *     以上<servlet></servlet>标签中的<init-param></init-param>是初始化参数。这个初始化参数信息会自动被小猫咪封装到ServletConfig对象当中
* */
public class ConfigTestServlet extends GenericServlet {
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        servletResponse.setContentType("text/html");
        PrintWriter out=servletResponse.getWriter();

        //获取ServletConfig对象
        ServletConfig config=this.getServletConfig();

        //输出该对象
        out.print("Servlet对象是"+config);

        out.print("<br>");

        // 获取<servlet-name></servlet-name>
        String servletName = config.getServletName();
        out.print("<servlet-name>"+servletName+"</servlet-name>");
        out.print("<br>");

        // 通过ServletConfig对象的两个方法，可以获取到web.xml文件中的初始化参数配置信息。
        // java.util.Enumeration<java.lang.String>	getInitParameterNames() 获取所有的初始化参数的name
        Enumeration<String> initParameterNames = config.getInitParameterNames();
        // 遍历集合
        while(initParameterNames.hasMoreElements()) { // 是否有更多元素
            String parameterName = initParameterNames.nextElement(); // 取元素
            String parameterVal = config.getInitParameter(parameterName); // 通过name获取value
            out.print(parameterName + "=" + parameterVal);
            out.print("<br>");
        }
        // java.lang.String	getInitParameter(java.lang.String name) 通过初始化参数的name获取value
        /*String driver = config.getInitParameter("driver");
        out.print(driver);*/


        // 实际上获取一个Servlet对象的初始化参数，可以不用获取ServletConfig对象。直接通过this也可以。
        Enumeration<String> names = this.getInitParameterNames();
        while(names.hasMoreElements()){
            String name = names.nextElement();
            String value = this.getInitParameter(name);
            // 打印到后台
            System.out.println(name + "=" + value);
        }

        // 怎么获取ServletContext对象呢？
        // 第一种方式：通过ServletConfig对象获取ServletContext对象。
        ServletContext application = config.getServletContext();
        // 输出
        out.print("<br>" + application); //org.apache.catalina.core.ApplicationContextFacade@19187bbb

        // 第二种方式：通过this也可以获取ServletContext对象。
        ServletContext application2 = this.getServletContext();
        out.print("<br>" + application2); //org.apache.catalina.core.ApplicationContextFacade@19187bbb


    }
}

  • 什么是ServletConfig？

    • Servlet对象的配置信息对象。

    • ServletConfig对象中封装了<servlet></servlet>标签中的配置信息。（web.xml文件中servlet的配置信息）

  • 一个Servlet对应一个ServletConfig对象。

  • Servlet对象是Tomcat服务器创建，并且ServletConfig对象也是Tomcat服务器创建。并且默认情况下，他们都是在用户发送第一次请求的时候创建。

  • Tomcat服务器调用Servlet对象的init方法的时候需要传一个ServletConfig对象的参数给init方法。

  • ServletConfig接口的实现类是Tomcat服务器给实现的。（Tomcat服务器说的就是WEB服务器。）

  • ServletConfig接口有哪些常用的方法？

public String getInitParameter(String name); // 通过初始化参数的name获取value
public Enumeration<String> getInitParameterNames(); // 获取所有的初始化参数的name
public ServletContext getServletContext(); // 获取ServletContext对象
public String getServletName(); // 获取Servlet的name

  • 以上方法在Servlet类当中，都可以使用this去调用。因为GenericServlet实现了ServletConfig接口。

五、ServletContext接口详解

1.

* ServletContext
* 1. ServletContext是什么？
*  ServletContext是接口，是Servlet规范中的一员。
* 2. ServletContext是谁实现的？
*  Tomcat服务器（WEB服务器）实现了ServletContext接口。
*  public class org.apache.catalina.core.ApplicationContextFacade implements ServletContext {}
* 3. ServletContext对象是谁创建的？在什么时候创建的？
*  ServletContext对象在WEB服务器启动的时候创建。
*  ServletContext对象是WEB服务器创建的。
*  对于一个webapp来说，ServletContext对象只有一个。
*  ServletContext对象在服务器关闭的时候销毁。
* 4. ServletContext怎么理解？
*  context是什么意思？
*      Servlet对象的环境对象。（Servlet对象的上下文对象。）
*  ServletContext对象其实对应的就是整个web.xml文件。
*  50个学生，每个学生都是一个Servlet，这50个学生都在同一个教室当中。那么这个教室就相当于ServletContext对象。
*  放在ServletContext对象当中的数据，所有Servlet一定是共享的。
*  比如：一个教室中的空调是所有学生共享的，一个教室中的语文老师是所有学生共享的。
*  Tomcat是一个容器，一个容器当中可以放多个webapp，一个webapp对应一个ServletContext对象。

AServlet 类

package oop1;

import jakarta.servlet.*;

import javax.swing.text.GapContent;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * ServletContext
 * 1. ServletContext是什么？
 *  ServletContext是接口，是Servlet规范中的一员。
 * 2. ServletContext是谁实现的？
 *  Tomcat服务器（WEB服务器）实现了ServletContext接口。
 *  public class org.apache.catalina.core.ApplicationContextFacade implements ServletContext {}
 * 3. ServletContext对象是谁创建的？在什么时候创建的？
 *  ServletContext对象在WEB服务器启动的时候创建。
 *  ServletContext对象是WEB服务器创建的。
 *  对于一个webapp来说，ServletContext对象只有一个。
 *  ServletContext对象在服务器关闭的时候销毁。
 * 4. ServletContext怎么理解？
 *  context是什么意思？
 *      Servlet对象的环境对象。（Servlet对象的上下文对象。）
 *  ServletContext对象其实对应的就是整个web.xml文件。
 *  50个学生，每个学生都是一个Servlet，这50个学生都在同一个教室当中。那么这个教室就相当于ServletContext对象。
 *  放在ServletContext对象当中的数据，所有Servlet一定是共享的。
 *  比如：一个教室中的空调是所有学生共享的，一个教室中的语文老师是所有学生共享的。
 *  Tomcat是一个容器，一个容器当中可以放多个webapp，一个webapp对应一个ServletContext对象。
 */
public class AServlet extends GenericServlet {
    @Override
    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {

        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        // 获取ServletContext对象
        ServletContext application = this.getServletContext();
        out.print("ServletContext对象是：" + application + "<br>");

    }
}

BServlet类

package oop1;

import jakarta.servlet.*;

import java.io.IOException;
import java.io.PrintWriter;

public class BServlet extends GenericServlet {
    @Override
    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        // 获取ServletContext对象
        ServletContext application = this.getServletContext();
        out.print("ServletContext对象是：" + application + "<br>");
    }
}

⑴. ServletContext 是什么？

  • ServletContext 是“Web应用的全局管家”：
    每个Web应用启动时，容器（如Tomcat）会创建一个ServletContext对象，它代表整个Web应用，所有Servlet共享同一个ServletContext。

  • 作用：
    用于存储全局配置（如web.xml中的参数）、共享数据（所有用户和Servlet都能访问）等。

⑵. 为什么两个Servlet输出的ServletContext对象相同？

  • 同一个Web应用，同一个ServletContext：
    只要AServlet和BServlet部署在同一个Web应用中，它们获取的ServletContext一定是同一个对象。

pom.xml是maven构建的相当于这里的lib

  • 一个Servlet对象对应一个ServletConfig。100个Servlet对象则对应100个ServletConfig对象。

  • 只要在同一个webapp当中，只要在同一个应用当中，所有的Servlet对象都是共享同一个ServletContext对象的。

  • ServletContext对象在服务器启动阶段创建，在服务器关闭的时候销毁。这就是ServletContext对象的生命周期。ServletContext对象是应用级对象。

  • Tomcat服务器中有一个webapps，这个webapps下可以存放webapp，可以存放多个webapp，假设有100个webapp，那么就有100个ServletContext对象。但是，总之，一个应用，一个webapp肯定是只有一个ServletContext对象。

  • ServletContext被称为Servlet上下文对象。（Servlet对象的四周环境对象。）

  • 一个ServletContext对象通常对应的是一个web.xml文件。

  • ServletContext对应显示生活中的什么例子呢？

    • 一个教室里有多个学生，那么每一个学生就是一个Servlet，这些学生都在同一个教室当中，那么我们可以把这个教室叫做ServletContext对象。那么也就是说放在这个ServletContext对象（环境）当中的数据，在同一个教室当中，物品都是共享的。比如：教室中有一个空调，所有的学生都可以操作。可见，空调是共享的。因为空调放在教室当中。教室就是ServletContext对象。

  • ServletContext是一个接口，Tomcat服务器对ServletContext接口进行了实现。

    • ServletContext对象的创建也是Tomcat服务器来完成的。启动webapp的时候创建的。

  • ServletContext接口中有哪些常用的方法？

public String getInitParameter(String name); // 通过初始化参数的name获取value
public Enumeration<String> getInitParameterNames(); // 获取所有的初始化参数的name

写在web-app中

<!--以上两个方法是ServletContext对象的方法，这个方法获取的是什么信息？是以下的配置信息-->
<context-param>
    <param-name>pageSize</param-name>
    <param-value>10</param-value>
</context-param>
<context-param>
    <param-name>startIndex</param-name>
    <param-value>0</param-value>
</context-param>
<!--注意：以上的配置信息属于应用级的配置信息，一般一个项目中共享的配置信息会放到以上的标签当中。-->
<!--如果你的配置信息只是想给某一个servlet作为参考，那么你配置到servlet标签当中即可，使用ServletConfig对象来获取。-->

AServlet类

package oop1;

import jakarta.servlet.*;

import javax.swing.text.GapContent;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;

/**
 * ServletContext
 * 1. ServletContext是什么？
 *  ServletContext是接口，是Servlet规范中的一员。
 * 2. ServletContext是谁实现的？
 *  Tomcat服务器（WEB服务器）实现了ServletContext接口。
 *  public class org.apache.catalina.core.ApplicationContextFacade implements ServletContext {}
 * 3. ServletContext对象是谁创建的？在什么时候创建的？
 *  ServletContext对象在WEB服务器启动的时候创建。
 *  ServletContext对象是WEB服务器创建的。
 *  对于一个webapp来说，ServletContext对象只有一个。
 *  ServletContext对象在服务器关闭的时候销毁。
 * 4. ServletContext怎么理解？
 *  context是什么意思？
 *      Servlet对象的环境对象。（Servlet对象的上下文对象。）
 *  ServletContext对象其实对应的就是整个web.xml文件。
 *  50个学生，每个学生都是一个Servlet，这50个学生都在同一个教室当中。那么这个教室就相当于ServletContext对象。
 *  放在ServletContext对象当中的数据，所有Servlet一定是共享的。
 *  比如：一个教室中的空调是所有学生共享的，一个教室中的语文老师是所有学生共享的。
 *  Tomcat是一个容器，一个容器当中可以放多个webapp，一个webapp对应一个ServletContext对象。
 */
public class AServlet extends GenericServlet {
    @Override
    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {

        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        // 获取ServletContext对象
        ServletContext application = this.getServletContext();
        out.print("ServletContext对象是：" + application + "<br>");


        // 获取上下文的初始化参数
        Enumeration<String> initParameterNames = application.getInitParameterNames();
        while(initParameterNames.hasMoreElements()){
            String name = initParameterNames.nextElement();
            String value = application.getInitParameter(name);
            out.print(name + "=" + value + "<br>");
        }

    }
}

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">

    <!--上下文的初始化参数，以下的这些配置信息，可以通过ServletContext对象来获取-->
    <context-param>
        <param-name>pageSize</param-name>
        <param-value>10</param-value>
    </context-param>
    <context-param>
        <param-name>startIndex</param-name>
        <param-value>0</param-value>
    </context-param>

    <servlet>
        <servlet-name>aservlet</servlet-name>
        <servlet-class>oop1.AServlet</servlet-class>
        <!--<load-on-startup>1</load-on-startup>-->
    </servlet>
    <servlet-mapping>
        <servlet-name>aservlet</servlet-name>
        <url-pattern>/a</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>bservlet</servlet-name>
        <servlet-class>oop1.BServlet</servlet-class>
        <!--<load-on-startup>0</load-on-startup>-->
    </servlet>
    <servlet-mapping>
        <servlet-name>bservlet</servlet-name>
        <url-pattern>/b</url-pattern>
    </servlet-mapping>


</web-app>

运行结果：

2.获取context path （获取应用上下文的根）（动态的获取）

// 获取应用的根路径（非常重要），因为在java源代码当中有一些地方可能会需要应用的根路径，这个方法可以动态获取应用的根路径
// 在java源码当中，不要将应用的根路径写死，因为你永远都不知道这个应用在最终部署的时候，起一个什么名字。

// 获取应用的根路径（非常重要），因为在java源代码当中有一些地方可能会需要应用的根路径，这个方法可以动态获取应用的根路径
// 在java源码当中，不要将应用的根路径写死，因为你永远都不知道这个应用在最终部署的时候，起一个什么名字。
public String getContextPath();
//String contextPath = application.getContextPath();

AServlet类添加代码如下，其他保持不变

package oop1;

import jakarta.servlet.*;

import javax.swing.text.GapContent;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;

/**
 * ServletContext
 * 1. ServletContext是什么？
 *  ServletContext是接口，是Servlet规范中的一员。
 * 2. ServletContext是谁实现的？
 *  Tomcat服务器（WEB服务器）实现了ServletContext接口。
 *  public class org.apache.catalina.core.ApplicationContextFacade implements ServletContext {}
 * 3. ServletContext对象是谁创建的？在什么时候创建的？
 *  ServletContext对象在WEB服务器启动的时候创建。
 *  ServletContext对象是WEB服务器创建的。
 *  对于一个webapp来说，ServletContext对象只有一个。
 *  ServletContext对象在服务器关闭的时候销毁。
 * 4. ServletContext怎么理解？
 *  context是什么意思？
 *      Servlet对象的环境对象。（Servlet对象的上下文对象。）
 *  ServletContext对象其实对应的就是整个web.xml文件。
 *  50个学生，每个学生都是一个Servlet，这50个学生都在同一个教室当中。那么这个教室就相当于ServletContext对象。
 *  放在ServletContext对象当中的数据，所有Servlet一定是共享的。
 *  比如：一个教室中的空调是所有学生共享的，一个教室中的语文老师是所有学生共享的。
 *  Tomcat是一个容器，一个容器当中可以放多个webapp，一个webapp对应一个ServletContext对象。
 */
public class AServlet extends GenericServlet {
    @Override
    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {

        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        // 获取ServletContext对象
        ServletContext application = this.getServletContext();
        out.print("ServletContext对象是：" + application + "<br>");


        // 获取上下文的初始化参数
        Enumeration<String> initParameterNames = application.getInitParameterNames();
        while(initParameterNames.hasMoreElements()){
            String name = initParameterNames.nextElement();
            String value = application.getInitParameter(name);
            out.print(name + "=" + value + "<br>");
        }


        // 获取context path （获取应用上下文的根）
        String contextPath = application.getContextPath();
        out.print(contextPath + "<br>");

    }
}

3.获取文件的绝对路径（真实路径）

// 获取文件的绝对路径（真实路径）
public String getRealPath(String path);

 AServlet类：

package oop1;

import jakarta.servlet.*;

import javax.swing.text.GapContent;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;

/**
 * ServletContext
 * 1. ServletContext是什么？
 *  ServletContext是接口，是Servlet规范中的一员。
 * 2. ServletContext是谁实现的？
 *  Tomcat服务器（WEB服务器）实现了ServletContext接口。
 *  public class org.apache.catalina.core.ApplicationContextFacade implements ServletContext {}
 * 3. ServletContext对象是谁创建的？在什么时候创建的？
 *  ServletContext对象在WEB服务器启动的时候创建。
 *  ServletContext对象是WEB服务器创建的。
 *  对于一个webapp来说，ServletContext对象只有一个。
 *  ServletContext对象在服务器关闭的时候销毁。
 * 4. ServletContext怎么理解？
 *  context是什么意思？
 *      Servlet对象的环境对象。（Servlet对象的上下文对象。）
 *  ServletContext对象其实对应的就是整个web.xml文件。
 *  50个学生，每个学生都是一个Servlet，这50个学生都在同一个教室当中。那么这个教室就相当于ServletContext对象。
 *  放在ServletContext对象当中的数据，所有Servlet一定是共享的。
 *  比如：一个教室中的空调是所有学生共享的，一个教室中的语文老师是所有学生共享的。
 *  Tomcat是一个容器，一个容器当中可以放多个webapp，一个webapp对应一个ServletContext对象。
 */
public class AServlet extends GenericServlet {
    @Override
    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {

        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        // 获取ServletContext对象
        ServletContext application = this.getServletContext();
        out.print("ServletContext对象是：" + application + "<br>");


        // 获取上下文的初始化参数
        Enumeration<String> initParameterNames = application.getInitParameterNames();
        while(initParameterNames.hasMoreElements()){
            String name = initParameterNames.nextElement();
            String value = application.getInitParameter(name);
            out.print(name + "=" + value + "<br>");
        }


        // 获取context path （获取应用上下文的根）
        String contextPath = application.getContextPath();
        out.print(contextPath + "<br>");




        // 获取文件的绝对路径
        // 后面的这个路径，加了一个“/”，这个“/”代表的是web的根
        String realPath = application.getRealPath("/index.html"); // 可以
        // 你不加“/”，默认也是从根下开始找。
        String realPath2 = application.getRealPath("index.html"); // 不加“/”也可以
        out.print(realPath + "<br>");
        out.print(realPath2 + "<br>");

        // D:\javadaima-heji\javadaima4\out\artifacts\Servlet04_war_exploded\common\common.html
       String realPath3 = application.getRealPath("/common/common.html");
        out.print(realPath3 + "<br>");

    }
}

4.通过ServletContext对象也是可以记录日志的

// 通过ServletContext对象也是可以记录日志的
public void log(String message);
public void log(String message, Throwable t);
// 这些日志信息记录到哪里了？
// localhost.2021-11-05.log

// Tomcat服务器的logs目录下都有哪些日志文件？
//catalina.2021-11-05.log 服务器端的java程序运行的控制台信息。
//localhost.2021-11-05.log ServletContext对象的log方法记录的日志信息存储到这个文件中。
//localhost_access_log.2021-11-05.txt 访问日志
package oop1;

import jakarta.servlet.*;

import javax.swing.text.GapContent;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;

/**
 * ServletContext
 * 1. ServletContext是什么？
 *  ServletContext是接口，是Servlet规范中的一员。
 * 2. ServletContext是谁实现的？
 *  Tomcat服务器（WEB服务器）实现了ServletContext接口。
 *  public class org.apache.catalina.core.ApplicationContextFacade implements ServletContext {}
 * 3. ServletContext对象是谁创建的？在什么时候创建的？
 *  ServletContext对象在WEB服务器启动的时候创建。
 *  ServletContext对象是WEB服务器创建的。
 *  对于一个webapp来说，ServletContext对象只有一个。
 *  ServletContext对象在服务器关闭的时候销毁。
 * 4. ServletContext怎么理解？
 *  context是什么意思？
 *      Servlet对象的环境对象。（Servlet对象的上下文对象。）
 *  ServletContext对象其实对应的就是整个web.xml文件。
 *  50个学生，每个学生都是一个Servlet，这50个学生都在同一个教室当中。那么这个教室就相当于ServletContext对象。
 *  放在ServletContext对象当中的数据，所有Servlet一定是共享的。
 *  比如：一个教室中的空调是所有学生共享的，一个教室中的语文老师是所有学生共享的。
 *  Tomcat是一个容器，一个容器当中可以放多个webapp，一个webapp对应一个ServletContext对象。
 */
public class AServlet extends GenericServlet {
    @Override
    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {

        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        // 获取ServletContext对象
        ServletContext application = this.getServletContext();
        out.print("ServletContext对象是：" + application + "<br>");


        // 获取上下文的初始化参数
        Enumeration<String> initParameterNames = application.getInitParameterNames();
        while(initParameterNames.hasMoreElements()){
            String name = initParameterNames.nextElement();
            String value = application.getInitParameter(name);
            out.print(name + "=" + value + "<br>");
        }


        // 获取context path （获取应用上下文的根）
        String contextPath = application.getContextPath();
        out.print(contextPath + "<br>");




        // 获取文件的绝对路径
        // 后面的这个路径，加了一个“/”，这个“/”代表的是web的根
        String realPath = application.getRealPath("/index.html"); // 可以
        // 你不加“/”，默认也是从根下开始找。
        String realPath2 = application.getRealPath("index.html"); // 不加“/”也可以
        out.print(realPath + "<br>");
        out.print(realPath2 + "<br>");

        // D:\javadaima-heji\javadaima4\out\artifacts\Servlet04_war_exploded\common\common.html
       String realPath3 = application.getRealPath("/common/common.html");
        out.print(realPath3 + "<br>");


        // 通过ServletContext对象也是可以记录日志的
        // 这些日志信息记录到哪里了？
        application.log("你好，世界");
        application.log("快乐星期");


    }
}

5.存（怎么向ServletContext应用域中存数据）

// ServletContext对象还有另一个名字：应用域（后面还有其他域，例如：请求域、会话域）

// 如果所有的用户共享一份数据，并且这个数据很少的被修改，并且这个数据量很少，可以将这些数据放到ServletContext这个应用域中

// 为什么是所有用户共享的数据？ 不是共享的没有意义。因为ServletContext这个对象只有一个。只有共享的数据放进去才有意义。

// 为什么数据量要小？ 因为数据量比较大的话，太占用堆内存，并且这个对象的生命周期比较长，服务器关闭的时候，这个对象才会被销毁。大数据量会影响服务器的性能。占用内存较小的数据量可以考虑放进去。

// 为什么这些共享数据很少的修改，或者说几乎不修改？
// 所有用户共享的数据，如果涉及到修改操作，必然会存在线程并发所带来的安全问题。所以放在ServletContext对象中的数据一般都是只读的。

// 数据量小、所有用户共享、又不修改，这样的数据放到ServletContext这个应用域当中，会大大提升效率。因为应用域相当于一个缓存，放到缓存中的数据，下次在用的时候，不需要从数据库中再次获取，大大提升执行效率。

// 存（怎么向ServletContext应用域中存数据）
public void setAttribute(String name, Object value); // map.put(k, v)
// 取（怎么从ServletContext应用域中取数据）
public Object getAttribute(String name); // Object v = map.get(k)
// 删（怎么删除ServletContext应用域中的数据）
public void removeAttribute(String name); // map.remove(k)

user类：

package oop1;

public class User {
    private String name;
    private String password;

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public User() {
    }

    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

在AServlet中添加如下代码

    // 准备数据
        User user = new User("jack", "123");
        // 向ServletContext应用域当中存储数据
        application.setAttribute("userObj", user);
        // 取出来
        Object userObj = application.getAttribute("userObj");
        // 输出到浏览器
        out.print(userObj + "<br>");

运行结果：

可以在AServlet中只添加如下代码

 // 准备数据
        User user = new User("jack", "123");
        // 向ServletContext应用域当中存储数据
        application.setAttribute("userObj", user);

在BServlet中添加

    // 取出来
        Object userObj = application.getAttribute("userObj");
        // 输出到浏览器
        out.print(userObj + "<br>");

运行结果：

先刷b为null

注意：以后我们编写Servlet类的时候，实际上是不会去直接继承GenericServlet类的，因为我们是B/S结构的系统，这种系统是基于HTTP超文本传输协议的，在Servlet规范当中，提供了一个类叫做HttpServlet，它是专门为HTTP协议准备的一个Servlet类。我们编写的Servlet类要继承HttpServlet。（HttpServlet是HTTP协议专用的。）使用HttpServlet处理HTTP协议更便捷。但是你需要直到它的继承结构：

jakarta.servlet.Servlet（接口）【爷爷】
jakarta.servlet.GenericServlet implements Servlet（抽象类）【儿子】
jakarta.servlet.http.HttpServlet extends GenericServlet（抽象类）【孙子】

我们以后编写的Servlet要继承HttpServlet类。

  • 大家到目前为止都接触过哪些缓存机制了？

    • 堆内存当中的字符串常量池。

      • "abc" 先在字符串常量池中查找，如果有，直接拿来用。如果没有则新建，然后再放入字符串常量池。

    • 堆内存当中的整数型常量池。

      • [-128 ~ 127] 一共256个Integer类型的引用，放在整数型常量池中。没有超出这个范围的话，直接从常量池中取。

    • 连接池(Connection Cache)

      • 这里所说的连接池中的连接是java语言连接数据库的连接对象：java.sql.Connection对象。

      • JVM是一个进程。MySQL数据库是一个进程。进程和进程之间建立连接，打开通道是很费劲的。是很耗费资源的。怎么办？可以提前先创建好N个Connection连接对象，将连接对象放到一个集合当中，我们把这个放有Connection对象的集合称为连接池。每一次用户连接的时候不需要再新建连接对象，省去了新建的环节，直接从连接池中获取连接对象，大大提升访问效率。

      • 连接池

        • 最小连接数

        • 最大连接数

        • 连接池可以提高用户的访问效率。当然也可以保证数据库的安全性。

    • 线程池

      • Tomcat服务器本身就是支持多线程的。

      • Tomcat服务器是在用户发送一次请求，就新建一个Thread线程对象吗？

        • 当然不是，实际上是在Tomcat服务器启动的时候，会先创建好N多个线程Thread对象，然后将线程对象放到集合当中，称为线程池。用户发送请求过来之后，需要有一个对应的线程来处理这个请求，这个时候线程对象就会直接从线程池中拿，效率比较高。

        • 所有的WEB服务器，或者应用服务器，都是支持多线程的，都有线程池机制。

    • redis

      • NoSQL数据库。非关系型数据库。缓存数据库。

    • 向ServletContext应用域中存储数据，也等于是将数据存放到缓存cache当中了。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2323293.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

将网络安全和第三方风险管理与业务目标相结合

将网络安全和第三方风险管理与业务目标相结合

在网络安全风险领域&#xff0c;我们经常遇到与企业语言不通的问题。这可能导致网络安全风险管理计划得不到支持。当发现网络安全风险时&#xff0c;困难在于以符合组织语言和目标的方式来表达它。 第三方风险属于另一个灰色地带。在组织内部&#xff0c;许多利益相关者&#…
阅读更多...
NO.58十六届蓝桥杯备战|基础算法-枚举|普通枚举|二进制枚举|铺地毯|回文日期|扫雷|子集|费解的开关|Even Parity(C++)

NO.58十六届蓝桥杯备战|基础算法-枚举|普通枚举|二进制枚举|铺地毯|回文日期|扫雷|子集|费解的开关|Even Parity(C++)

枚举 顾名思义&#xff0c;就是把所有情况全都罗列出来&#xff0c;然后找出符合题⽬要求的那⼀个。因此&#xff0c;枚举是⼀种纯暴⼒的算法。 ⼀般情况下&#xff0c;枚举策略都是会超时的。此时要先根据题⽬的数据范围来判断暴⼒枚举是否可以通过。 使⽤枚举策略时&#xf…
阅读更多...
Python正则表达式（二）

Python正则表达式（二）

目录 六、re.findall()函数和分组 1、0/1分组情况 2、多分组情况 七、或“|”的用法 1、作用域 2、用法 八、贪婪模式和懒惰模式 1、量词的贪婪模式 2、量词的懒惰模式 九、匹配对象 1、相关函数 六、re.findall()函数和分组 1、0/1分组情况 在正则表达式中&#x…
阅读更多...
图解AUTOSAR_SWS_FlashDriver

图解AUTOSAR_SWS_FlashDriver

AUTOSAR Flash驱动(FLS)模块详解 AUTOSAR基础软件存储抽象层组件详细解析 目录 1. 概述 1.1. Flash驱动模块简介1.2. 功能和作用2. 架构设计 2.1. 模块架构2.2. API接口设计2.3. 状态机设计2.4. 异步操作时序2.5. 配置结构2.6. 任务处理流程3. 总结 3.1. 设计优势3.2. 应用场景…
阅读更多...
哪吒汽车：一边熬夜蹦迪，一边找药投医

哪吒汽车：一边熬夜蹦迪，一边找药投医

两年前&#xff0c;威马CEO沈晖发了个短视频&#xff0c;内容是“活下去&#xff0c;像牲口一样活下去”。 如今最能体会沈晖当时心情的&#xff0c;估计就是方运舟了。 作为哪吒汽车创始人兼董事长&#xff0c;他连续多次被限高&#xff0c;为了让哪吒汽车活下去&#xff0c…
阅读更多...
Linux一步部署主DNS服务器

Linux一步部署主DNS服务器

​ #!/bin/bash #部署DHCP服务 #userli 20250319if [ "$USER" ! "root" ]then echo"错误&#xff1a;非root用户&#xff0c;权限不足&#xff01;"exit 0fi#防火墙与高级权限 systemctl stop firewalld && systemctl disable firewalld…
阅读更多...
图片隐私清理工具

图片隐私清理工具

图片隐私清理助手&#xff1a;一键清除图片敏感信息的神器 在数字时代&#xff0c;我们每天都会拍摄和分享大量图片&#xff0c;但你是否注意过这些图片中可能暗藏隐私信息&#xff1f;相机的GPS定位、拍摄参数等EXIF数据&#xff0c;都可能在不经意间泄露你的隐私。今天介绍的…
阅读更多...
【UE5】摄像机晃动

【UE5】摄像机晃动

目录 效果 步骤 一、游戏中晃动视角 二、Sequence中晃动视角 效果 步骤 一、游戏中晃动视角 1. 新建一个蓝图&#xff0c;父类选择“CameraShakeBase” 这里命名为“BP_MyCameraShake” 打开“BP_MyCameraShake”&#xff0c;根晃动模式这里设置为“Perlin噪点摄像机晃…
阅读更多...
类和对象—继承（1）

类和对象—继承（1）

目录 1、继承1.1、继承的概念1.2、继承的语法 2、子类访问父类成员2.1、子类中访问父类的成员变量2.2、子类中访问父类的成员方法2.3、super 关键字 3、子类构造方法 1、继承 在 Java 中&#xff0c;类对现实中的实体进行描述&#xff0c;而类实例化的对象用来表示现实中的实体…
阅读更多...
试试智能体工作流，自动化搞定运维故障排查

试试智能体工作流，自动化搞定运维故障排查

APO 1.5.0版本全新推出的智能体工作流功能&#xff0c;让运维经验不再零散&#xff01;只需将日常的运维操作和故障排查经验转化为标准化流程&#xff0c;就能一键复用&#xff0c;效率翻倍&#xff0c;从此告别重复劳动&#xff0c;把时间留给更有价值的创新工作。更贴心的是&…
阅读更多...
Linux应用：线程基础

Linux应用：线程基础

线程介绍 进程是程序在操作系统里的一次执行过程&#xff0c;是系统进行资源分配和调度的基本单位&#xff1b;而线程是进程中的一个执行单元&#xff0c;是 CPU 调度和分派的基本单位。一个进程可以包含多个线程&#xff0c;这些线程共享进程的资源&#xff0c;如内存空间、文…
阅读更多...
要创建一个基于Spring Boot、Thymeleaf、MyBatis Plus和MySQL的简单表格增删改查（CRUD）项目

要创建一个基于Spring Boot、Thymeleaf、MyBatis Plus和MySQL的简单表格增删改查（CRUD）项目

文章目录 要创建一个基于Spring Boot、Thymeleaf、MyBatis Plus和MySQL的简单表格增删改查&#xff08;CRUD&#xff09;项目1. 创建Spring Boot项目2.项目配置2.1 依赖yml配置数据库表配置 3.代码实现3.1 实体类3.2 数据访问层3.3 服务层3.4 控制层3.5 Thymeleaf模板 要创建一…
阅读更多...
解决Cubemx生产的 .ioc文件不能外部打开的方法

解决Cubemx生产的 .ioc文件不能外部打开的方法

正常来说&#xff0c;cubemx生成的文件会有图标 但是当图标白色的时候&#xff0c;无法通过直接点击这个文件进入cubemx 1.首先检查java环境是不是装的JAVA8&#xff0c;如果是的话进行第二步操作&#xff1b; 2.重新安装一次cubemx&#xff0c;在安装的时候选择为我安装&…
阅读更多...
在 Linux（Ubuntu / CentOS 7）上快速搭建我的世界 MineCraft 服务器，并实现远程联机，详细教程

在 Linux（Ubuntu / CentOS 7）上快速搭建我的世界 MineCraft 服务器，并实现远程联机，详细教程

Linux 部署 MineCraft 服务器 详细教程&#xff08;丐版&#xff0c;无需云服务器&#xff09; 一、虚拟机 Ubuntu 部署二、下载 Minecraft 服务端三、安装 JRE 21四、安装 MCS manager 面板五、搭建服务器六、本地测试连接七、下载樱花&#xff0c;实现内网穿透&#xff0c;邀…
阅读更多...
Transformer | 一文了解：缩放、批量、多头、掩码、交叉注意力机制（Attention）

Transformer | 一文了解：缩放、批量、多头、掩码、交叉注意力机制（Attention）

源自: AINLPer&#xff08;每日干货分享&#xff01;&#xff01;&#xff09; 编辑: ShuYini 校稿: ShuYini 时间: 2025-3-27 更多&#xff1a;>>>>专注大模型/AIGC、学术前沿的知识分享&#xff01; 引言 之前的文章&#xff1a;2万字长文&#xff01;一文了解…
阅读更多...
原型验证后客户推翻原有需求，如何止损

原型验证后客户推翻原有需求，如何止损

原型验证后客户推翻原有需求时止损的有效方法包括&#xff1a;迅速评估影响范围、立即开展沟通确认、调整项目计划和资源配置、更新变更管理流程、协商成本分担机制。其中&#xff0c;迅速评估影响范围是关键&#xff0c;项目团队必须立即明确此次变更的具体影响&#xff0c;包…
阅读更多...
六、小白学JAVA-类和对象

六、小白学JAVA-类和对象

1、什么是类和对象 人类---类&#xff1a;走路、说话、学习 人---对象&#xff1a;具体到某个人&#xff0c;就是对象&#xff0c;走路、说话、学习&#xff0c;每个人都是独特的人。 public class Person {String name;public void walk() {System.out.println("我会走…
阅读更多...
STM32硬件IIC与OLED使用

STM32硬件IIC与OLED使用

OLED屏幕介绍 OLED即有机发光管(Organic Light-Emitting Diode,OLED)。OLED显示技术具有自发光、广视角、几乎无穷高的对比度、较低功耗、极高反应速度、可用于绕曲性面板、使用温度范围广、构造及制程简单等有点&#xff0c;被认为是下一代的平面显示屏新兴应用技术 OLED显示…
阅读更多...
基于Spring Boot的电动车智能充电服务平台的设计与实现（LW+源码+讲解）

基于Spring Boot的电动车智能充电服务平台的设计与实现（LW+源码+讲解）

专注于大学生项目实战开发,讲解,毕业答疑辅导&#xff0c;欢迎高校老师/同行前辈交流合作✌。 技术范围&#xff1a;SpringBoot、Vue、SSM、HLMT、小程序、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、安卓app、大数据、物联网、机器学习等设计与开发。 主要内容&#xff1a;…
阅读更多...
十、JavaScript对象

十、JavaScript对象

一、对象 创建对象的方法有三种&#xff1a;字面量、new、构造函数。 1.利用字面量创建对象 花括号{}里面包含了表达这个具体事物&#xff08;对象&#xff09;的属性和方法 // 1.利用对象字面量创建对象{}// var obj {}; // 创建了一个空的对象var obj {uname: black,ag…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023