Servlet的学习总结

一、什么是Servlet

Servlet运行在web服务器或应用服务器上的程序，它是作为来自web浏览器或其他http客户端的请求和http服务器上的数据库或应用程序之间的中间层。 使用servlet可以收集来自网页表单的用户输入，呈现来自数据库或者其他源的记录，还可以创建网页。

servlet的作用：处理客户端的请求

 

二、Servlet的生命周期

    实例化 --> 初始化 --> 服务 --> 销毁
    构造方法    int()    service()    destroy()

                          

• 调用init()方法进行初始化。
• 调用service()方法来处理客户端的请求。
• 调用destroy()方法终止（结束）。

最后，Servlet是由JVM的垃圾回收期进行来及回收的。

service() 方法是执行实际任务的主要方法。service() 方法检查 HTTP 请求类型（GET、POST、PUT、DELETE 等），并在适当的时候调用 doGet、doPost、doPut，doDelete 等方法。

1、doDelete
      

protected void doDelete(HttpServletRequest request,
            HttpServletResponse response) throws ServletException,
            IOException;

      被这个类的service方法调用，用来处理一个HTTP DELETE操作。这个操作允许客户端请求从服务器上删除URL。这一操作可能有负面影响，对此用户就负起责任。
      这一方法的默认执行结果是返回一个HTTP BAD_REQUEST错误。当你要处理DELETE请求时，你必须重载这一方法。

 

2、doGet
      

protected void doGet(HttpServletRequest request, 
            HttpServletResponse response) throws ServletException,
            IOException;

      被这个类的service方法调用，用来处理一个HTTP GET操作。这个操作允许客户端简单地从一个HTTP服务器“获得”资源。对这个方法的重载将自动地支持HEAD方法。
      GET操作应该是安全而且没有负面影响的。这个操作也应该可以安全地重复。
      这一方法的默认执行结果是返回一个HTTP BAD_REQUEST错误。

 

3、doHead
      

protected void doHead(HttpServletRequest request,
            HttpServletResponse response) throws ServletException,
            IOException;

      被这个类的service方法调用，用来处理一个HTTP HEAD操作。默认的情况是，这个操作会按照一个无条件的GET方法来执行，该操作不向客户端返回任何数据，而仅仅是返回包含内容长度的头信息。
      与GET操作一样，这个操作应该是安全而且没有负面影响的。这个操作也应该可以安全地重复。
      这个方法的默认执行结果是自动处理HTTP HEAD操作，这个方法不需要被一个子类执行。 

 

4、doOptions
      

protected void doOptions(HttpServletRequest request,
            HttpServletResponse response) throws ServletException,
            IOException;

      被这个类的service方法调用，用来处理一个HTTP OPTION操作。这个操作自动地决定支持哪一种HTTP方法。例如，一个Servlet写了一个HttpServlet的子类并重载了doGet方法，doOption会返回下面的头：
      Allow: GET,HEAD,TRACE,OPTIONS
      你一般不需要重载这个方法。

 

5、doPost
      

protected void doPost(HttpServletRequest request,
            HttpServletResponse response) throws ServletException,
            IOException;

      被这个类的service方法调用，用来处理一个HTTP POST操作。这个操作包含请求体的数据，Servlet应该按照他行事。
      这个操作可能有负面影响。例如更新存储的数据或在线购物。
      这一方法的默认执行结果是返回一个HTTP BAD_REQUEST错误。当你要处理POST操作时，你必须在HttpServlet的子类中重载这一方法。

 

6、doPut
      

protected void doPut(HttpServletRequest request, 
            HttpServletResponse response) throws ServletException,
            IOException;

      被这个类的service方法调用，用来处理一个HTTP PUT操作。这个操作类似于通过FTP发送文件。
      这个操作可能有负面影响。例如更新存储的数据或在线购物。
      这一方法的默认执行结果是返回一个HTTP BAD_REQUEST错误。当你要处理PUT操作时，你必须在HttpServlet的子类中重载这一方法。

 

