Servlet简介及生命周期

                     Servlet简介及生命周期                     

1.Servlet简介

    Servlet是可部署在Web服务器上的Java程序.

        Servlet是对支持Java的服务器的一般扩充。它最常见的用途是扩展Web服务器，提供非常安全的、

        可移植的、易于使用的CGI替代品。它是一种动态加载的模块，为来自Web服务器的请求提供服务。

        它完全运行在Java虚拟机上。由于它在服务器端运行，因此它不依赖于浏览器的兼容性。

    servlet容器：负责处理客户请求、把请求传送给servlet并把结果返回给客户。

        不同程序的容器实际实现可能有所变化，但容器与servlet之间的接口是由servlet API定义好的，

        这个接口定义了servlet容器在servlet上要调用的方法及传递给servlet的对象类。

2.servlet编程，需要引用以下两个类和接口：javax.servlet 和javax.servlet.http，在这些类和接口中，javax.servlet.Servlet接口尤为重要。

        所有的 servlet 必须实现这个接口或继承已实现这个接口的类。

3.Servlet 接口有五个方法，如下：

        1)  public void init(ServletConfig config) throws ServletException

        2)  public void service(ServletRequest request, ServletResponseresponse) throws  ServletException, java.io.IOException 

        3)　public void destroy()

        4)　public ServletConfig getServletConfig()

        5)　public java.lang.String getServletInfo() 

4.init、service和 destroy 方法是 Servlet 生命周期的方法。当 Servlet 类实例化后，容器加载 init，以通知 servlet 它已进入服务行列。

        init 方法必须被加载，Servelt 才能接收和请求。如果要载入数据库驱动程序、初始化一些值等等，程序员可以重写这个方法。

        在其他情况下，这个方法一般为空。

5.service 方法由 Servlet 容器调用，以允许 Servlet 响应一个请求。Servlet 容器传递 javax.servlet.ServletRequest 对象和 

        javax.servlet.ServletResponse 对象。ServletRequest 对象包含客户端 HTTP 请求信息，ServletResponse 则封装servlet 响应。

        通过这两个对象，您可以写一些需要 servlet怎样服务和客户怎样请求的代码。

6.从service中删除Servlet实例之前，容器调用destroy方法。在servlet容器关闭或servlet 容器需要更多的内存时，就调用它。

        这个方法只有在servlet 的service 方法内的所有线程都退出的时候，或在超时的时候才会被调用。在 servlet 容器调用 destroy方法之后，

        它将不再调用 servlet的 service方法。

7.destroy 方法给了servlet机会，来清除所有空闲资源（比如：内存，文件处理和线程），以确保在内存的持续状态和 servlet的当

        前状态是同步的。

servlet的生命周期：

        1、servlet容器创建servlet的一个实例

        2、容器调用该实例的init()方法

        3、如果容器对该servlet有请求，则调用此实例的service()方法

        4、容器在销毁本实例前调用它的destroy()方法

        5、销毁并标记该实例以供作为垃圾收集一旦请求了一个servlet，就没有办法阻止容器执行一个完整的生命周期。

           容器在servlet首次被调用时创建它的

如何编开发，配置，发布一个Servlet

1.编写:

        开发一个Servlet，可以通过实现java.servlet.Servlet接口，但通常都不是直接去实现这个接口，而是继承javax.servlet.http.HttpServlet类来实现的。 HttpServlet类专门为HTTP协议设计，对java.servlet.Servlet接口的方法都

   提供了默认实现。一般的，通过继承HttpServlet类，只需重载doGet和doPost() 方法就可以实现自己的Servlet。

   当然如果要在Servlet被加载时进行初始化操作，还可以重载它的init()和destroy()方法。

    一个简单的例子：

      import java.io.*;

      import javax.servlet.*;

      import javax.servlet.http.*;

      public class Hello extends HttpServlet{

        public void doGet(HttpServletRequest request,

                HttpServletResponse response)

                   throws ServletException,IOException{

             response.setContentType("text/html");

             PrintWriter out=response.getWriter();

             out.print("<h1>hello!</h1>");

        }

      }

2.配置：

      如果你是在命令行下进行编译，则需要将TOMCAT安装目录下的commons/lib/servlet-api.jar添加到classpath中。

     将编译好的.class文件复制到对应工程的WEB-INF/classes目录下。

      接下来修改web.xml文件，在web-app标签下添加如下内容：

       <servlet>

        <--这里的hello用来标志和其他类的不同，可以是任意的-->

          <servlet-name>hello</servlet-name>

          <--这里的Hello就是要调用的servlet类名-->

          <servlet-class>Hello</servlet-class>

       </servlet>

       <servlet-mapping>

        <--这里的hello用来标志和其他类的不同，可以是任意的-->

          <servlet-name>hello</servlet-name>

        <--这里的/servlet/hello就是在IE地址栏中要添加在的

          "http://localhost:8080"后面的-->

          <url-pattern>/servlet/hello</url-pattern>

       </servlet-mapping>

3.发布：

    打开服务器，在IE地址栏中输入（以TOMCAT为例）"http:// localhost:8080/servlet/hello"， 就能看到效果了。

                                     Servlet教程

一、        Servlet简介

        Servlet是对支持Java的服务器的一般扩充。它最常见的用途是扩展Web服务器，提供非常安全的、可移植的、

        易于使用的CGI替代品。它是一种动态加载的模块，为来自Web服务器的请求提供服务。它完全运行在Java虚拟机上。

        由于它在服务器端运行，因此它不依赖于浏览器的兼容性。

        servlet容器：

        负责处理客户请求、把请求传送给servlet并把结果返回给客户。不同程序的容器实际实现可能有所变化，

        但容器与servlet之间的接口是由servlet API定义好的，这个接口定义了servlet容器在servlet上要调用的方法及传递给servlet的对象类。

        servlet的生命周期：

        1、servlet容器创建servlet的一个实例

        2、容器调用该实例的init()方法

        3、如果容器对该servlet有请求，则调用此实例的service()方法

        4、容器在销毁本实例前调用它的destroy()方法

        5、销毁并标记该实例以供作为垃圾收集

        一旦请求了一个servlet，就没有办法阻止容器执行一个完整的生命周期。

        容器在servlet首次被调用时创建它的一个实例，并保持该实例在内存中，让它对所有的请求进行处理。容器可以决定在任何

        时候把这个实例从内存中移走。在典型的模型中，容器为每个servlet创建一个单独的实例，容器并不会每接到一个请求就创

        建一个新线程，而是使用一个线程池来动态的将线程分配给到来的请求，但是这从servlet的观点来看，效果和为每个请求创

        建一个新线程的效果相同。

