JavaWeb之Servlet概述

刺骨的言语ヽ痛彻心扉 2024-04-08 11:56 52阅读 0赞

#### 文章目录 ####

*  1.Servlet概念
 *  2.开发一个带有Servlet(Java程序)的webapp步骤？
 *   *  2.1 使用记事本开发
     *  2.2 使用idea开发
 *  3.关于JavaEE的版本
 *  4.执行步骤
 *  5.执行原理
 *   *  5.1 Request和Response原理
 *  6. Servlet的生命周期
 *   *  6.1 什么是Servlet对象生命周期？
     *  6.2 Servlet对象是由谁来维护的？
     *  6.3 servlet对象的创建
     *  6.4 init初始化方法
     *  6.5 被销毁：执行destroy方法
     *  6.6 当我们Servlet类中编写一个有参数的构造方法，如果没有手动编写无参数构造方法会出现什么问题？
     *  6.7 关于Servlet类中方法的调用次数？
 *  7. ServletConfig
 *  8. ServletContext
 *   *  8.1 请求域对象和应用域对象
 *  9.Servlet注解
 *  10.Servlet体系结构
 *   *  10.1 GenericServlet
     *  10.2 HttpServlet
     *   *  10.2.1 HttpServletRequest接口详解
         *   *  10.2.1.1 常用的方法
             *  10.2.1.2 HttpServletRequest接口的其他常用方法
         *  10.2.2 Response对象
         *   *  10.2.2.1 功能
             *  10.2.2.2 案例
 *  11.转发和重定向
 *   *  11.1 转发
     *  11.2 重定向
     *  11.3 转发和重定向的区别
 *  12.欢迎资源文件
 *  12.关于WEB-INF目录

## 1.Servlet概念 ##

（1）servlet:server applet(运行在服务器端的小程序)  
浏览器请求动态资源找我们写的Java类，这些Java类没有main方法，依赖于服务器(如tomcat)才能运行，因此这些类需要遵守一定的规则，才能被服务器(tomcat)识别  
（2）遵循Servlet规范的webapp，这个webapp就可以放在不同的WEB服务器中运行（因为这个webapp是遵循Servlet规范的）  
（3）Servlet规范包括什么呢？

*  规范了哪些接口
 *  规范了哪些类
 *  规范了一个web应用中应该有哪些配置文件
 *  规范了一个web应用中配置文件的名字
 *  规范了一个web应用中配置文件存放的路径
 *  规范了一个web应用中配置文件的内容
 *  规范了一个合法有效的web应用它的目录结构应该是怎样的

## 2.开发一个带有Servlet(Java程序)的webapp步骤？ ##

### 2.1 使用记事本开发 ###

（1）第一步：在webapps目录下新建一个目录，起名crm（这个crm就是webapp的名字,名字随意）  
注意：crm就是这个webapp的根  
（2）第二步：在webapp的根下新建一个目录：WEB-INF  
注意：这个目录的名字是Servlet规范中规定的，必须全部大写，必须一模一样。  
（3）第三步：在WEB-INF目录下新建一个目录：classes  
注意：这个目录的名字必须是全部小写的classes。这也是Servlet规范中规定的。另外这个目录下一定存放的是Java程序编译之后的class文件（这里存放的是字节码文件）  
（4）第四步：在WEB-INF目录下新建一个目录：lib  
注意：这个目录不是必须的。但如果一个webapp需要第三方的jar包的话，这个jar包要放到这个lib目录下，这个目录的名字也不能随意编写，必须是全部小写的lib。例如java语言连接数据库需要数据库的驱动jar包。那么这个jar包就一定要放到lib目录下。这Servlet规范中规定的。  
（5）第五步：在WEB-INF目录下新建一个文件：web.xml  
注意：这个文件是必须的，这个文件名必须叫做web.xml。这个文件必须放在这里。一个合法的webapp，web.xml文件是必须的，这个web.xml文件就是一个配置文件，在这个配置文件中描述了请求路径和Servlet类之间的对照关系。

（6）第六步：编写一个Java程序，这个小Java程序也不能随意开发，这个小java程序必须实现Servlet接口。  
①这个Servlet接口不在JDK当中（因为Servlet不是JavaSE了。Servlet属于JavaEE，是另外的一套类库。）Servlet接口（Servlet.class文件）是Oracle提供的（最原始的是sun公司提供的），Servlet接口是JavaEE的规范中的一员。  
②Tomcat服务器实现了Servlet规范，所以Tomcat服务器也需要使用Servlet接口。Tomcat服务器中应该有这个接口，Tomcat服务器的CATALINA\_HOME\\lib目录下有一个servlet-api.jar，解压这个servlet-api.jar之后，你会看到里面有一个Servlet.class文件。  
③重点：从JakartaEE9开始，Servlet接口的全名变了：jakarta.servlet.Servlet  
④注意：编写这个Java小程序的时候，java源代码你愿意在哪里就在哪里，位置无所谓，你只需要将java源代码编译之后的class文件放到classes目录下即可。  
（7）第七步：编译我们编写的HelloServlet  
重点：你怎么能让你的HelloServlet编译通过呢？配置环境变量CLASSPATH  
CLASSPATH=.;C:\\dev\\apache-tomcat-10.0.12\\lib\\servlet-api.jar  
（8）第八步：将以上编译之后的HelloServlet.class文件拷贝到WEB-INF\\classes目录下。  
（9）第九步：在web.xml文件中编写配置信息，让“请求路径”和“Servlet类名”关联在一起。

*  这一步用专业术语描述：在web.xml文件中注册Servlet类。

<?xml version="1.0" encoding="UTF-8"?>
    
    <web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
                          https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
      version="5.0"
      metadata-complete="true">
    
    	
    	
    	<servlet>
    		<servlet-name>demoServlet</servlet-name>
    		
    		<servlet-class>com.se.HelloServlet</servlet-class>
    	</servlet>
    	
    	<servlet-mapping>
    		
    		<servlet-name>demoServlet</servlet-name>
    		
    		<url-pattern>/demoServlet1</url-pattern>
    	</servlet-mapping>
    </web-app>