7、doTrace
      

protected void doTrace(HttpServletRequest request,
            HttpServletResponse response) throws ServletException,
            IOException;

      被这个类的service方法调用，用来处理一个HTTP TRACE操作。这个操作的默认执行结果是产生一个响应，这个响应包含一个反映trace请求中发送的所有头域的信息。
      当你开发Servlet时，在多数情况下你需要重载这个方法。

 

8、getLastModified
      protected long getLastModified(HttpServletRequest request);
      返回这个请求实体的最后修改时间。为了支持GET操作，你必须重载这一方法，以精确地反映最后修改的时间。这将有助于浏览器和代理服务器减少装载服务器和网络资源，从而更加有效地工作。返回的数值是自1970-1-1日（GMT）以来的毫秒数。 
默认的执行结果是返回一个负数，这标志着最后修改时间未知，它也不能被一个有条件的GET操作使用。

 

9、service
     

 protected void service(HttpServletRequest request,
            HttpServletResponse response) throws ServletException,
            IOException;
      public void service(ServletRequest request, ServletResponse response)
            throws ServletException, IOException;

      这是一个Servlet的HTTP-specific方案，它分配请求到这个类的支持这个请求的其他方法。
      当你开发Servlet时，在多数情况下你不必重载这个方法。

 

三、Servlet的相关组件

servlet 有一些对象组件在 servlet 的各生命阶段提供一些职责服务，而从简化并方便开发者的使用。

1.ServletConfig

作用：1、可以获取Servlet配置文件的信息。2、可以获取ServletContext对象。

ServletConfig 对于这个对象，在 Servlet 接口中有这样一个相关方法：

ServletConfig getServletConfig();

而在 Servlet 的子类 GenericServlet 有这样的定义：

private transient ServletConfig config;

public void init(ServletConfig config) throws ServletException {
        this.config = config;
        this.init();
}

 

通过代码的分析，我们可以知道这个对象与 servlet 的关系是 1：1 的。

从配置文件的角度来说：web.xml 中的 的子标签 里的 key-value 式的参数就被保存在这个对象中。

另外：servlet 有一个 getInitParameter 方法， 这个方法的底层也是通过 ServletConfig 这个对象来实现的，代码如下：

public String getInitParameter(String name) {
    //就是这里了（1）
    ServletConfig sc = this.getServletConfig();
    if (sc == null) {
        throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));
    } else {
        //还有这（2）
        return sc.getInitParameter(name);
    }
}

2.ServletContext

ServletContext 又称上下文，它由容器所创建，并且是一个全局唯一的对象，可以被容器中所有的 servlet 所共享。

ServletContext 的主要作用有两个：

1. 实现 servlet 之间数据共享
2. 读取资源文件

一些代码示例：
通过ServletContext来获取全局的、整个Web应用的初始化参数：

<context-param>
    <param-name>name</param-name>
    <param-value>gavin</param-value>
</context-param>

利用ServletContext对象读取资源文件（比如properties文件）

// 这种方法的默认读取路径就是Web应用的根目录
InputStream stream = this.getServletContext().getResourceAsStream("dbinfo.properties");
// 创建属性对象
Properties properties = new Properties();
properties.load(stream);
String name = properties.getProperty("name");
String password = properties.getProperty("password");
out.println("name="+name+";password="+password);

注意：如果这个文件放在了src目录下，这时就不能用ServletContext来读取了，必须要使用类加载器去读取。

// 类加载器的默认读取路径是src根目录
InputStream stream = MyServlet.class.getClassLoader().getResourceAsStream("dbinfo.properties")

3.Request

Servlet 客户端 HTTP 请求：https://www.w3cschool.cn/servlet/servlet-client-request.html

4.Response

Servlet 服务器 HTTP 响应：https://www.w3cschool.cn/servlet/servlet-server-response.html

5.Session

Session 与 Cookie 从来都是一起“出生入死”。由于 http 是无状态协议，seesion 和 cookies 的出现就是为了弥补这一点的。不同的是：cookie 是客户端保存状态，session 是服务端保存状态。