servlet API

servlet接口：

    public interface Servlet

    它的生命周期由javax.servlet.servlet接口定义。当你在写servlet的时候必须直接或间接的实现这个接口。一般趋向于间接实现：

    通过从javax.servlet.GenericServlet或javax.servlet.http.HttpServlet派生。在实现servlet接口时必须实现它的五个方法：

    init():

    public void init(ServletConfig config) throws ServletException

    一旦对servlet实例化后，容器就调用此方法。容器把一个ServletConfig对象传统给此方法，这样servlet的实例就可以把与容器相

    关的配置数据保存起来供以后使用。如果此方法没有正常结束就会抛出一个ServletException。一旦抛出该异常，servlet就不再执行，

    而随后对它的调用会导致容器对它重新载入并再次运行此方法。接口规定对任何servlet实例，此方法只能被调用一次，在任何请

    求传递给servlet之前，此方法可以在不抛出异常的情况下运行完毕。

    service():

    public void service(ServletRequest req,ServletResponse res) throws ServletException,IOException

    只有成功初始化后此方法才能被调用处理用户请求。前一个参数提供访问初始请求数据的方法和字段，后一个提供servlet构造响应的方法。

    destroy():

    public void destroy()

    容器可以在任何时候终止servlet服务。容器调用此方法前必须给service()线程足够时间来结束执行，因此接口规定当service()正在执行

    时destroy()不被执行。

    getServletConfig():

    public ServletConfig getServletConfig()

    在servlet初始化时，容器传递进来一个ServletConfig对象并保存在servlet实例中，该对象允许访问两项内容：初始化参数和ServletContext

    对象，前者通常由容器在文件中指定，允许在运行时向sevrlet传递有关调度信息，后者为servlet提供有关容器的信息。此方法可以

    让servlet在任何时候获得该对象及配置信息。

    getServletInfo():

    public String getServletInfo()

    此方法返回一个String对象，该对象包含servlet的信息，例如开发者、创建日期、描述信息等。该方法也可用于容器。

    GenericServlet类

    Public abstract class GenericServlet implants Servlet,ServletConfig,Serializable

    此类提供了servlet接口的基本实现部分，其service()方法被申明为abstract，因此需要被派生。init(ServletConfig conf)方法把servletConfig对

    象存储在一个private transient（私有临时）实例变量里，getServletConfig()方法返回指向本对象的指针，如果你重载此方法，将不能使

    用getServletConfig来获得ServletConfig对象，如果确实想重载，记住要包含对super.config的调用。2.1版的API提供一个重载的没有参数

    的init()方法。现在在init(ServletConfig)方法结束时有一个对init()的调用，尽管目前它是空的。2.1版API里面，此类实现了ServletConfig接口，

    这使得开发者不用获得ServletConfig对象情况下直接调用ServletConfig的方法，这些方法是：getInitParameter(),getInitParameterNames(),

    getServletContext。此类还包含两个写日志的方法，它们实际上调用的是ServletContext上的对应方法。log(String msg)方法将servlet的名

    称和msg参数写到容器的日志中，log(String msg,Throwable cause)除了包含servlet外还包含一个异常。

    HttpServlet类

    该类扩展了GenericServlet类并对servlet接口提供了与HTTP更相关的实现。

    service():

    protected void service(HttpServletRequest req,HttpServletResponse res) throws ServletException,IOException

    public void service(HttpServletRequest req,HttpServletResponse res)throws ServletException,IOException

    该方法作为HTTP请求的分发器，这个方法在任何时候都不能被重载。当请求到来时，service()方法决定请求的类型（GET,POST,HEAD,

    OPTIONS,DELETE,PUT,TRACE），并把请求分发给相应的处理方法（doGet(),doPost(),doHead(),doOptions(),doDelete(),doPut(),doTrace()）

        每个do方法具有和第一个service()相同的形式。为了响应特定类型的HTTP请求，我们必须重载相应的do方法。如果servlet收到一个HTTP

        请求而你没有重载相应的do方法，它就返回一个说明此方法对本资源不可用的标准HTTP错误。

        getLatModified():

        protected long getLastModified(HttpServletRequest req)

        该方法返回以毫秒为单位的的自GMT时间
 
 
  
  1970年
  
  1月
  
  1日
 
 0时0分0秒依赖的最近一次修改servlet的时间，缺省是返回一个负数表示时间未知。

        当处理GET请求时，调用此方法可以知道servlet的最近修改时间，服务器就可决定是否把结果从缓存中去掉。

        HttpServletRequest接口

        public interface HttpServletRequest extends ServletRequest

        所有实现此接口的对象（例如从servlet容器传递的HTTP请求对象）都能让servlet通过自己的方法访问所有请求的数据。下面是一些用来获

        取表单数据的基本方法。

        getParameter()

        public String getParameter(String key)

        此方法试图将根据查询串中的关键字定位对应的参数并返回其值。如果有多个值则返回列表中的第一个值。如果请求信息中没有指定参数，

        则返回null。

        getParameterValues():

        public String[] getParameterValues(String key)

        如果一个参数可以返回多个值，比如复选框集合，则可以用此方法获得对应参数的所有值。如果请求信息中没有指定参数，则返回null。

        GetParameterNames():

        Public Enumeration getParameterNames()

        此方法返回一个Enumeration对象，包含对应请求的所有参数名字列表。

        HttpServletResponse接口

        public interface HttpServletResponse extends servletResponse

        servlet容器提供一个实现该接口的对象并通过service()方法将它传递给servlet。通过此对象及其方法，servlet可以修改响应头并返回结果。

        setContentType():

        public void setContentType(String type)

        在给调用者发回响应前，必须用此方法来设置HTTP响应的MIME类型。可以是任何有效的MIME类型，当给浏览器返回HTML是就是

        ”text/html”类型。

        getWriter():

        public PrintWriter getWriter()throws IOException

        此方法将返回PrintWriter对象，把servlet的结果作为文本返回给调用者。PrintWriter对象自动把Java内部的UniCode编码字符转换成正确的

        编码以使客户端能够阅读。

        getOutputStream():

        public ServletOutputStream getOutputStream() throws IOException

        此方法返回ServletOutputStream对象，它是java.io.OutputStream的一个子类。此对象向客户发送二进制数据。

        setHeader():

        public void setHeader(String name,String value)

        此方法用来设置送回给客户的HTTP响应头。有一些快捷的方法用来改变某些常用的响应头，但有时也需要直接调用此方法。

        编译条件

        需要从http://java.sun.com/products/servlet/ 获得一份JSDK的拷贝，并把servlet.jar移动到JDK安装目录下的/jre/lib/ext目录下。如果是JDK1.1，

        则移动到/lib下，并在CLASSPATH中加入servlet.jar的绝对路径。

        运行条件

        需要Apache Jserv,Jrun Servlet Exec,Java Web Server,Weblogic,WebSphere,Tomcat,Resin等servlet服务器端程序。

