JavaWeb之Servlet概述

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类之间的对照关系。

<?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">
</web-app>

（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都对应一个servlet-mapping -->
	<servlet>
		<servlet-name>demoServlet</servlet-name>
		<!--这个位置必须是带有包名的全限定类名-->
		<servlet-class>com.se.HelloServlet</servlet-class>
	</servlet>
	<!--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目录结构应该是怎样的？

webapproot
     |------WEB-INF
     		  |------classes(存放字节码)
     		  |------lib(第三方jar包)
     		  |------web.xml(注册Servlet)
     |------html
     |------css
     |------javascript
     |------image
     ....

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都可以
    

（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.执行步骤

（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.执行原理

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

5.1 Request和Response原理

（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对象和请求路径之间的关系

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体系结构

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共享同一份数据。

（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）工作原理:是浏览器完成的。具体跳转到哪个资源，是浏览器说了算。

（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目录之外。