更多详解参考理解HTTP session原理及应用：https://www.cnblogs.com/x_wukong/p/3929654.html

6.Filter

filter 是一段可以重复使的代码，它的作用是在拦截 request 和 response 并调整它们。在 web 容器启动之后，处理客户端请求之前，容器必须为过滤器列表中每个过滤器实例化一个对象并初始化，然后调用映射到的过滤器的 doFilter 方法。

Servlet编写Filter可以参考： https://www.runoob.com/servlet/servlet-writing-filters.html

7.Listener

监听器监听的是事件，servlet 提供的事件类型如下：

7.1 servlet上下文事件

1. ServletContextListener Servlet上下刚刚创建，接收第一个请求，上下文关闭
2. ServletContextAttributeListener 监听Servlet 上下文的属性已添加、删除、或替换

7.2 http 会话事件

1. HttpSessionListener 会话已创建、销毁或超时
2. HttpSessionAttributeListener 已经在 HttpSession 上添加、移除、或替换属性
3. httpHttpSessionIdListener HttpSession 的 ID 将被改变
4. HttpSessionActivationListener HttpSession 已被激活或钝化
5. HttpSessionBindingListener 对象已经从 HttpSession 绑定或解除绑定

7.3 servlet请求事件

1. ServletRequestListener 一个 servlet 请求已经开始由 Web 组件处理
2. ServletRequestAttributeListener 已经在 ServletRequest 上添加、移除、或替换属性。
3. AsyncListener 超时、连接终止或完成异步处理

四、Servlet的运作流程

1、web.xml 启动

