Servlet

Servlets perform the following major tasks:

• Read the explicit data sent by the clients (browsers). This includes an HTML form on a Web page or it could also come from an applet or a custom HTTP client program.
  
• Read the implicit HTTP request data sent by the clients (browsers). This includes cookies, media types and compression schemes the browser understands, and so forth.
  
• Process the data and generate the results. This process may require talking to a database, executing an RMI or CORBA call, invoking a Web service, or computing the response directly.
  
• Send the explicit data (i.e., the document) to the clients (browsers). This document can be sent in a variety of formats, including text (HTML or XML), binary (GIF images), Excel, etc.
  
• Send the implicit HTTP response to the clients (browsers). This includes telling the browsers or other clients what type of document is being returned (e.g., HTML), setting cookies and caching parameters, and other such tasks.
  

参考：
Servlets - Overview: http://www.tutorialspoint.com/servlets/servlets_overview.htm

To deploy and run a servlet, a web container must be used. A web container (also known as a servlet container) is essentially the component of a web server that interacts with the servlets. The web container is responsible for managing the lifecycle of servlets, mapping a URL to a particular servlet and ensuring that the URL requester has the correct access rights.

参考：https://en.wikipedia.org/wiki/Java_servlet#History

Servert 3.0 新功能，可参考：
http://stackoverflow.com/questions/1638865/what-are-the-differences-between-servlet-2-5-and-3
http://javabeat.net/new-features-in-servlets-3-0/

The service() method is the main method to perform the actual task. The servlet container (i.e. web server) calls the service() method to handle requests coming from the client( browsers) and to write the formatted response back to the client.

Each time the server receives a request for a servlet, the server spawns a new thread and calls service. The service() method checks the HTTP request type (GET, POST, PUT, DELETE, etc.) and calls doGet, doPost, doPut, doDelete, etc. methods as appropriate.

Here is the signature of this method:

public void service(ServletRequest request,
                    ServletResponse response)
      throws ServletException, IOException{
}

The service () method is called by the container and service method invokes doGe, doPost, doPut, doDelete, etc. methods as appropriate. So you have nothing to do with service() method but you override either doGet() or doPost() depending on what type of request you receive from the client.

The following figure depicts a typical servlet life-cycle scenario.

• First the HTTP requests coming to the server are delegated to the servlet container.
  
• The servlet container loads the servlet before invoking the service() method.
  
• Then the servlet container handles multiple requests by spawning multiple threads, each thread executing the service() method of a single instance of the servlet.
  

和配置 sevlet 类似，我们可以在 web.xml 的<web-app>...</web-app>之间配置 filter。如：

<filter>
   <filter-name>AuthenticationFilter</filter-name>
   <filter-class>com.xxx.servlet.filters.AuthenticationFilter</filter-class>
</filter>
<filter-mapping>
   <filter-name>AuthenticationFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

上面例子中，所有请求都会先经过 AuthenticationFilter 的处理。

filter 简单实例可参考：http://www.tutorialspoint.com/servlets/servlets-writing-filters.htm

下面例子摘自：https://www.mkyong.com/servlet/what-is-listener-servletcontextlistener-example/

首先，创建一个类。

package com.mkyong.listener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class MyAppServletContextListener implements ServletContextListener{

    @Override
    public void contextDestroyed(ServletContextEvent arg0) {
    System.out.println("ServletContextListener destroyed");
    }

    //Run this before web application is started
    @Override
    public void contextInitialized(ServletContextEvent arg0) {
        System.out.println("ServletContextListener started");
    }
}

然后，在 web.xml 中进行相关配置，例如：

<web-app ...>
  <listener>
    <listener-class>
       com.mkyong.listener.MyAppServletContextListener
    </listener-class>
  </listener>
</web-app>

启动 tomcat 后，会有类似下面的输出：

Dec 2, 2009 10:11:46 AM org.apache.catalina.core.StandardEngine start
INFO: Starting Servlet Engine: Apache Tomcat/6.0.20

ServletContextListener started   <-------------- Your code here, before we application --->

Dec 2, 2009 10:11:46 AM org.apache.coyote.http11.Http11Protocol start
INFO: Starting Coyote HTTP/1.1 on http-8080
//...
INFO: Server startup in 273 ms

Servlet 是运行在 Servlet 容器中的，常用的 Tomcat、JBoss、WebLogic 都是 Servlet 容器，其生命周期是由容器来管理。Servlet 的生命周期通过 java.servlet.Servlet 接口中的 init(), service(), 和 destroy() 方法表示。Servlet 的生命周期有四个阶段：加载并实例化、初始化、请求处理、销毁。

当客户端第一次请求 Servlet 的时候，Tomcat 会根据 web.xml 配置文件实例化 Servlet。当又有一个客户端访问该 Servlet 的时候，不会再实例化该 Servlet，也就是多个线程在使用这个实例。

Serlvet 采用多线程来处理多个请求同时访问，Tomcat 容器维护了一个线程池来服务请求。线程池实际上是等待执行代码的一组线程叫做工作组线程(Worker Thread)，Tomcat 容器使用一个调度线程（Dispatcher Thead）来管理工作组线程。

当容器收到一个 Servlet 请求，调度线程从线程池中选出一个工作组线程，将请求传递给该线程，然后由该线程来执行 Servlet 的 service() 方法。当这个线程正在执行的时候，容器收到另一个请求，调度线程将从线程池中选出另外一个工作组线程来服务这个新的请求，容器并不关心这个请求是否访问的是同一个 Servlet 还是另一个 Servlet。 当容器同时收到对同一个 Servlet的多个请求的时候，那这个Servlet的 service() 方法将在多线程中并发地执行。 所以，Servlet不是线程安全的。