简单范例

import java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

public class HelloWorld extends HttpServlet {

    public void doGet(HttpServletRequest request, HttpServletResponse response)

    throws IOException, ServletException

    {

        response.setContentType("text/html");

        PrintWriter out = response.getWriter();

        out.println("<html>");

        out.println("<body>");

        out.println("<head>");

        out.println("<title>Hello World!</title>");

        out.println("</head>");

        out.println("<body>");

        out.println("<h1>Hello World!</h1>");

        out.println("</body>");

        out.println("</html>");

    }

}

        servlet的性能和效率

        一个servlet仅被初始化一次而执行多次，因此极小的低效性也会随着时间的增加而产生很很大的影响。在代码中需要考虑String

        对象的使用，如果产生HTML响应需要用到很多字符串时，不应该为每一个字符串生成一个String对象，因为这会产生大量的String

        和StringBuffer对象，造成大量的对象构造消耗和垃圾收集负担，解决的办法是一行一行的把所有需要写入的直接写入PrintWriter中，

        或者创建一个StringBuffer对象，并使用append()方法将文本加入。

        及时回送

        有时，程序需要花费很长时间执行，在这种情况下应该回送给客户端一些信息，而不是长时间显示白屏，这可以在执行到一定程

        度就回送一些东西，可以使用PrintWriter的flush()方法强制将现有的内容回送给浏览器。

        Servlet会话

        由于Web服务器使用的协议HTTP是一种无状态的协议，因此要维护单个客户机一系列请求的当前状态就需要使用其它的附加手段，

        在以前，一般的方法是使用：

l    隐藏的表格字段：在浏览器中，这种类型的字段是不可见的，然而，它在请求中被传送，服务器端程序可以读取它的值。它的优

     点是实现容易，且大多浏览器都支持；缺点是字段必须按照特定的顺序建立，客户端可以通过查看源代码得到其值，在浏览器中

     单击“后退”按钮会丢失加到当前页中的附加字段，同时也限制了用户动态的生成文档。

l    Cookie：是一些关键的数据片断，由服务器建立并由客户机的浏览器存放。浏览器维护一个它自己的Cookie表，这使得它可以作为一

     种会话跟踪的解决方案。使用Cookie的好处是它比在URL或表单中储存数据更直观。它的缺点是它可以用于在比一次短会话更长时

     间内跟踪用户，甚至可以用来跟踪某个用户向站点发送的每一个请求，因此有人担心自己的隐私问题而关闭了Cookie，一些老的浏

     览器也不支持cookie。Servlet API提供一个Cookie类支持cookie，使用HttpServletResponse.addCookie()和HttpServletResponse.getCookies()

     方法添加和读取cookie。

l    URL重写：修改请求的url，使之包含会话ID。这种方法的缺点是：对于大量的数据，URL会变得很长而失去控制；在某些环境下，

     URL的字符串长度有一定的限制；数据保密问题，你可能不想让旁边的人或者可以使用同一个计算机的看到你的会话数据。

     Servlet提供HttpServletRequest类可以获得参数。

Servlet API有自己内置的会话跟踪支持，使用HttpSession对象既可。它的setAttribute()方法绑定一对名字/值数据，把它存到当前会话中，

如果会话中已经存在该名字责替换它，语法为：public void setAttribute(String name,Object value)。getAttribute()方法读取存储在会话中的对

象，语法为：public Object getAttribute(String name)。getAttributeNames()方法返回存储在会话中的所有名字，

语法为：public String[] getAttributeNames()。最后一个方法是removeAttribute()方法，它从会话中删除指定的信息，

语法为：public void removeAttribute(String name)。HttpSession对象可以使用HttpServletRequest对象request的getSession(true)方法获得。

参数为true意味着如果不存在该对象则创建一个。

二、servlet规范定义的Servlet 生命周期

        servlet有良好的生存期的定义，包括如何加载、实例化、初始化、处理客户端请求以及如何被移除。这个生存期由javax.servlet.Servlet

        接口的init,service和destroy方法表达。

1、加载和实例化

        容器负责加载和实例化一个servlet。实例化和加载可以发生在引擎启动的时候，也可以推迟到容器需要该servlet为客户请求服务的时候。

        首先容器必须先定位servlet类，在必要的情况下，容器使用通常的Java类加载工具加载该servlet，可能是从本机文件系统，也可以是从远

        程文件系统甚至其它的网络服务。容器加载servlet类以后，它会实例化该类的一个实例。需要注意的是可能会实例化多个实例，

        例如一个servlet类因为有不同的初始参数而有多个定义，或者servlet实现SingleThreadModel而导致容器为之生成一个实例池。