1. 容器启动的过程中读取 web.xml 的配置
2. 创建一个全局唯的 ServletContext 对象，并将 标签中的参数初始化到这个对象中
3. 定位（加载）各 servlet，filter， listener 的 class 文件
4. 如果配置了 ServletContextListener，容器启动之后会运行这个监听器中的代码来为容器做一些初始化动作
5. 容器启动完成
6. 当第一个请求过来时，容器通过 url 映射找到对应的 servlet 的 class 文件，实例化一个 servlet 对象，然后调用这个对象的 init 方法初始化它， 最后调用它的 service 方法来处理请求。（这里用到了模板方法模式）
7. 最后当容器想要关闭时，会先调用每个 servlet 的 destroy 方法，以释放一些资源。

    <!-- druid 监控 servlet -->
	<servlet>
		<servlet-name>DruidStatView</servlet-name>
		<servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>DruidStatView</servlet-name>
		<url-pattern>/druid/*</url-pattern>
	</servlet-mapping>
	<!-- 文件下载 -->
	<servlet>
		<servlet-name>DownloadFileServlet</servlet-name>
		<servlet-class>com.linewell.pbd.servlet.DownloadFileServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>DownloadFileServlet</servlet-name>
		<url-pattern>/downloadFile</url-pattern>
	</servlet-mapping>

2、非web.xml启动

不是说项目中没有 web.xml 文件，而是这个文件中什么初始化配置都没有只有最外层的 标签。

1. 类路径下添加目录：META-INF/services
2. 自定义一个类实现 ServletContainerInitializer 接口
3. 在类上以 @HandlesTypes(value = {xxx.class, xxx.class}) 这样的 annotation 标注感兴趣的类
4. 在 onStartup(Set<Class<?>> set, ServletContext servletContext) 方法中，感兴趣的类会被放到第一个参数 set 中传过来。可以存这个方法中对 servletContext 做一些处理。如：添加 servlet ， listener 或者 filter。

SpingBoot项目整合Servlet也有两种方式，详解在 https://blog.csdn.net/u012206730/article/details/95971660

五、Servlet的单实例多线程

不同的用户同时对同一个业务（如注册）发出请求，那这个时候容器里产生的有是几个servlet实例呢？

答案是：只有一个servlet实例。一个servlet是在第一次被访问时加载到内存并实例化的。同样的业务请求共享一个servlet实例。不同的业务请求一般对应不同的servlet。

由于Servlet/JSP默认是以多线程模式执行的，所以，在编写代码时需要非常细致地考虑多线程的安全性问题。

 JSP的中存在的多线程问题： 

当客户端第一次请求某一个JSP文件时，服务端把该JSP编译成一个CLASS文件，并创建一个该类的实例，然后创建一个线程处理CLIENT端的请求。如果有多个客户端同时请求该JSP文件，则服务端会创建多个线程。每个客户端请求对应一个线程。以多线程方式执行可大大降低对系统的资源需求,提高系统的并发量及响应时间。、

 对JSP中可能用的的变量说明如下: 

实例变量: 实例变量是在堆中分配的,并被属于该实例的所有线程共享，所以不是线程安全的。 
JSP系统提供的8个类变量 
JSP中用到的OUT,REQUEST,RESPONSE,SESSION,CONFIG,PAGE,PAGECONXT是线程安全的(因为每个线程对应的request，respone对象都是不一样的，不存在共享问题), APPLICATION在整个系统内被使用,所以不是线程安全的。
局部变量: 局部变量在堆栈中分配,因为每个线程都有它自己的堆栈空间,所以是线程安全的. 
静态类: 静态类不用被实例化,就可直接使用,也不是线程安全的. 
外部资源: 在程序中可能会有多个线程或进程同时操作同一个资源(如:多个线程或进程同时对一个文件进行写操作).此时也要注意同步问题. 

Servlet单实例多线程机制：

Servlet采用多线程来处理多个请求同时访问。servlet依赖于一个线程池来服务请求。线程池实际上是一系列的工作者线程集合。Servlet使用一个调度线程来管理工作者线程。 
        当容器收到一个Servlet请求，调度线程从线程池中选出一个工作者线程,将请求传递给该工作者线程，然后由该线程来执行Servlet的service方法。当这个线程正在执行的时候,容器收到另外一个请求,调度线程同样从线程池中选出另一个工作者线程来服务新的请求,容器并不关心这个请求是否访问的是同一个Servlet.当容器同时收到对同一个Servlet的多个请求的时候，那么这个Servlet的service()方法将在多线程中并发执行。 
         Servlet容器默认采用单实例多线程的方式来处理请求，这样减少产生Servlet实例的开销，提升了对请求的响应时间，对于Tomcat可以在server.xml中通过<Connector>元素设置线程池中线程的数目。

六、如何开发线程安全的Servlet

1、实现 SingleThreadModel 接口 
　　该接口指定了系统如何处理对同一个Servlet的调用。如果一个Servlet被这个接口指定,那么在这个Servlet中的service方法将不会有两个线程被同时执行，当然也就不存在线程安全的问题。这种方法只要将前面的Concurrent Test类的类头定义更改为： 

Public class Concurrent Test extends HttpServlet implements SingleThreadModel {

…………

}  

2、同步对共享数据的操作 
　　使用synchronized 关键字能保证一次只有一个线程可以访问被保护的区段

3、避免使用实例变量 

本实例中的线程安全问题是由实例变量造成的，只要在Servlet里面的任何方法里面都不使用实例变量，那么该Servlet就是线程安全的。 

对上面的三种方法进行测试，可以表明用它们都能设计出线程安全的Servlet程序。但是，如果一个Servlet实现了SingleThreadModel接口，Servlet引擎将为每个新的请求创建一个单独的Servlet实例，这将引起大量的系统开销。SingleThreadModel在Servlet2.4中已不再提倡使用；同样如果在程序中使用同步来保护要使用的共享的数据，也会使系统的性能大大下降。这是因为被同步的代码块在同一时刻只能有一个线程执行它，使得其同时处理客户请求的吞吐量降低，而且很多客户处于阻塞状态。另外为保证主存内容和线程的工作内存中的数据的一致性，要频繁地刷新缓存,这也会大大地影响系统的性能。所以在实际的开发中也应避免或最小化 Servlet 中的同步代码；在Serlet中避免使用实例变量是保证Servlet线程安全的最佳选择。从Java 内存模型也可以知道，方法中的临时变量是在栈上分配空间，而且每个线程都有自己私有的栈空间，所以它们不会影响线程的安全。

 

更加详细的说明：

1. 变量的线程安全：这里的变量指字段和共享数据(如表单参数值)。 
   a，将 参数变量 本地化。多线程并不共享局部变量.所以我们要尽可能的在servlet中使用局部变量。 
             例如：

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

   b，使用同步块Synchronized，防止可能异步调用的代码块。这意味着线程需要排队处理。在使用同板块的时候要尽可能的缩小同步代码的范围，不要直接在sevice方法和响应方法上使用同步，这样会严重影响性能。 

2,属性的线程安全：ServletContext，HttpSession，ServletRequest对象中属性。 
         ServletContext：（线程是不安全的） 
         ServletContext是可以多线程同时读/写属性的，线程是不安全的。要对属性的读写进行同步处理或者进行深度Clone()。所以在Servlet上下文中尽可能少量保存会被修改（写）的数据，可以采取其他方式在多个Servlet中共享，比方我们可以使用单例模式来处理共享数据。 
         HttpSession：（线程是不安全的） 
         HttpSession对象在用户会话期间存在，只能在处理属于同一个Session的请求的线程中被访问，因此Session对象的属性访问理论上是线程安全的。 
         当用户打开多个同属于一个进程的浏览器窗口，在这些窗口的访问属于同一个Session，会出现多次请求，需要多个工作线程来处理请求，可能造成同时多线程读写属性。这时我们需要对属性的读写进行同步处理：使用同步块Synchronized和使用读/写器来解决。 
        ServletRequest：（线程是安全的） 
        对于每一个请求，由一个工作线程来执行，都会创建有一个新的ServletRequest对象，所以ServletRequest对象只能在一个线程中被访问。ServletRequest是线程安全的。注意：ServletRequest对象在service方法的范围内是有效的，不要试图在service方法结束后仍然保存请求对象的引用。 
3，使用同步的集合类： 
  使用Vector代替ArrayList，使用Hashtable代替HashMap。 
4，不要在Servlet中创建自己的线程来完成某个功能。 
  Servlet本身就是多线程的，在Servlet中再创建线程，将导致执行情况复杂化，出现多线程安全问题。 
5，在多个servlet中对外部对象(比方文件)进行修改操作一定要加锁，做到互斥的访问。 
6，javax.servlet.SingleThreadModel接口是一个标识接口，如果一个Servlet实现了这个接口，那Servlet容器将保证在一个时刻仅有一个线程可以在给定的servlet实例的service方法中执行。将其他所有请求进行排队。

具体更多详解可参考：https://blog.csdn.net/xionglangs/article/details/72472834

 

 

Servlet的线程安全：

不要使用全局变量，要使用局部变量

 

八、Servlet的三种创建方式

1、实现javax.servlet.Servlet接口
2、继承javax.servlet.GenericServlet抽象类(适配器模式)
3、继承javax.servlet.http.HttpServlet抽象类(模板设计模式)

九、与Servlet相关的对象

1. Servlet接口-------------->javax.servlet.Servlet;
2. GenericServlet抽象类----->javax.servlet.GenericServlet;
3. HttpServlet抽象类-------->javax.servlet.http.HttpServlet;
4. ServletConfig接口-------->javax.servlet.ServletConfig;
5.  ServletContext接口------->javax.servlet.ServletContext;
6. ServletRequest接口------->javax.servlet.ServletRequest;
7. ServletResponse接口------>javax.servlet.ServletResponse;
8. HttpServletRequest接口--->javax.servlet.http.HttpServletRequest;
9. HttpServletResponse接口-->javax.servlet.http.HttpServletResponse;
10. RequestDispatcher接口---->javax.servlet.RequestDispatcher;