Servlet学习

什么是Servlet

定义： Servlet是基于java技术的web组件，由容器管理并产生动态的内容。Servlet与客户端通过Servlet容器实现请求/响应模型进行交互。

！！！：Servlet不是从命令行启动的，而是由包含Java虚拟机的Web服务器进行加载。

Java Servlet是运行在web服务器或应用上的程序，它是作为Web浏览器或其他HTTP客户端的请求和HTTP服务器上的数据库或应用程序之间的中间层。
使用Servlet，可以收集来自网页表单的用户输入，呈现来自数据库或其他源的记录，还可以动态创建网页。
Java Servlet通常情况下与使用CGI（Common Gateway Interface,公共网关接口）实现的程序可以达到异曲同工的效果。但是相比于CGI，Servlet有以下几点优势：
（1）性能明显更好
（2）Servlet在web服务器的地址空间内执行。这样它就没有必要再创建一个单独的进程来处理每个客户端请求
（3）服务器上的java安全管理器执行了一系列限制，以保护服务器计算机上的资源。因此Servlet是可信的。
（4）java类库的全部功能对Servlet来说是可用的。它可以通过sockets和RMI
机制与apples、数据库或其他软件进行交互。

Servlet架构

Servlet任务

（1）读取客户端（浏览器）发送的显式的数据。这包括网页上的html表单，也可以是来自applet或自定义的HTTP客户端程序的表单
（2）读取客户端（浏览器）发送的隐式的HTTP请求数据。这包括cookies、媒体类型和浏览器能理解的压缩格式等等
（3）处理数据并生成结果。这个过程可能需要访问数据库，执行RMI或CORBA调用，调用web服务，或者直接计算得出对应的响应
（4）发送显式的数据（即文档）到客户端（浏览器）。该文档的格式可以是多种多样的，包括文本文件（html或xml）、二进制文件（GIF图像）、Excel等。
（5）发送隐式的HTTP响应到客户端（浏览器）。这包括告诉浏览器或其他客户端被返回的文档类型（例如html），设置cookies和缓存参数，以及其他类新的任务。

Servlet包

Java Servlet是运行在带有支持Java Servlet规范的解释器的web服务器上的java类。
Servlet可以使用javax.servlet 和javax.servlet.http包创建，它是java企业版的标准组成部分，java企业版是支持大型开发项目的java类库的扩展版本。
这些类实现Java Servlet和JSP规范。在写本教程的时候，二者相应的版本分别是Java Servlet2.5和JSP2.1
Java Servlet就像任何其他的java类一样已经被创建和编译。在安装Servlet包并把他们添加到计算机的Classpath类路径中之后，就可以通过JDK的java编译器或其他任何java编译器来编译Servlet。

Servlet的工作原理

Servlet接口定义了Servlet与servlet容器之间的契约。这个契约是：Servlet容器将Servlet类载入内存，并产生Servlet实例和调用它具体的方法。但是，在一个应用程序中，每种Servlet只能有一个实例。

用户请求致使Servlet容器调用Servlet的Service（）方法，并传入一个ServletRequest对象和一个ServletResponse对象。ServletRequest对象和ServletResponse对象都是由Servlet容器（例如Tomcat）封装好的，并不需要程序员去实现。程序员可以直接使用这两个对象。
ServletRequest对象封装了当前的Http请求，因此，开发人员不必解析和操作原始的Http数据。ServletResponse表示当前用户的Http响应，程序员只需直接操作ServletResponse对象就能把响应轻松地发回给客户。
对每一个应用程序，Servlet容器还会创建一个ServletContext对象。这个对象封装了上下文（应用程序）的环境详情。每个应用程序只有一个ServletContext。每个Servlet对象也都有一个封装Servlet配置的ServletConfig对象。

Servlet接口中定义的方法

public interface Servlet{
    void init(ServletConfig var1) throws ServletExcetion;
    ServletConfig getServletConfig();
    void service(ServletRequest var1, ServletRequest var2) throws ServletException, IOException;
    String getServletInfo();
    void destroy();
    }

Servlet的其它两个方法

getServletInfo()，这个方法会返回Servlet的一段描述，可以返回一段字符串
getServletConfig()，这个方法会返回由Servlet容器传给init()方法的ServletConfig对象

ServletRequest接口

Servlet容器对于接收到的每一个Http请求，都会创建一个ServletRequest对象，并把这个对象传递给Servlet的service()方法。其中，ServletRequest对象内封装了这个请求的许多详细信息。

public interface ServletRequest{
    int getContentLength();
    String getContentType();
    String getParameter(String var1);
    }
   

其中，getParameter是在ServletRequest中最常用的方法，可用于查询字符串的值。

ServletResponse接口

javax.servlet.ServletResponse接口表示一个Servlet响应，在调用Servlet的service()方法前，Servlet容器会创建一个ServletResponse对象，并把它作为第二个参数传给Service（）方法，ServletResponse隐藏了向浏览器发送响应的复杂过程。