2、初始化

    servlet加载并实例化后，容器必须在它能够处理客户端请求前初始化它。初始化的过程主要是读取永久的配置信息，昂贵资源

    （例如JDBC连接）以及其它仅仅需要执行一次的任务。通过调用它的init方法并给它传递唯一的一个（每个servlet定义一个）

    ServletConfig对象完成这个过程。给它传递的这个配置对象允许servlet访问容器的配置信息中的名称－值对（name-value）初始化参数。

    这个配置对象同时给servlet提供了访问实现了ServletContext接口的具体对象的方法，该对象描述了servlet的运行环境。

    2.1初始化的错误处理

    在初始化期间，servlet实例可能通过抛出UnavailableException 或者 ServletException异常表明它不能进行有效服务。如果一个servlet抛

    出一个这样的异常，它将不会被置入有效服务并且应该被容器立即释放。在此情况下destroy方法不会被调用因为初始化没有成功完成。

    在失败的实例被释放后，容器可能在任何时候实例化一个新的实例，对这个规则的唯一例外是如果失败的servlet抛出的异常是

    UnavailableException并且该异常指出了最小的无效时间，那么容器就会至少等待该时间指明的时限才会重新试图创建一个新的实例。

    2.2、工具因素

    当工具（注：根据笔者的理解，这个工具可能是应用服务器的某些检查工具，通常是验证应用的合法性和完整性）加载和内省（

    introspect）一个web应用时，它可能加载和内省该应用中的类，这个行为将触发那些类的静态初始方法被执行，因此，开发者不能

    假定只要当servlet的init方法被调用后它才处于活动容器运行状态（active container runtime）。作为一个例子，这意味着servlet不能

    在它的静态（类）初始化方法被调用时试图建立数据库连接或者连接EJB容器。

3、处理请求

   在servlet被适当地初始化后，容器就可以使用它去处理请求了。每一个请求由ServletRequest类型的对象代表，而servlet使用ServletResponse

   回应该请求。这些对象被作为service方法的参数传递给servlet。在HTTP请求的情况下，容器必须提供代表请求和回应的HttpServletRequest

   和HttpServletResponse的具体实现。需要注意的是容器可能会创建一个servlet实例并将之放入等待服务的状态，但是这个实例在它的生存期

   中可能根本没有处理过任何请求。

    3.1、多线程问题

    容器可能同时将多个客户端的请求发送给一个实例的service方法，这也就意味着开发者必须确保编写的servlet可以处理并发问题。

    如果开发者想防止这种缺省的行为，那么他可以让他编写的servlet实现SingleThreadModel。实现这个类可以保证一次只会有一个线

    程在执行service方法并且一次性执行完。容器可以通过将请求排队或者维护一个servlet实例池满足这一点。如果servlet是分布式应

    用的一部分，那么，那么容器可能在该应用分布的每个JVM中都维护一个实例池。如果开发者使用synchronized关键字定义service方

    法(或者是doGet和doPost)，容器将排队处理请求，这是由底层的java运行时系统要求的。我们强烈推荐开发者不要同步service方法或

    者HTTPServlet的诸如doGet和doPost这样的服务方法。

    3.2、处理请求中的异常

    servlet在对请求进行服务的时候有可能抛出ServletException或者UnavailableException异常。ServletException表明在处理请求的过程中发

    生了错误容器应该使用合适的方法清除该请求。UnavailableException表明servlet不能对请求进行处理，可能是暂时的，也可能是永久的。

    如果UnavailableException指明是永久性的，那么容器必须将servlet从服务中移除，调用它的destroy方法并释放它的实例。如果指明是暂

    时的，那么容器可以选择在异常信息里面指明的这个暂时无法服务的时间段里面不向它发送任何请求。在这个时间段里面被被拒绝的

    请求必须使用SERVICE_UNAVAILABLE (503)返回状态进行响应并且应该携带稍后重试（Retry-After）的响应头表明不能服务只是暂

    时的。容器也可以选择不对暂时性和永久性的不可用进行区分而全部当作永久性的并移除抛出异常的servlet。

    3.3线程安全

    开发者应该注意容器实现的请求和响应对象（注：即容器实现的HttpServletRequest和HttpServletResponese）没有被保证是线程安全的，

    这就意味着他们只能在请求处理线程的范围内被使用，这些对象不能被其它执行线程所引用，因为引用的行为是不确定的。

4、服务结束

    容器没有被要求将一个加载的servlet保存多长时间，因此一个servlet实例可能只在容器中存活了几毫秒，当然也可能是其它更长的任

    意时间（但是肯定会短于容器的生存期）

    当容器决定将之移除时（原因可能是保存内存资源或者自己被关闭），那么它必须允许servlet释放它正在使用的任何资源并保存任何

    永久状态（这个过程通过调用destroy方法达到）。容器在能够调用destroy方法前，它必须允许那些正在service方法中执行的线程执行

    完或者在服务器定义的一段时间内执行（这个时间段在容器调用destroy之前）。一旦destroy方法被调用，容器就不会再向该实例发

    送任何请求。如果容器需要再使用该servlet，它必须创建新的实例。destroy方法完成后，容器必须释放servlet实例以便它能够被垃圾

    回收。

三、    serlvet为什么只需要实现doGet和doPost

        Serlvet接口只定义了一个服务方法就是service，而HttpServlet类实现了该方法并且要求调用下列的方法之一：

        doGet：处理GET请求

        doPost：处理POST请求

        doPut：处理PUT请求

        doDelete：处理DELETE请求

        doHead：处理HEAD请求

        doOptions：处理OPTIONS请求

        doTrace：处理TRACE请求

        通常情况下，在开发基于HTTP的servlet时，开发者只需要关心doGet和doPost方法，其它的方法需要开发者非常的熟悉HTTP编程，因此

        这些方法被认为是高级方法。

        而通常情况下，我们实现的servlet都是从HttpServlet扩展而来。

        doPut和doDelete方法允许开发者支持HTTP/1.1的对应特性；

        doHead是一个已经实现的方法，它将执行doGet但是仅仅向客户端返回doGet应该向客户端返回的头部的内容；

        doOptions方法自动的返回servlet所直接支持的HTTP方法信息；

        doTrace方法返回TRACE请求中的所有头部信息。

        对于那些仅仅支持HTTP/1.0的容器而言，只有doGet, doHead 和 doPost方法被使用，因为HTTP/1.0协议没有定义PUT, DELETE, OPTIONS,

        或者TRACE请求。

        另外，HttpServlet定义了getLastModified方法以支持有条件的（conditional）get操作。有条件的get操作是指使用GET方式请求资源并且在头

        部指定只有在资源内容在指定时间后被修改的情况下服务器才有必要回应请求并发送请求的内容。对于那些实现doGet方法并且在不同

        请求之间内容相同的servlet而言，它应该实现这个方法以提高网络资源的利用率。

        另外要提及的是，按照规范的要求，servlet容器至少要实现HTTP/1.0协议规范，推荐实现HTTP/1.1规范，在此基础上可以实现其它的基

        于请求回应模式（based request response model）的协议（例如HTTPS）。