（10）第十步：启动Tomcat服务器  
（11）第十一步：打开浏览器，在浏览器地址栏上输入一个url，这个URL必须是：

*  http://127.0.0.1:8080/crm/demoServlet1
 *  非常重要的一件事：浏览器上的请求路径不能随便写，这个请求路径必须和web.xml文件中的url-pattern一致。
 *  注意：浏览器上的请求路径和web.xml文件中的url-pattern的唯一区别就是：浏览器上的请求路径带项目名：/crm
 *  以后不需要我们编写main方法了。tomcat服务器负责调用main方法，Tomcat服务器启动的时候执行的就是main方法。我们javaweb程序员只需要编写Servlet接口的实现类，然后将其注册到web.xml文件中，即可。
 *  总结一下：一个合法的webapp目录结构应该是怎样的？

### 2.2 使用idea开发 ###

（1）第一步：New Project（我比较习惯先创建一个Empty Project【空工程】，然后在空工程下新建Module【模块】，这不是必须的，只是一种习惯，你可以直接新建非空的Project），这个Empty Project起名为：javaweb（不是必须的，只是一个名字而已。一般情况下新建的Project的名字最好和目录的名字一致。）  
（2）第二步：新建模块（File --> new --> Module…）  
①这里新建的是一个普通的JavaSE模块（这里先不要新建Java Enterprise模块）  
②这个Module自动会被放在javaweb的project下面。  
③给这个Module起名  
（3）第三步：让Module变成JavaEE的模块（让Module变成webapp的模块。符合webapp规范。符合Servlet规范的Module）  
①在Module上点击右键：Add Framework Support…（添加框架支持）  
②在弹出的窗口中，选择Web Application（选择的是webapp的支持）  
③选择了这个webapp的支持之后，IDEA会自动给你生成一个符合Servlet规范的webpp目录结构。  
**重点，需要注意的：在IDEA工具中根据Web Application模板生成的目录中有一个web目录，这个目录就代表webapp的根**  
（4）第四步：编写Servlet

class StudentServlet implements Servlet
      //实现jakarta.servlet.Servlet接口中的5个方法。

*  这个时候发现Servlet.class文件没有。怎么办？将CATALINA\_HOME/lib/servlet-api.jar和jsp-api.jar添加到classpath当中（这里的classpath说的是IDEA的classpath）
    
     *  File --> Project Structrue --> Modules --> + 加号 --> 执行1或者2都可以  
        ![在这里插入图片描述][044f08f886cb4df8b46954effec258f4.png]

（6）第六步：在Servlet当中的service方法中编写业务代码  
（7）第七步：在WEB-INF目录下新建了一个子目录：lib（这个目录名可不能随意，必须是全部小写的lib），并且将连接数据库的驱动jar包放到lib目录下。  
（8）第八步：在web.xml文件中完成StudentServlet类的注册。（请求路径和Servlet之间对应起来）  
（9）第九步：让IDEA工具去关联Tomcat服务器。关联的过程当中将webapp部署到Tomcat服务器当中。  
①IDEA工具右上角，绿色小锤子右边有一个：Add Configuration  
②左上角加号，点击Tomcat Server --> local  
③在弹出的界面中设置服务器Server的参数（基本上不用动）  
④在当前窗口中有一个Deployment（点击这个用来部署webapp），继续点击加号，部署即可。  
⑤修改 Application context为：/xmm（就是我们自己起的项目名）  
（10）第十步：启动Tomcat服务器  
①在右上角有绿色的箭头，或者绿色的小虫子，点击这个绿色的小虫子，可以采用debug的模式启动Tomcat服务器。  
②我们开发中建议适用debug模式启动Tomcat  
（11）第十一步：打开浏览器，在浏览器地址栏上输入相应的地址

## 3.关于JavaEE的版本 ##

*  JavaEE目前最高版本是 JavaEE8
 *  JavaEE被Oracle捐献了，Oracle将JavaEE规范捐献给Apache了。
 *  Apache把JavaEE换名了，以后不叫JavaEE了，以后叫做 jakarta EE。
 *  以后没有JavaEE了。以后都叫做Jakarta EE。
 *  JavaEE8版本升级之后的"JavaEE 9"，不再是"JavaEE9"这个名字了，叫做JakartaEE9
 *  JavaEE8的时候对应的Servlet类名是：javax.servlet.Servlet
 *  JakartaEE9的时候对应的Servlet类名是：jakarta.servlet.Servlet （包名都换了）
 *  如果你之前的项目还是在使用javax.servlet.Servlet，那么你的项目无法直接部署到Tomcat10+版本上。你只能部署到Tomcat9-版本上。在Tomcat9以及Tomcat9之前的版本中还是能够识别javax.servlet这个包。

## 4.执行步骤 ##

![在这里插入图片描述][3b61f6275f014e239d9d7dbdb6a96ed1.png]

（1）创建JavaEE项目

public class DemoServlet implements Servlet {
        
        /**
         * 初始化方法
         * 在Servlet对象第一次被创建时执行，只会执行一次
         * @param servletConfig
         * @throws ServletException
         */
        @Override
        public void init(ServletConfig servletConfig) throws ServletException {
        
    }
        /**
         * 获取ServletConfig对象
         * ServletConfig: Servlet的配置对象
         * @return
         */
        @Override
        public ServletConfig getServletConfig() {
        
            return null;
        }
        /**
         * 提供服务方法
         * 每一次Servlet被访问时执行,执行多次
         * @param servletRequest
         * @param servletResponse
         * @throws ServletException
         * @throws IOException
         */
        @Override
        public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        
        }
        /**
         *  获取Servlet的一些信息，版本、作者等等
         * @reurn
         */
        @Override
        public String getServletInfo() {
        
            return null;
        }
        /**
         * 销毁方法
         * 在服务器在销毁servlet对象之前会调用一次destroy方法
         * destroy方法在执行的时候，servlet对象的内存还没有被销毁(即将被销毁)
         */
        @Override
        public void destroy() {
        
    } }