public interface ServletResponse{
    String getCharacterEncoding();
    String getContentType();
    ServletOutputStream getOutputStream() throws IOException;
    PrintWriter getWriter() throws IOException;
    void setCharacterEncoding(String var1);
    void setContentLength(String var1);
    void setBufferSize(String var1);
    int getBufferSize();
    void flushBuffer() throws IOException;
    void resetBuffer();
    boolean isCommitted();
    void reset();
    void setLocale(Locale var1);
    Locale getLocale();
    

其中的getWriter方法，它返回了一个可以向客户端发送文本的Java.io.PrintWriter对象。默认情况下，PrintWriter对象使用ISO-8859-1编码（该编码在输入中文时会发生乱码）。

在向客户端发送响应时，大多数都是使用该对象向客户端发送HTML。
还有一个方法也可以用来向浏览器发送数据，getOutputStream,这是一个二进制流对象，因此这个方法是用来发送二进制数据的。

在发送任何HTML之前，应该先调用setContentType()方法，设置响应的内容类型，并将“text/html”作为一个参数传入，这是在告诉浏览器相应的内容类型为HTML，需要以HTML的方法解释响应内容而不是普通的文本，或者也可以加上“charset=UTF-8”改变响应的编码方式以防止中文乱码现象。

ServletConfig接口

当Servlet容器初始化Servlet时，Servlet容器会给Servlet的init()方式传入一个ServletConfig对象。

String getServletName();
//获得Servlet在web.xml中配置的name值
String getInitParameter(String name);
//获得Servlet的初始化参数
Enumeration getInitParameterNames();
//获得所有Servlet的初始化参数的名称

ServletContext对象

ServletContext对象表示Servlet应用程序。每个Web应用程序都只有一个ServletContext对象。在将一个应用程序同时部署到多个容器的分布式环境中，每台虚拟机上的web应用都会有一个ServletContext对象。
通过在ServletConfig中调用getServletContext()方法，也可以获得ServletContext对象。
因为有了ServletContext对象，就可以共享从应用程序中的所有资料处访问到的信息，并且可以动态注册Web对象。前者将对象保存在ServletContext中的一个内部Map中。保存在ServletContext中的对象被称作属性。
ServletContext中的下列方法负责属性：

Object getAttribute(String var1);
Enumeration<String> getAttibuteName();
void setAtttribute(String var1,Object var2);
void removeAttribute(String var1);

GenericServlet抽象类

前面编写Servlet一直是通过Servlet接口来编写的，但是，使用这种方法，则必须要实现Servlet接口中定义的所有的方法，即使有一些方法中没有任何东西也要去实现并且还需要自己手动地维护ServletConfig这个对象的引用，因此，这样去实现Servlet是比较麻烦的。

void init(ServletConfig var1) throws ServletException;

GenericServlet抽象类的出现很好地解决了这个问题，本着代码简洁的原则，GenericServlet实现了Servlet和ServletConfig接口，下面是GenericService抽象类的具体代码：

public abstract class GenericServlet implements Servlet, ServletConfig,Serializable{
 
    private static final String LSTRING_FILE = "javax.servlet.LocalStrings";
    private static ResourceBundle lStrings = ResourceBundle.getBundle("javax.servlet.LocalStrings");
    private transient ServletConfig config;
    
    public GenericServlet() {    
    }
    
    public void destroy() {  
    }
    
    public String getInitParameter(String name) {
	ServletConfig sc = this.getServletConfig();
	if (sc == null) {                                
	    throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));        
	} else {            
	    return sc.getInitParameter(name);        
	}    
    }
    public Enumeration<String> getInitParameterName(){
        ServletConfig sc = this.getServletConfig();
        if(sc == null){
           throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));        
           } else {            
           return sc.getInitParameterNames();        
           }
   }
   
    public ServletConfig getServletConfig(){
        return this.config;
    }
    public ServletContext getServletContext(){
        ServletConfig sc = this.getServletConfig();
        if(sc == null){
           throw new IlleagalStateException(lStrings.getString("err.servlet_config_not_initialized"));
        } else {
            return sc.getServletContext();        
            }    
    }
    public String getServletInfo() {        
    return "";    
    }
    public void init(ServletConfig config) throws ServletException {        
    this.config = config;        
    this.init();    
    }
    public void init() throws ServletException {    
    }
    public void log(String msg) {        
    this.getServletContext().log(this.getServletName() + ": " + msg);    
    }
    public void log(String message, Throwable t) {        this.getServletContext().log(this.getServletName() + ": " + message, t);    
    }
    public abstract void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
 public String getServletName() {        
     ServletConfig sc = this.getServletConfig();        
     if (sc == null) {            
         throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));        
     } else {            
         return sc.getServletName();        
 	}
 	}
}
		      

其中，GenericServlet抽象类相比于直接实现Servlet接口，有以下几个好处：

（1）为Servlet接口中的所有方法提供了默认的实现，则程序员需要什么就直接改什么，不再需要把所有的方法都自己实现了。
（2）提供方法，包围ServletConfig对象中的方法。
（3）将init()方法中的ServletConfig参数赋给了一个内部的ServletConfig引用从而来保存ServletConfig对象，不需要程序员自己去维护ServletConfig

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