四、    servlet实例的个数及因此引发的问题

        在缺省情况下，一个容器中只为每个servlet定义生成一个servlet类实例。在servlet实现SingleThreadModel接口的情况下，容器可以生成多个

        实例以应付沉重的请求，也可以将请求排队发送给同一个实例（对于一个高性能的容器，也可能是这两种方式的结合，因为实例的个

        数是有限制的，因此在线程安全方式下一个实例会有多个请求排队等待服务同时容器中多个实例可以对请求进行服务）。对于为可分布

        式（distributable）应用开发的servlet而言，在每个JVM中对每个SERVLET定义都会有一个实例，如果在这样的应用中servlet也实现

        了SingleThreadModel接口，那么在每个JVM中每个servlet定义也可能有多个实例。

        使用SingleThreadModel接口可以保证一个线程一次性执行完给定实例的service方法，需要注意的是这个保证只能应用于servlet实例，那些

        可以被多个servlet实例访问的对象（例如HttpSession实例）依然对多个servlet有效，即使他们实现了SingleThreadModel。

        根据规范中的这些说明，我们在实现自己的serlvet时需要考虑多线程的问题，一般而言，不要在servlet中定义可变的成员，只能定义一些

        常量（使用final定义，如果没有使用，应该注意在程序中不应该修改其值），笔者见过一个定义很差的servlet:

        public class SomeHttpServlet extends HttpServlet {

            HttpSession session;

            ...

        }

        这样的servlet在使用中一定会出现问题，所有的用户都会共用一个session（这样很节约系统资源，不是吗？:)），因此一个用户请求的

        信息突然跑到另一个用户的ie窗口豪不奇怪。

        而且，即使你的servlet实现了SingleThreadModel接口也不要定义可变的成员，因为该成员的信息会保留下来，而这对于其它的用户而

        言在绝大部分情况下是毫无意义的。（你确定会有意义的情况例外，例如某种计数）

        另外需要说明的是上面说明中都是针对servlet定义而言的，而servlet定义定义不等价servlet类定义，即一个servlet类可能会有多个servlet

        定义，但是笔者还没有找到“servlet定义”的定义，规范中提到实例化一个servlet时可能会有不同的初始参数，但是这个也不同于带

        参数的多个构造方法。一般情况下我们可以认为一个servlet类对应一个servlet定义。

五、    servlet会话

        HTTP协议是一种无状态的协议，而对于现在的web应用而言，我们往往需要记录从特定客户端的一系列请求间的联系。现在已经有很

        多会话跟踪的技术，但是对于程序员而言都不是很方便直接使用。servlet规范定义了一个简单的HttpSession接口以方便servlet容器进行

        会话跟踪而不需要开发者注意实现的细节。

        一般而言，有两种最常用的会话跟踪机制，一种就是URL重写。在客户端不接受cookie的情况下可以使用URL重写进行会话跟踪。

        URL重写包括向URL路径添加一些容器可以解释的数据。规范要求会话ID必须编码在URL路径中，参数名称必须是jsessionid，例如:

        http://www.myserver.com/catalog/index.html;jsessionid=1234

        另一种就是现在最常用的cookie了，规范要求所有的servlet都必须支持cookie。容器向客户端发送一个cookie，客户端在后续的处于

        同一个会话的请求中向服务器返回该cookie。会话跟踪cookie的名字必须是JSESSIONID。

        新出现的一种会话功能是SSL会话，SSL（Secure Sockets Layer，安全套接字层）是HTTPS协议使用的一种加密技术，内建了会话跟踪

        功能，servlet容器可以非常容易的使用这些数据建立会话跟踪。（但是HTTPS不是规范要求servlet必须支持的协议） 

        因为HTTP是一种基于请求响应的协议，因此会话只有在客户端加入它以后才被新建立。当会话跟踪信息被成功的返回给服务器以指示

        会话给建立时客户端才算加入了一个会话。如果客户端没有加入会话，那么下一次请求不会被认为是会话的一部分。如何客户端还不

        知道会话或者客户端选择不加入一个会话，那么会话被认为是新的。开发者必须自己设计自己的应用中的会话处理状态，在什么地方

        没有加入会话，什么地方不能加入会话以及什么地方不需要加入会话。

        规范要求HttpSession在应用或者servlet上下文级别有效，诸如cookie这样的建立会话的底层机制可以在上下文中共享，但是对于那些外

        露的对象，以及更重要的是对象的那些属性是不能在上下文中共享的。

        对于会话的属性的绑定而言，任何对象都可以绑定到某个命名属性。被绑定的属性对象对于其它处于相同ServletContext并且处于同一

        个会话处理中的其它servlet也是可见的。

        某些对象在被加入会话或者被从会话中移除时要求得到通知，这样的信息可以通过让该对象实现HttpSessionBindingListener接口得到。

        该接口定义了两个方法用以标记被绑定到会话或者从会话中被移除。

        valueBound方法在对象通过getAttribute之前就被调用，而valueUnbound方法在对象已经不能通过getAttribute得到后才被调用。

        由于HTTP是无状态协议，因此客户端不再活动时没有什么明显的信号，这也就意味着只有一种机制可以用于表明客户端不再活动：

        超时。会话的缺省的时限由servlet容器定义并且可以通过HttpSession的getMaxInactiveInterval得到，开发者也可以通过使

        用setMaxInactiveInterval方法进行设置，这些方法返回的单位是秒，如果时限被设置为－1，那么意味着永远不会超时。

        通过调用HttpSession的getLastAccessedTime方法，我们可以得到在当前请求之前的访问时间。当会话中的一个请求被servlet上下文处理

        时会话就被认为被访问了。

        另外需要注意的就是一些很重要的会话的语义问题。

        多线程问题：多个请求线程可能会同时访问同一个会话，开发者有责任以适当的方式同步访问会话中的资源。

        分布式环境：对于被标记为可分布的应用而言，同一会话中的所有请求只能被单一的VM处理。同时，放入HttpSession中的所有对象都

        必须实现Serializable接口，否则容器可能会抛出IllegalArgumentException（在jboss_tomcat下没有抛出这个异常，但是如果在关闭服务器时

        还有未完成的会话，那么服务器在试图存储会话时会出现串行化异常，在重新启动的时候会试图回复会话，也会出现异常）。这个限

        制意味着开发者不会遇到非可分布容器中的那些并发问题。另外容器提供者可以通过将一个会话对象以及它的内容从分布式系统的一

        个活动节点移动到系统的其它不同节点的能力来保证可伸缩性。

        客户端的语义：基于cookie或者SSL证书通常是被web浏览器控制并且不联系到特定浏览器窗口的事实，从客户端应用的所有窗口发送到

        容器的请求都可能是同一个会话。为了达到最大的可移植性，开发者不能总假设特定客户端的所有窗口的请求都处于同一个会话中。