（2）定义一个类，实现servlet接口

public class ServletDemo1 implements Servlet

（3）实现接口中的抽象方法  
（4）在web.xml中配置Servlet

<servlet>
    	<servlet-name>demo1</servlet-name>
    	<servlet-class>cn.itcast.web.servlet.ServletDemo1</servlet-class>//全类名
    </servlet>
    <servlet-mapping>
    	<servlet-name>demo1</servlet-name>
    	<url-pattern>/demo1</url-pattern>
    </servlet-mapping>

## 5.执行原理 ##

![在这里插入图片描述][1f2612797a064347a26a231bdc11927c.png]

1.当服务器接收到客户端浏览器的请求后，会解析请求URL路径，获取访问的Servlet的资源路径  
2.查找web.xml文件，是否有对应的`<url-pattern>`标签体内容  
3.如果有,则再找到对应的`<servlet-class>`全类名  
4.tomcat会将字节码文件加载进内存，并且创建其对象  
5.调用方法

### 5.1 Request和Response原理 ###

![在这里插入图片描述][8c0c72cf73014a70a9d9b40c74ebc99d.png]  
（1）request和response对象都是由服务器创建的，我们来使用它们  
（2）request对象是来获取请求消息，response对象是来设置响应消息

## 6. Servlet的生命周期 ##

### 6.1 什么是Servlet对象生命周期？ ###

*  Servlet对象什么时候被创建。
 *  Servlet对象什么时候被销毁。
 *  Servlet对象创建了几个？
 *  Servlet对象的生命周期表示：一个Servlet对象从出生在最后的死亡，整个过程是怎样的。

### 6.2 Servlet对象是由谁来维护的？ ###

*  Servlet对象的创建，对象上方法的调用，对象最终的销毁，Javaweb程序员是无权干预的。
 *  Servlet对象的生命周期是由Tomcat服务器（WEB Server）全权负责的。
 *  Tomcat服务器通常我们又称为：WEB容器（WEB Container）
 *  WEB容器来管理Servlet对象的死活。
 *  思考：我们自己new的Servlet对象受WEB容器的管理吗？
    
     *  我们自己new的Servlet对象是不受WEB容器管理的。
     *  WEB容器创建的Servlet对象，这些Servlet对象都会被放到一个集合当中（HashMap），只有放到这个HashMap集合中的Servlet才能够被WEB容器管理，自己new的Servlet对象不会被WEB容器管理。（自己new的Servlet对象不在容器当中）
     *  web容器底层应该有一个HashMap这样的集合，在这个集合当中存储了Servlet对象和请求路径之间的关系

![在这里插入图片描述][b82015ac75da431ca87e887a132f22db.png]

### 6.3 servlet对象的创建 ###

当用户第一次访问Servlet时，由容器调用Servlet的构造器创建具体的servlet对象。也可以在容器启动之后立刻创建实例  
（1）默认情况下，通过浏览器第一次被访问时，Servlet被创建  
（2）可以配置执行Servlet的创建时机(在标签下配置),在该子标签中填写整数，越小的整数优先级越高。  
①用户发送第一次请求的时候，创建  
`<load-on-startup></load-on-startup>`的值为负数，默认为-1  
②在服务器启动时，创建  
`<load-on-startup></load-on-startup>`的值为0或正整数  
（3）Servlet对象是单例的（但是要注意：Servlet对象是单实例的，但是Servlet类并不符合单例模式。我们称之为假单例。之所以单例是因为Servlet对象的创建我们javaweb程序员管不着，这个对象的创建只能是Tomcat来说了算，Tomcat只创建了一个，所以导致了单例，但是属于假单例。真单例模式，构造方法是私有化的。）  
注意：Servlet的init方法，只执行一次，说明Servlet在内存中只存在一个对象，Servlet是单例的  
①多个用户同时访问时，可能存在线程安全问题  
②解决：尽量不要在Servlet中定义成员变量。既使定义了成员变量，也不要对其修改值

### 6.4 init初始化方法 ###

(1)Servlet的init()方法是在第一次请求该Servlet时由容器调用的方法。在该方法中，Servlet对象的初始化任务可以完成。init()方法只被调用一次，在Servlet对象的生命周期内，只要Web应用程序没有停止或Servlet没有被卸载，init（）方法不会被再次调用。  
(2)在init（）方法中，常见的初始化任务包括获取Servlet配置参数、初始化状态变量、创建或获取数据库连接池或其他对象等。任何初始化任务，都应该放在init（）方法中，以确保在Servlet被请求之前，它们已经完成。  
(3)在Servlet的生命周期中，init（）方法是在Servlet被实例化后第一个调用的方法。当容器调用Servlet的init（）方法时，它会传递一个ServletConfig对象作为参数，该对象包含该Servlet的配置信息，例如Servlet的名称、参数、上下文等。ServletConfig对象可以用来获取Servlet的初始化参数，并为Servlet对象提供有用的信息。

### 6.5 被销毁：执行destroy方法 ###