GenericService抽象类中还存在另一个没有任何参数的Init()方法：

public void init() throws ServletException{
}

原因： 由于抽象类是无法直接产生实例的，需要另一个类去继承这个抽象类，那么就会发生方法覆盖的问题，如果在类中覆盖了GenericServlet抽象类的init()方法，那么程序员就必须手动地去维护ServletConfig对象，还得调用super.init(servletConfig)方法去调用父类的GenericServlet的初始化方法来保存ServletConfig对象，这样会给程序员带来很大的麻烦。GenericServlet提供的第二个不带参数的init()方法，就是为了解决上述问题。

这个不带参数的init()方法，是在ServletConfig对象被赋给ServletConfig引用后，由第一个才参数的init（ServletConfig servletconfig）方法方法调用的，那么这意味着当程序员如果需要覆盖这个GenerivServlet法人初始化方法，则只需要覆盖那个不带参数的init()方法就好了，此时servletConfig对象仍然有GenericServlet保存着。

通过扩展GenericServlet抽象类，就不需要覆盖没有计划改变的方法。因此，代码将会变得更加的简洁，程序员的工作也会减少很多。

然而，虽然GenricServlet是对Servlet一个很好的加强，但是也不经常用，因为他不像HttpServlet那么高级。HttpServlet才是主角，在现实的应用程序中被广泛使用。那么我们接下来就看看传说中的HttpServlet到底厉害在哪里吧。

javax.servlet.http包内容

之所以HttpServlet要比GenericServlet强大，是因为HttpServlet是由GenericServlet抽象类扩展而来的，其声明如下：

public abstract class HttpServlet extends GenericServlet implements Serializable

HttpServlet之所以运用广泛的另一个原因是现在大部分的应用程序都要与HTTP结合起来使用。这意味着我们可以利用HTTP的特性完成更多更强大的任务。javax.servlet.http包是Servlet API包中的第二个包，其中包含了用于编写Servlet应用程序的类和接口。
java.servlet.http中的许多类型都覆盖了javax.servlet类型

HttpServlet抽象类

HttpServlet抽象类是基于GenericServlet抽象类而来的。使用HttpServlet抽象类时，还需要借助分别代表Servlet请求和Servlet响应的HttpServletRequest和ServletResponse对象。

HttpServletRequest接口扩展于javax.servlet.ServletRequest接口，HttpServletResponse接口扩展于javax.servlet.servletResponse接口。

public interface HttpServletRequest extends ServletRequest

public interface HttpServletResponse extends ServletResponse

HttpServlet抽象类覆盖了GenericServlet抽象类中的Service()方法，并且添加了一个自己独有的service() HttpServletRequest ,HttpServletResponse 方法

GenericServlet抽象类中定义的service方法

public abstract void service(ServletRequest var1, SrvletResponse var2) throws ServletException, IOException;

可以看到这是一个抽象方法，要HttpServlet自己去实现这个service方法

public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException{
    HttpServletRequest request;
    HttpServletResponse response;
    try{
        request = (HttpServletRequest)req;
        response = (HttpServletResponse)res;
    } catch (ClassCastException vvar6){
        throws new ServletException("non-HTTP request or response");
    }
    this.service(request, response);
 }

我们发现，HttpServlet中的service方法把接收到的ServletRequsest类型的对象转换成了HttpServletRequest类型的对象，把ServletResponse类型的对象转换成了HttpServletResponse类型的对象。之所以能够这样强制的转换，是因为在调用Servlet的Service方法时，Servlet容器总会传入一个HttpServletRequest对象和HttpServletResponse对象，预备使用HTTP。因此，转换类型当然不会出错了。

转换之后，service方法把两个转换后的对象传入了另一个service方法，那么我们再来看看这个方法是如何实现的：

protected void service(HttpServletRequest req, HttpResponse resp) throws ServletException

Servlet的生命周期

init(),service(),destroy()是Servlet生命周期的方法。代表了Servlet从“出生”到“工作”再到“死亡的”过程。Servlet容器（例如Tomcat）会根据下面的规则来调用这三个方法：
1.init(),当Servlet第一次被请求时，Servlet容器就会开始调用这个方法来初始化一个Servlet对象出来，但是这个方法在后续请求中不会再被Servlet容器调用。可以使用init()方法来执行相应的初始化工作。调用这个方法时，Servlet容器会传入一个ServletConfig对象进来从而对Servlet对象进行初始化。
2.service()方法，每当请求Servlet时，容器就会调用这个方法。第一次请求时，Servlet容器会调用init()方法进行初始化一个Servlet对象出来，然后调用它的service()方法进行工作，但在后续请求中只会使用service()方法。
3.destroy，当要销毁Servlet时，Servlet容器就会调用这个方法。在卸载应用程序或者关闭Servlet容器时，就会发生这种情况，一般在这个方法中会写一些清除代码。

本文参考链接