六、    Bean和Servlet的企业应用

        J2EE是一个企业应用程序的开发平台，包括了对EJB、Servlet、JavaServer Page、JNDI、XML等的支持。在这个平台上可以开发瘦客户

        端的多层体系结构的企业应用程序。

        　　Enterprise JavaBean技术是J2EE的主要基础。EJB技术对在分布式的计算环境中执行应用逻辑提供了一个可伸缩的框架结构。J2EE通

        过将EJB组件结构和其它的企业技术相结合，解决了在Java平台上进行开发和配置服务端应用程序的无缝结合。

        　　要使用J2EE开发您的企业应用，您必须要在您的机器上安装一个Web服务器，还要支持XML。为了在浏览器中运行Java 2的API，

        还要给您的浏览器安装一个支持Java2的插件。

        　　下面就介绍怎样用J2EE SDK写一个包括了HTML页面，Servlet和Session Bean的一个简单的瘦客户端的多层体系结构的企业应用程

        序。听起来是不是心动了呢？下面就开始吧。

        还要提醒一点的就是：在编程的时候，适当的增加catch子句是一个很好编程风格。如果例子代码抛出了一个正确的异常，代码就被

         try/catch这样的程序结构包围。Catch子句应该中应该加入处理异常的代码，千万不要留成空白。至少，应该加入语句：e.printStackTrace()

         来在控制台显示异常信息。

　　J2EE SDK是一个J2EE平台上用于演示、教育等用途的非商业的东东。可以从javasoft的网站上免费下载。很适合用来学习。

        如果你没有出国权限，还可以从国内各高校的FTP服务器上去下载，速度比较快，但可能版本不是最新的。

        瘦客户端的多层体系结构的应用程序的例子：

　　本例子通过一个HTML页面的输入来调用一个Servlet，Servlet再用Java的名字目录服务接口（JNDI）APIs来寻找一个会话Session Bean，

        这个Session Bean来执行一个计算。当Servlet得到了计算的结果的之后，Servlet把计算结果返回给HTML页面的用户。

　　之所以说这是一个瘦客户端的应用程序，是因为Servlet本身并没有执行任何的应用逻辑。这个简单的计算是由一个Session Bean

        在J2EE的应用服务器上执行的。客户没有参与过程的任何操作，所有的计算都是由Session Bean完成的。

　　所谓的多层体系结果实际上是由三或者四层组成的。我们的例子实际上是四层的一个结构。三层的体系结构是在标准的两层的

        客户/服务器结构基础上，将一个多线程的应用服务器加到了非浏览器的客户端和后台数据库之间。而四层的体系结构是通过Servlet

        和JavaServer Pages技术将客户端的应用程序由浏览器和HTML页面来取代。这个例子我们暂时只用其中的三层，在下一个例子中。

        我们再去访问数据库。这样，就扩展到四层了。再以后，我们会涉及到JavaServer Pages技术和XML技术。

J2EE软件的安装：

　　为了使我们的例子能够运行起来，首先要下载一个Java2 SDK Enterprise Edition（J2EE）的
 
 
  
  1.2.1
 
 的版本和一个J2SE

（Java 2 Standard Edition）的1.2以上的版本。在Windows 2000系统中，假设我们把J2EE和J2SE都装到了C:/J2EE目录下。

安装详细目录如下：

J2EE：C:/J2EE/j2sdkee
  
  
   
   1.2.1
  
  

J2SE：C:/J2EE/jdk
  
  
   
   1.2.2
  
  

Path和ClassPath的设置：

　　下载的东西包括了J2EE的应用服务器、Cloudscape数据库、使用了加密套接字协议层的Web服务器、开发和配置的工具、

企业级的Java APIs。其Path和ClassPath的设置如下：

Path的设置：在Windows系统中，需要把Path的目录包含下面两个目录：

C:/J2EE/j2sdkee
  
  
   
   1.2.1
  
  /bin

C:/J2EE/jdk
  
  
   
   1.2.2
  
  /bin

Classpath的设置：在Windows系统中，需要把Classpath参数包含下面的文件：

C:/J2EE/j2sdkee.
  
  
   
   1.2.1
  
  /lib/j2ee.jar

另外，还要配置环境变量：

J2EE_HOME=C:/J2EE/j2sdkee
  
  
   
   1.2.1
  
  

JAVA_HOME=C:/J2EE/jdk
  
  
   
   1.2.2
  
  