当servlet容器停止或者重新启动都会引起销毁servlet对象并调用destroy方法  
①Servlet被销毁时执行(当服务器被关闭时，Servlet就会被销毁）  
②只有服务器正常关闭时，才会执行destroy方法  
③destroy方法在Servlet被销毁之前执行，一般用于释放资源  
④destroy方法是在什么时候被调用的？

*  在服务器关闭的时候。
 *  因为服务器关闭的时候要销毁AServlet对象的内存。  
    \- 服务器在销毁AServlet对象内存之前，Tomcat服务器会自动调用AServlet对象的destroy方法。

⑤destroy方法调用的时候，对象销毁了还是没有销毁呢？  
destroy方法执行的时候Servlet对象还在，没有被销毁。destroy方法执行结束之后，Servlet对象的内存才会被Tomcat释放。

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

*  报错了：500错误。
 *  注意：500是一个HTTP协议的错误状态码。
 *  500一般情况下是因为服务器端的Java程序出现了异常（服务器端的错误都是500错误：服务器内部错误。）
 *  如果没有无参数的构造方法，会导致出现500错误，无法实例化Servlet对象。
 *  所以，一定要注意：在Servlet开发当中，不建议程序员来定义构造方法，因为定义不当，一不小心就会导致无法实例化Servlet对象。
 *  思考：Servlet的无参数构造方法是在对象第一次创建的时候执行，并且只执行一次。init方法也是在对象第一次创建的时候执行，并且只执行一次。那么我们能把init方法体中写的内容写到无参构造方法中从而代替掉init方法吗？  
    不能。Servlet规范中有要求，作为javaweb程序员，编写Servlet类的时候，不建议手动编写构造方法，因为手动编写的构造方法，很容易让原本存在的无参数构造方法消失，这个操作可能会导致Servlet对象无法实例化。所以init方法是有存在的必要的。

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

*  构造方法只执行一次。
 *  init方法只执行一次。
 *  service方法：用户发送一次请求则执行一次，发送N次请求则执行N次。
 *  destroy方法只执行一次。

## 7. ServletConfig ##

（1）ServletConfig是什么？  
①ServletConfig是Servlet规范中的一员  
②ServletConfig是一个接口  
（2）谁去实现了ServletConfig这个接口？  
①WEB服务器实现了，public class org.apache.catalina.core.StandardWrapperFacade implements ServletConfig \{ \}  
②结论：Tomcat服务器实现了ServletConfig接口。  
③如果把Tomcat服务器换成其他服务器，输出ServletConfig对象的结果可能就不同了，因为包名和类名可能会和Tomcat不一样；但是他们都实现了ServletConfig这个规范  
（3）一个Servlet对象中有一个ServletConfig对象（Servlet和ServletConfig对象是一对一）  
（4）ServletConfig对象是谁创建的？什么时候创建的？  
①Tomcat服务器(WEB服务器)创建了ServletConfig对象  
②在创建Servlet对象的时候，同时创建了ServletConfig对象  
（5）ServletConfig接口有什么用？  
Servlet对象的配置信息对象  
（6）ServletConfig对象包装了什么信息？  
ServletConfig对象中包装的信息是web.xml文件中`<servlet></servlet>`标签的配置信息，Tomcat解析web.xml文件，将web.xml文件中  
`<servlet></servlet>`标签中的配置信息自动包装到ServletConfig对象中。

## 8. 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服务器启动的时候创建的。  
（4）对于一个webapp来说，ServletContext对象只有一个；ServletContext对象是在服务器关闭的时候销毁的  
（5）ServletContext怎么理解？  
①context是servlet对象的环境对象（Servlet对象的上下文对象）  
②ServletContext对象对应的其实就是整个web.xml文件  
③比如:50个学生，每个学生都是一个servlet，这50个学生都在同一个教室当中，那么这个教室就相当于ServletContext对象；  
放在ServletContext对象中的数据，所有servlet都是共享的。  
④Tomcat是一个容器，一个容器当中可以放多个webapp，一个webapp对应一个ServletContext对象，一个servlet对象对应  
一个ServletConfig  
（6）获取应用级的配置信息(一般一个项目中共享的配置信息会放到该标签中)

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

①`String getInitParameter(String name);` //通过初始化参数的name获取value  
②`Enumeration<String> getInitParameterNames();` // 获取所有初始化参数的name  
（7）获取应用的根路径  
public String getContextPath();  
（8）获取文件的绝对路径  
public String getRealPath(String path);  
（9）通过ServletContext对象也是可以记录日志的  
①void log(String msg)  
②void log(String message,Throwable throwable)  
（10）Tomcat服务器的logs目录下都有哪些日志文件？  
catalina.日期.log //服务器端的java程序运行的控制台信息  
localhost.日期.log // ServletContext对象的log方法记录的日志信息存储到这个文件中  
localhost\_access\_log.日期.txt //访问日志  
（11）ServletContext对象还有另外一个名字：应用域。如果所有用户共享一份数据，并且这个数据很少被修改，数据量很少，可以将这些数据放到ServletContext这个应用域中。数据量小、所有用户共享、又不修改，这样的数据放到ServletContext这个数据域中，会大大提升效率。因为应用域相当于一个缓存，放到缓存中的数据，下次再用的时候，不需要再从数据库中获取，大大提升执行效率。  
①要求是用户共享的数据是因为ServletContext对象只有一个，只有共享的数据放进去才有意义  
②要求数据量小是因为数据量太大会占用过多的堆内存，并且这个对象的生命周期比较长，服务器关闭的时候，这个对象才会被销毁。大数据量会影响服务器的性能。  
③要求数据很少被修改是因为所有用户共享的数据，如果涉及到修改操作，必然会存在线程并发所带来的安全问题，所以放在ServletContext对象中的数据一般都是只读的。

### 8.1 请求域对象和应用域对象 ###

（1）request对象实际上又称为“请求域”对象，请求域”对象要比“应用域”对象范围小很多。生命周期短很多。请求域只在一次请求内有效。一个请求对象request对应一个请求域对象。一次请求结束之后，这个请求域就销毁了。  
请求域对象存取数据的方法如下：

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

（2）ServletContext（Servlet上下文对象），又称为应用域对象，什么情况下会考虑向应用域中绑定数据呢？  
①所有用户共享的数据  
②这个共享的数据量很小  
③这个共享的数据很少被修改

*  ServletContext数据域中存、取、删数据  
    setAttribute(String name,Object object)  
    getAttribute(String name)  
    removeAttribute(String name)
 *  实际上向应用域当中绑定数据，就相当于把数据放到了缓存（Cache）中，然后用户访问的时候直接从缓存中取，可以减少IO的操作，大大提升系统的性能，所以缓存技术是提高系统性能的重要手段。

## 9.Servlet注解 ##

（1）@WebServlet注解在Servlet类上使用，属性如下：  
①name属性：用来指定Servlet的名字。等同于：`<servlet-name>`  
②urlpatterns属性：用来指定Servlet的映射路径，可以指定多个字符串。等同于：`<url-pattern>`  
③loadOnStartUp属性：用于指定在服务器启动阶段是否加载该Servlet，等同于：`<load-on-startup>`  
（2）注意：  
①当注解的属性是一个数组，并且数组中只有一个元素，大括号可以省略  
②如果注解的属性名是value的话，属性名也是可以省略的  
（3）@WebServlet注解源码如下：

@Target({
        ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface WebServlet {
        
        String name() default ""; // 相当于<servlet-name>
     
        String[] value() default {
        }; // 代表urlPatterns()相关属性配置
    
        String[] urlPatterns() default {
        }; // 相当于<url-pattern>
        
        int loadOnStartup() default -1; // 相当于<load-on-startup>
        
        WebInitParam [] initParams() default {
        };
        
        boolean asyncSupported() default false;
     
        String smallIcon() default "";
    
        String largeIcon() default "";
     
        String description() default "";
    
        String displayName() default "";
    }

## 10.Servlet体系结构 ##

![在这里插入图片描述][f6e009aedeb74df58a0c33282b5ea8af.png]

### 10.1 GenericServlet ###

(1)GenericServlet:将Servlet接口中其他的方法做了默认空实现，只将service()方法作为抽象

注意：init方法中的ServletConfig对象是由Tomcat创建好的。这个ServletConfig对象是在init方法的参数上的，属于局部变量。  
那么ServletConfig对象以后要是在service方法中使用，怎么才能保证ServletConfig对象在service方法中能够被使用?  
源码实现如下：

private transient ServletConfig config;//transient:游离的属性,不参与序列化
    public void init(ServletConfig config) throws ServletException {
        
            this.config = config;
            this.init();
        }
    public void init() throws ServletException {
        
            // NOOP by default
        }
    public ServletConfig getServletConfig() {
        
            return config;
        }

我们需要重写init方法时，去重写public void init() 这个方法就可以了

### 10.2 HttpServlet ###

（1）HttpServlet类是专门为HTTP协议准备的。比GenericServlet更加适合HTTP协议下的开发。  
（2）HttpServlet在jakarta.servlet.http.HttpServlet这个包下  
（3）http包下都有哪些类和接口呢？jakarta.servlet.http.\*;  
①jakarta.servlet.http.HttpServlet （HTTP协议专用的Servlet类，抽象类）  
②jakarta.servlet.http.HttpServletRequest （HTTP协议专用的请求对象）  
③jakarta.servlet.http.HttpServletResponse （HTTP协议专用的响应对象）  
（4）HttpServletRequest对象中封装了什么信息？  
①HttpServletRequest，简称request对象。封装了请求协议的全部内容。  
②Tomcat服务器（WEB服务器）将“请求协议”中的数据全部解析出来，然后将这些数据全部封装到request对象当中了。  
③也就是说，我们只要面向HttpServletRequest，就可以获取请求协议中的数据。  
（5）HttpServletResponse对象是专门用来响应HTTP协议到浏览器的。  
（6）HttpServlet源码分析：

public class HelloServlet extends HttpServlet {
        
    	// 用户第一次请求，创建HelloServlet对象的时候，会执行这个无参数构造方法。
    	public HelloServlet() {
        
        }
    }
    
    public abstract class GenericServlet implements Servlet, ServletConfig,
            java.io.Serializable {
        
              
    	/* 用户第一次请求的时候，HelloServlet对象第一次被创建之后，因为HelloServlet
           没有init方法，HttpServlet也没有，所以执行GenericServlet的init有参构造.。  */
        public void init(ServletConfig config) throws ServletException {
        
            this.config = config;
            this.init();
        }
    	// 用户第一次请求的时候，带有参数的init(ServletConfig config)执行之后，会执行这个没有参数的init()
    	public void init() throws ServletException {
        
            // NOOP by default
        }
    }
    
    // HttpServlet模板类。
    public abstract class HttpServlet extends GenericServlet {
        
        // 用户发送第一次请求的时候这个service会执行(HelloServlet没有service,执行Httpservlet的)
        // 用户发送第N次请求的时候，这个service方法还是会执行。
        // 用户只要发送一次请求，这个service方法就会执行一次。
        @Override
        public void service(ServletRequest req, ServletResponse res)
            throws ServletException, IOException {
        
    
            HttpServletRequest  request;
            HttpServletResponse response;
    
            try {
        
                // 将ServletRequest和ServletResponse向下转型为带有Http的HttpServletRequest和HttpServletResponse
                request = (HttpServletRequest) req;
                response = (HttpServletResponse) res;
            } catch (ClassCastException e) {
        
                throw new ServletException(lStrings.getString("http.non_http"));
            }
            // 调用重载的service方法。
            service(request, response);
        }
        
        // 这个service方法的两个参数都是带有Http的。
        // 这个service是一个模板方法。
        // 在该方法中定义核心算法骨架，具体的实现步骤延迟到子类中去完成。
        protected void service(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        
            // 获取请求方式
            // 这个请求方式最终可能是：""
            // 注意：request.getMethod()方法获取的是请求方式，可能是七种之一：
            // GET POST PUT DELETE HEAD OPTIONS TRACE
            String method = req.getMethod();
    
            // 如果请求方式是GET请求，则执行doGet方法。
            if (method.equals(METHOD_GET)) {
        
                long lastModified = getLastModified(req);
                if (lastModified == -1) {
        
                    // servlet doesn't support if-modified-since, no reason
                    // to go through further expensive logic
                    doGet(req, resp);
                } else {
        
                    long ifModifiedSince;
                    try {
        
                        ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                    } catch (IllegalArgumentException iae) {
        
                        // Invalid date header - proceed as if none was set
                        ifModifiedSince = -1;
                    }
                    if (ifModifiedSince < (lastModified / 1000 * 1000)) {
        
                        // If the servlet mod time is later, call doGet()
                        // Round down to the nearest second for a proper compare
                        // A ifModifiedSince of -1 will always be less
                        maybeSetLastModified(resp, lastModified);
                        doGet(req, resp);
                    } else {
        
                        resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                    }
                }
    
            } else if (method.equals(METHOD_HEAD)) {
        
                long lastModified = getLastModified(req);
                maybeSetLastModified(resp, lastModified);
                doHead(req, resp);
    
            } else if (method.equals(METHOD_POST)) {
        
                // 如果请求方式是POST请求，则执行doPost方法。
                doPost(req, resp);
    
            } else if (method.equals(METHOD_PUT)) {
        
                doPut(req, resp);
    
            } else if (method.equals(METHOD_DELETE)) {
        
                doDelete(req, resp);
    
            } else if (method.equals(METHOD_OPTIONS)) {
        
                doOptions(req,resp);
    
            } else if (method.equals(METHOD_TRACE)) {
        
                doTrace(req,resp);
    
            } else {
        
                //
                // Note that this means NO servlet supports whatever
                // method was requested, anywhere on this server.
                //
    
                String errMsg = lStrings.getString("http.method_not_implemented");
                Object[] errArgs = new Object[1];
                errArgs[0] = method;
                errMsg = MessageFormat.format(errMsg, errArgs);
    
                resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
            }
        }
        
        /*子类没有重写doGet就会走父类的，报405错误*/
        protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException{
        
            // 报405错误
            String msg = lStrings.getString("http.method_get_not_supported");
            sendMethodNotAllowed(req, resp, msg);
        }
            /*子类没有重写doPost就会走父类的，报405错误*/
        protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        
            // 报405错误
            String msg = lStrings.getString("http.method_post_not_supported");
            sendMethodNotAllowed(req, resp, msg);
        }   
    }
    /*
    通过以上源代码分析：
    	假设前端发送的请求是get请求，后端程序员重写的方法是doPost
    	假设前端发送的请求是post请求，后端程序员重写的方法是doGet
    	会发生什么呢？
    		发生405这样的一个错误。405表示前端的错误，发送的请求方式不对。和服务器不一致。不是服务器需要的请求方式。
    	通过以上源代码可以知道：只要HttpServlet类中的doGet方法或doPost方法执行了，必然405.
    怎么避免405的错误呢？
    	后端重写了doGet方法，前端一定要发get请求。
    	后端重写了doPost方法，前端一定要发post请求。
    	这样可以避免405错误。
    	这种前端到底需要发什么样的请求，其实应该后端说了算。后端让发什么方式，前端就得发什么方式。
    */

（7）我们编写的HelloServlet直接继承HttpServlet，直接重写HttpServlet类中的service()方法行吗？  
○ 可以，只不过你享受不到405错误。享受不到HTTP协议专属的东西。  
（8）到今天我们终于得到了最终的一个Servlet类的开发步骤：  
○ 第一步：编写一个Servlet类，直接继承HttpServlet  
○ 第二步：重写doGet方法或者重写doPost方法，到底重写谁，javaweb程序员说了算。  
○ 第三步：将Servlet类配置到web.xml文件当中。  
○ 第四步：准备前端的页面（form表单），form表单中指定请求路径即可。

#### 10.2.1 HttpServletRequest接口详解 ####

（1）HttpServletRequest是一个接口，全限定名称：jakarta.servlet.http.HttpServletRequest  
（2）HttpServletRequest接口是Servlet规范中的一员，HttpServletRequest的父接口：ServletRequest  
（3）HttpServletRequest对象中都有什么信息？都包装了什么信息？  
○ HttpServletRequest对象是Tomcat服务器负责创建的。这个对象中封装了什么信息？封装了HTTP的请求协议。  
○ 实际上是用户发送请求的时候，遵循了HTTP协议，发送的是HTTP的请求协议，Tomcat服务器将HTTP协议中的信息以及数据全部解析出来，然后Tomcat服务器把这些信息封装到HttpServletRequest对象当中，传给了我们javaweb程序员。  
○ javaweb程序员面向HttpServletRequest接口编程，调用方法就可以获取到请求的信息了。  
（4）request和response对象的生命周期？  
○ request对象和response对象，一个是请求对象，一个是响应对象。这两个对象只在当前请求中有效。  
○ 一次请求对应一个request。  
○ 两次请求则对应两个request。  
○ …

##### 10.2.1.1 常用的方法 #####

（1）获取用户提交的数据

Map<String,String[]> getParameterMap() 这个是获取Map
    Enumeration<String> getParameterNames() 这个是获取Map集合中所有的key
    String[] getParameterValues(String name) 根据key获取Map集合的value
    String getParameter(String name)  获取value这个一维数组当中的第一个元素。这个方法最常用。
    // 以上的4个方法，和获取用户提交的数据有关系。

（2）思考：如果是你，前端的form表单提交了数据之后，你准备怎么存储这些数据，你准备采用什么样的数据结构去存储这些数据呢？  
● 前端提交的数据格式：username=abc&userpwd=111&aihao=s&aihao=d&aihao=tt  
● 我会采用Map集合来存储：

Map<String,String>
        key存储String
        value存储String
        这种想法对吗？不对。
        如果采用以上的数据结构存储会发现key重复的时候value覆盖。
        key         value
        ---------------------
        username    abc
        userpwd     111
        aihao       s
        aihao       d
        aihao       tt
        这样是不行的，因为map的key不能重复。
    Map<String, String[]>
        key存储String
        value存储String[]
        key				value
        -------------------------------
        username		{
        "abc"}
        userpwd			{
        "111"}
        aihao			{
        "s","d","tt"}

（3）注意：前端表单提交数据的时候，假设提交了120这样的“数字”，其实是以字符串"120"的方式提交的，所以服务器端获取到的一定是一个字符串的"120"，而不是一个数字。（前端永远提交的是字符串，后端获取的也永远是字符串。）

（4）四个方法的使用

//username=zhangsan&userpwd=123&interest=s&interest=d
    /*Map<String,String[]>
         key				value
      ---------------------------
      "username"		{"zhangsan"}
      "userpwd"		  {"123"}
      "interest"		{"s", "d"}  */
    
    public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws IOException,ServletException{
        
      
             /*1.最常用的方式  String getParameter(String name)*/
           	String username = request.getParameter("username");
            String userpwd = request.getParameter("userpwd");
      			
      				System.out.println(username);
           	  System.out.println(userpwd);
      
      
    		/*2.既然是checkbox，调用方法：request.getParameterValues("interest")*/
          	String[] interests = request.getParameterValues("interest");		
      					for(String  i : interests){
        
               			 System.out.println(i);
           	 }
    				
      		/*3.直接通过getParameterNames()这个方法，可以直接获取这个Map集合的所有key*/
            Enumeration<String> names = request.getParameterNames();
            while(names.hasMoreElements()){
        
                String name = names.nextElement();
                System.out.println(name);
            }
      			
      		/*4.获取参数Map集合*/
            Map<String,String[]> parameterMap = request.getParameterMap();
            // 遍历Map集合(获取Map集合中所有的key，遍历)
            Set<String> keys = parameterMap.keySet();
            Iterator<String> it = keys.iterator();
            while(it.hasNext()){
        
                String key = it.next();
    			System.out.print(key+"=");
            // 通过key获取value
                String[] values = parameterMap.get(key);
              for(String value : values){
        
                    System.out.print(value+",");
                }
              
              /*4.输出结果
              username=zhangsan,
    					userpwd=123,
    					interest=s,d,
    
    }

##### 10.2.1.2 HttpServletRequest接口的其他常用方法 #####

// 获取客户端的IP地址
          String remoteAddr = request.getRemoteAddr();
              
    // get请求在请求行上提交数据。
    // post请求在请求体中提交数据。
    // 设置请求体的字符集。（显然这个方法是处理POST请求的乱码问题。这种方式并不能解决get请求的乱码问题。）
    // Tomcat10之后，request请求体当中的字符集默认就是UTF-8，不需要设置字符集，不会出现乱码问题。
    // Tomcat9前（包括9在内），如果前端请求体提交的是中文，后端获取之后出现乱码，怎么解决这个乱码？执行以下代码。
           request.setCharacterEncoding("UTF-8");
              
     // 在Tomcat9之前（包括9），响应中文也是有乱码的，怎么解决这个响应的乱码？
           response.setContentType("text/html;charset=UTF-8");
     // 在Tomcat10之后，包括10在内，响应中文的时候就不在出现乱码问题了。以上代码就不需要设置UTF-8了。
              
     // 注意一个细节，在Tomcat10包括10在内之后的版本，中文将不再出现乱码
     // get请求乱码问题怎么解决？
     // get请求发送的时候，数据是在请求行上提交的，不是在请求体当中提交的。
     // get请求乱码解决方案：修改CATALINA_HOME/conf/server.xml配置文件
           <Connector URIEncoding="UTF-8" />
     // 注意：从Tomcat8之后，URIEncoding的默认值就是UTF-8，所以GET请求也没有乱码问题了。            
     // 获取应用的根路径
           String contextPath = request.getContextPath();          
     // 获取请求方式
           String method = request.getMethod();      
     // 获取请求的URI
           String uri = request.getRequestURI();  // /aaa/testRequest      
     // 获取servlet path
           String servletPath = request.getServletPath(); //   /testRequest

#### 10.2.2 Response对象 ####

##### 10.2.2.1 功能 #####

设置响应消息  
（1）设置响应行  
①格式：HTTP/1.1 200 ok  
②设置状态码：setStatus(int sc)  
（2）设置响应头：setHeader(String name, String value)  
（3）设置响应体：  
①获取输出流  
\*字符输出流：PrintWriter getWriter()  
\*字节输出流：ServletOutputStream getOutputStream()  
②使用输出流，将数据输出到客户端浏览器

##### 10.2.2.2 案例 #####

（1）重定向：资源跳转的方式  
（2）代码实现：

//1. 设置状态码为302
    response.setStatus(302);
    //2.设置响应头location
    response.setHeader("location","/day15/responseDemo2");
    //简单的重定向方法
    response.sendRedirect("/day15/responseDemo2");

## 11.转发和重定向 ##

### 11.1 转发 ###

（1）两个Servlet怎么共享数据？  
● 将数据放到ServletContext应用域当中，当然是可以的，但是应用域范围太大，占用资源太多。不建议使用。  
● 可以将数据放到request域当中，然后AServlet转发到BServlet，保证AServlet和BServlet在同一次请求当中，这样就可以做到两个Servlet，或者多个Servlet共享同一份数据。

![在这里插入图片描述][147e2a45028e4c09a93c16435341b476.png]

（2）转发原理： 是由WEB服务器来控制的。A资源跳转到B资源，这个跳转动作是Tomcat服务器内部完成的

// 第一步：获取请求转发器对象
    	// 相当于把"/b"这个路径包装到请求转发器当中，实际上是把下一个跳转的资源路径告知给Tomcat服务器了
    	RequestDispatcher dispatcher = request.getRequestDispatcher("/b");
    	// 第二步：调用转发器的forward方法完成跳转/转发
    	dispatcher.forward(request,response);
                
    	// 第一步和第二步代码可以联合在一起。
    	 request.getRequestDispatcher("/b").forward(request,response);
    	
    //注意:转发的时候是一次请求,会将当前的request和response对象传递给下一个servlet.

（3）转发的下一个资源必须是一个Servlet吗？  
不一定，只要是Tomcat服务器当中的合法资源，都是可以转发的。例如：html…  
注意：转发的时候，路径的写法要注意，转发的路径以“/”开始，不加项目名。

### 11.2 重定向 ###

（1）工作原理:是浏览器完成的。具体跳转到哪个资源，是浏览器说了算。

![在这里插入图片描述][94602b48af3f4a7d8bbc46115de3c4a4.png]

（2）实现命令

response.sendRedirect("请求地址")
     //注意:重定向地址需要加上 项目名
     //因为浏览器发送请求是需要加上项目名的

（3）特征:  
1)请求地址：  
既可以把当前网站内部的资源文件地址发送给浏览器 （/网站名/资源文件名）  
也可以把其他网站资源文件地址发送给浏览器(http://ip地址:端口号/网站名/资源文件名)  
2)请求次数  
浏览器至少发送两次请求，但是只有第一次请求是用户手动发送。  
后续请求都是浏览器自动发送的。  
3) 请求方式：  
重定向解决方案中，通过地址栏通知浏览器发起下一次请求，因此  
通过重定向解决方案调用的资源文件接收的请求方式一定是【GET】  
（4）缺点:  
重定向解决方案需要在浏览器与服务器之间进行多次往返，大量时间  
消耗在往返次数上，增加用户等待服务时间

### 11.3 转发和重定向的区别 ###

（1）代码上的区别  
①转发

// 第一步：获取请求转发器对象
    	RequestDispatcher dispatcher = request.getRequestDispatcher("/b");
    	// 第二步：调用转发器的forward方法完成跳转/转发
    	dispatcher.forward(request,response);
                
    	// 第一步和第二步代码可以联合在一起。
    	 request.getRequestDispatcher("/b").forward(request,response);
    	// 转发的时候是一次请求,不管你转发了多少次，都是一次请求
    	// AServlet转发到BServlet，再转发到CServlet，不管转发了多少次，都是在同一个request当中
    	// 这是因为调用forward方法的时候，会将当前的request和response对象传递给下一个servlet.

②重定向(重新定方向)

// 重定向时的路径当中需要以项目名开始，或者说需要添加项目名
    // response对象将这个路径："/servlet10/b"响应给浏览器了
    // 浏览器又自发的向服务器发送了一次全新的请求：http://localhost:8080/servlet10/b
    // 所以浏览器一共发送了两次请求
    // 第一次请求：http://localhost:8080/servlet10/a
    // 第二次请求：http://localhost:8080/servlet10/b
    // 最终浏览器地址栏上显示的地址是最后那一次请求的地址，所以重定向会导致浏览器地址栏上的地址发生改变
    response.sendRedirect(request.getContextPath+"/b")

（2）形式上的区别  
①转发（一次请求）：在浏览器上发送的请求是：http://localhost:8080/servlet10/a,最终结束后，浏览器上的地址还是这个，没变  
②重定向（两次请求）：在浏览器上发送的请求是：http://localhost:8080/servlet10/a,最终在浏览器的地址栏上显示的地址是http://localhost:8080/servlet10/b  
（3）转发和重定向的本质区别？  
①转发：是由WEB服务器来控制的，A资源跳转到B资源，这个跳转动作是由Tomcat服务器内部来完成的  
②重定向：是浏览器完成的，具体跳转到哪个资源，是浏览器说了算  
（4）转发和重定向应该如何选择?  
● 如果在上一个Servlet当中向request域当中绑定了数据，希望从下一个Servlet当中把request域里面的数据取出来，使用转发机制。  
● 剩下所有的请求均使用重定向。(重定向使用较多。)  
● 他俩跳转的资源只要是服务器内部合法的资源即可。(Servlet,JSP,HTML)…  
● 转发会存在浏览器刷新问题，在浏览器中点击刷新会一直都会刷新之前的请求。

## 12.欢迎资源文件 ##

（1）对于一个webapp站点来说，我们是可以设置它的欢迎页面的。设置了欢迎页面之后，当你访问这个webapp  
的时候，或者访问这个web站点的时候，没有指定任何“资源路径”，这个时候会默认访问你的欢迎页面。  
①我们一般的访问方式是： http://localhost:8080/myWeb/index.html，这种方式是指定了要访问的就是login.html  
资源  
②如果我们访问的是： http://localhost:8080/myWeb，没有指定具体的资源路径，默认就会访问我们的欢迎页面

（2）当文件名设置为index.html的时候，不需要在web.xml文件中进行配置欢迎页面，这是因为Tomcat服务器已经提前配置好。配置欢迎页面有两个地方可以配置：  
①在webapp内部的/WEB-INF/web.xml文件中进行配置（属于局部配置）  
②在CATALINA\_HOME/conf/web.xml文件中进行配置（属于全局变量）  
注意：局部优先原则  
③一个webapp是可以设置多个欢迎页面的，越靠上的优先级越高，找不到继续往下找

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

④路径不要以“/”开始，路径默认从webapp的根下开始找  
（3）欢迎页就是一个资源，可以是静态资源，也可以是动态资源  
①静态资源：index.html  
②动态资源：Servlet类

## 12.关于WEB-INF目录 ##

● 在WEB-INF目录下新建了一个文件：welcome.html  
● 打开浏览器访问：http://localhost:8080/servlet07/WEB-INF/welcome.html 出现了404错误。  
● 注意：放在WEB-INF目录下的资源是受保护的。在浏览器上不能够通过路径直接访问。所以像HTML、CSS、JS、image等静态资源一定要放到WEB-INF目录之外。

[044f08f886cb4df8b46954effec258f4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/a1f6d69f76b346d2b36d9be08e2c4971.png
[3b61f6275f014e239d9d7dbdb6a96ed1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/e2ca913d9a54420bb43e2e8af2e6b050.png
[1f2612797a064347a26a231bdc11927c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/10fb1020f30644859ce7e49c75179051.png
[8c0c72cf73014a70a9d9b40c74ebc99d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/f91bef78a0aa44aea43e78ee0b33108c.png
[b82015ac75da431ca87e887a132f22db.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/068f4739778d49a5a48f669073460cec.png
[f6e009aedeb74df58a0c33282b5ea8af.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/6869f70215684780bbab13efff2c62be.png
[147e2a45028e4c09a93c16435341b476.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/758537c8f2b84a2db5164ab290d3e5b6.png
[94602b48af3f4a7d8bbc46115de3c4a4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/9c20a79be47641169830e15b0a96a9f6.png