　　这样，就可以执行C:/J2EE/j2sdkee
  
  
   
   1.2.1
  
  /bin目录下面的批处理命令了。仔细看看里面的批处理，你会发现不少的东西的。

J2EE应用程序组件：

　　J2EE程序员编写J2EE组件。J2EE组件是一个功能齐全的软件单元。将其它的应用程序组件组装到J2EE的应用程序和接口中。

J2EE规范中定义如下的应用程序组件：

应用程序客户组件

Enterprise JavaBean组件

Servlet和JavaServer Pages组件（也叫做Web组件）

Applet

　　在本例子中，我们创建了一个J2EE的应用程序和两个J2EE的组件：一个Servlet和一个Session Bean。Servlet和HTML文件是捆绑在

        一个WAR（WEB Archive）文件中。Session Bean的类和接口捆绑到了一个JAR文件中。然后再把WAR文件和JAR文件加到J2EE的应用程

        序，捆绑到一个EAR（Enterprise Archive）文件中。并验证测试产品环境的配置。

　　在这所有的步骤中。实际上执行了很多的不用的角色的功能。编写Session Bean和Servlet是开发工作。而创建一个J2EE的应用程序，

        将J2EE组件组装到应用程序中是应用程序的组装工作。实际上，这些工作可以在不同的地方由不用的人员来做。

创建一个HTML页面：

这个页面名字为bonus.html。HTML代码如下：

　　代码中，让人感兴趣的是用别名来调用BonusServlet.class。因为在后面提到的应用程序的组装的时候，将它映射到了这个别

名BonusServlet上

<HTML>

<BODY BGCOLOR = "WHITE">

<BLOCKQUOTE>

<H3>Bonus Calculation</H3>

<FORM METHOD="GET" ACTION="BonusAlias">

<P>

Enter social security Number:

<P>

<INPUT TYPE="TEXT" NAME="SOCSEC"></INPUT>

<P>

Enter Multiplier:

<P>

<INPUT TYPE="TEXT" NAME="MULTIPLIER"></INPUT>

<P>

<INPUT TYPE="SUBMIT" VALUE="Submit">

<INPUT TYPE="RESET">

</FORM>

</BLOCKQUOTE>

</BODY>

</HTML>

　　这个HTML文件有两个数据域，用户可以输入社会保险号和一个乘数。当用户单击了Submit按纽。BonusServlet就得到了终端用户的

数据。然后寻找Session Bean。将用户数据传递给Session Bean。Session Bean计算出奖金，把结果返回给Servlet。Servlet再通过另一

个HTML页面将奖金结果返回给用户。

创建Servlet：

例子假定BonusServlet.java文件是在C:/J2EE/Client-Code目录下面。在运行的时候，Servlet代码执行如下操作：

获得用户数据

查找Session Bean

将用户数据传递给Session Bean

在得到Session Bean的返回结果以后，创建一个HTML页面将结果返回给客户。

Servlet代码如下：

import javax.servlet.*;

import javax.servlet.http.*;

import java.io.*;

import javax.naming.*;

import javax.rmi.PortableRemoteObject;

import Beans.*;

public class BonusServlet extends HttpServlet {

CalcHome homecalc;

public void init(ServletConfig config)

throws ServletException{

//Look up home interface

try{

InitialContext ctx = new InitialContext();

Object objref = ctx.lookup("calcs");

homecalc =

(CalcHome)PortableRemoteObject.narrow(

objref,

CalcHome.class);

} catch (Exception NamingException) {

NamingException.printStackTrace();

} 

}

public void doGet (HttpServletRequest request,

HttpServletResponse response)

throws ServletException, IOException {

String socsec = null;

int multiplier = 0;

double calc = 0.0;

PrintWriter out;

response.setContentType("text/html");

String title = "EJB Example";

out = response.getWriter();

out.println("<HTML><HEAD><TITLE>");

out.println(title);

out.println("</TITLE></HEAD><BODY>");

try{

Calc theCalculation;

//Get Multiplier and Social Security Information

String strMult =

request.getParameter("MULTIPLIER");

Integer integerMult = new Integer(strMult);

multiplier = integerMult.intValue();

socsec = request.getParameter("SOCSEC");

//Calculate bonus.10 AUGUST 28, 2000

double bonus = 100.00;

theCalculation = homecalc.create();

calc =

theCalculation.calcBonus(multiplier, bonus);

} catch(Exception CreateException){

CreateException.printStackTrace();

}

//Display Data

out.println("<H1>Bonus Calculation</H1>");

out.println("<P>Soc Sec: " + socsec + "<P>");

out.println("<P>Multiplier: " +

multiplier + "<P>");

out.println("<P>Bonus Amount: " + calc + "<P>");

out.println("</BODY></HTML>");

out.close();

}

public void destroy() {

System.out.println("Destroy");

}

}

　　在import子句中，javax.servlet包括了Servlet Class的协议。Java.io是系统输入输出包。Javax.naming里面包含了Java名字目录服务APIs。

    Javax.rmi是用来Session Bean的home接口和Remote对象的通信使用的。

　　在BonusServlet.init方法中，查找Session Bean的home接口。并且产生它的实例。方法使用了JNDI在组件的组装中的指定的名字calcs。

    用它来得到home接口的reference。然后就把这个reference和home接口类传递给PortableRemoteObject.narrow方法。来保证把reference转

    化为CalcHome类型。

　　DoGet()方法有两个参数。一个是request对象，另一个是reponse对象。浏览器发送一个request对象给Servlet。而Servlet返回一个response

    对象给浏览器。方法访问request对象里面的信息，可以发现是谁在发出的请求、请求的数据在什么表单里面、是哪个HTTP头被发送。并使

    用reponse对象产生一个HTML页面来响应浏览器的请求。

　　当方法处理请求的时候，如果产生输入输出错误，就抛出一个IOException异常。如果不能处理请求，就会抛出一个ServletException

    异常。为了计算奖金值，doGet()创建了一个home接口，调用它的calcBonus。

创建Session Bean：

　　Session Bean代表了与客户的一个短暂的会话。如果服务或者客户有一方崩溃了。数据就消失了。相反，Entity Bean代表了数据库中

    一段持久的数据。如果服务或者客户又一方崩溃了，底层的服务保证数据能被保存下来。

　　因为这个Enterprise Bean只是应BonusServlet的请求，执行了一个简单的计算。如果发生崩溃，可以重新初始化计算。这样，我们在本

    例子中就选择Session Bean来实现这个计算。

　  在组装配置好以后，Servlet组件和Session Bean组件如何在一个J2EE应用程序中协同工作。容器是Session Bean和支持Session Bean的底层

    平台之间的接口。容器是在配置期间产生的。

　　本例子假定CalcBean.java、Calc.java和CalcHome.java文件都放在C:/J2EE/Beans目录下面。CalcHome.java文件前面的Package名字 Beans

    和目录Beans的名字应该是一样的。当这些文件被编译的时候，是从Beans目录中编译，其名字是包的名字后面加一个斜线在加上类

    或者接口的名字。

CalcHome.java文件：

package Beans;

import java.rmi.RemoteException;

import javax.ejb.CreateException;

import javax.ejb.EJBHome;

public interface CalcHome extends EJBHome {

Calc create() throws CreateException, RemoteException;

}

　　BonusServlet并不直接同Session Bean通信。而是通过产生一个CalcHome的实例。这个Home接口扩展了EJBHome接口。有一个Create()

    方法，用来在容器中产生一个Session Bean。如果无法产生Session Bean，将会抛出一个CreateException异常。如果不能与Session Bean

    的远程方法通信，就会抛出一个RemoteException异常。

Calc.java文件：

package Beans;

import javax.ejb.EJBObject;

import java.rmi.RemoteException;

public interface Calc extends EJBObject {

public double calcBonus(int multiplier,

double bonus)

throws RemoteException;

}

　　产生一个Home接口以后,J2EE应用程序就创建一个Remote接口和一个Session Bean。Remote接口扩展了EJBObject接口。并且声明了

   一个calcBonus()方法来计算奖金值。方法需要抛出javax.rmi.RemoteException异常。方法的实现在CalcBean类里面。

CalcBean.java文件：

package Beans;

import java.rmi.RemoteException;

import javax.ejb.SessionBean;

import javax.ejb.SessionContext;

public class CalcBean implements SessionBean { 

public double calcBonus(int multiplier,

double bonus) {

double calc = (multiplier*bonus);

return calc;

}

public void ejbCreate() { }

public void setSessionContext(

SessionContext ctx) { }

public void ejbRemove() { }

public void ejbActivate() { }

public void ejbPassivate() { }

public void ejbLoad() { }

public void ejbStore() { }

}

　　本Session Bean类实现了SessionBean接口，提供了CalcBonus()方法的行为。在BonusServlet调用CalcHome的Create()方法以后，依次调用

    setSessionContext()方法和ejbCreate()方法。

　　这些空的方法是从SessionBean中来的。由容器负责调用。除非在Bean的创建或者删除里面，你需要附加一些你自己的操作。否者，

   你并不需要提供这些方法的行为。

                     Servlet简介及生命周期                     

1.Servlet简介

    Servlet是可部署在Web服务器上的Java程序.

        Servlet是对支持Java的服务器的一般扩充。它最常见的用途是扩展Web服务器，提供非常安全的、

        可移植的、易于使用的CGI替代品。它是一种动态加载的模块，为来自Web服务器的请求提供服务。

        它完全运行在Java虚拟机上。由于它在服务器端运行，因此它不依赖于浏览器的兼容性。

    servlet容器：负责处理客户请求、把请求传送给servlet并把结果返回给客户。

        不同程序的容器实际实现可能有所变化，但容器与servlet之间的接口是由servlet API定义好的，

        这个接口定义了servlet容器在servlet上要调用的方法及传递给servlet的对象类。

2.servlet编程，需要引用以下两个类和接口：javax.servlet 和javax.servlet.http，在这些类和接口中，javax.servlet.Servlet接口尤为重要。

        所有的 servlet 必须实现这个接口或继承已实现这个接口的类。

3.Servlet 接口有五个方法，如下：

        1)  public void init(ServletConfig config) throws ServletException

        2)  public void service(ServletRequest request, ServletResponseresponse) throws  ServletException, java.io.IOException 

        3)　public void destroy()

        4)　public ServletConfig getServletConfig()

        5)　public java.lang.String getServletInfo() 

4.init、service和 destroy 方法是 Servlet 生命周期的方法。当 Servlet 类实例化后，容器加载 init，以通知 servlet 它已进入服务行列。

        init 方法必须被加载，Servelt 才能接收和请求。如果要载入数据库驱动程序、初始化一些值等等，程序员可以重写这个方法。

        在其他情况下，这个方法一般为空。

5.service 方法由 Servlet 容器调用，以允许 Servlet 响应一个请求。Servlet 容器传递 javax.servlet.ServletRequest 对象和 

        javax.servlet.ServletResponse 对象。ServletRequest 对象包含客户端 HTTP 请求信息，ServletResponse 则封装servlet 响应。

        通过这两个对象，您可以写一些需要 servlet怎样服务和客户怎样请求的代码。

6.从service中删除Servlet实例之前，容器调用destroy方法。在servlet容器关闭或servlet 容器需要更多的内存时，就调用它。

        这个方法只有在servlet 的service 方法内的所有线程都退出的时候，或在超时的时候才会被调用。在 servlet 容器调用 destroy方法之后，

        它将不再调用 servlet的 service方法。

7.destroy 方法给了servlet机会，来清除所有空闲资源（比如：内存，文件处理和线程），以确保在内存的持续状态和 servlet的当

        前状态是同步的。

servlet的生命周期：

        1、servlet容器创建servlet的一个实例

        2、容器调用该实例的init()方法

        3、如果容器对该servlet有请求，则调用此实例的service()方法

        4、容器在销毁本实例前调用它的destroy()方法

        5、销毁并标记该实例以供作为垃圾收集一旦请求了一个servlet，就没有办法阻止容器执行一个完整的生命周期。

           容器在servlet首次被调用时创建它的