Servlet教程

Servlet 教程

1、        Servlet 简单介绍

Servlet是对支持Java的server的通常扩充。它最多见的用途是扩展Webserver，提供很是安全的、可移植的、易于使用的CGI替代品。它是一种动态载入的模块，为来自Webserver的请求提供服务。它全然运行在Java虚拟机上。因为它在server端运行，所以它不依赖于浏览器的兼容性。
servlet容器：
负责处理客户请求、把请求传送给servlet并把结果返回给客户。不一样程序的容器实际实现可能有所变化，但容器与servlet之间的接口是由servlet API定义好的，这个接口定义了servlet容器在servlet上要调用的方法及传递给servlet的对象类。
servlet的生命周期：
一、servlet容器建立servlet的一个实例
二、容器调用该实例的init()方法
三、假设容器对该servlet有请求，则调用此实例的service()方法
四、容器在销毁本实例前调用它的destroy()方法
五、销毁并标记该实例以供做为垃圾收集
一旦请求了一个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的近期改动时间，server就可决定是否把结果从缓存中去掉。
HttpServletRequest接口
public interface HttpServletRequest extends ServletRequest
所有实现此接口的对象（好比从servlet容器传递的HTTP请求对象）都能让servlet经过本身的方法訪问所有请求的数据。如下是一些用来获取表单数据的基本方法。
getParameter()
public String getParameter(String key)
此方法试图将依据查询串中的keyword定位相应的參数并返回其值。假设有多个值则返回列表中的第一个值。假设请求信息中没有指定參数，则返回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编码字符转换成正确的编码以使client可以阅读。
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等servletserver端程序。
简单范例

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()方法将文本添�。
及时回送
有时，程序需要花费很是长时间运行，在这种状况下应该回送给client一些信息，而不是长时间显示白屏，这可以在运行到必定程度就回送一些东西，可以使用PrintWriter的flush()方法强制将现有的内容回送给浏览器。

Servlet会话
因为Webserver使用的协议HTTP是一种无状态的协议，所以要维护单个客户机一系列请求的当前状态就需要使用其余的附加手段，在曾经，通常的方法是使用：
l    隐藏的表格字段：在浏览器中，这种类型的字段是不可见的，然而，它在请求中被传送，server端程序可以读取它的值。它的优势是实现easy，且大多浏览器都支持；缺点是字段必须依照特定的顺序创建，client可以经过查看源码获得其值，在浏览器中单击“后退”button会丢失加到当前页中的附加字段，同一时候也限制了用户动态的生成文档。
l    Cookie：是一些重要的做用片段，由server创建并由客户机的浏览器存放。浏览器维护一个它本身的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意味着假设不存在该对象则建立一个。

 

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

servlet有良好的生存期的定义，包括怎样载入、实例化、初始化、处理client请求以及怎样被移除。这个生存期由javax.servlet.Servlet接口的init,service和destroy方法表达。
一、载入和实例化
容器负责载入和实例化一个servlet。实例化和载入可以发生在引擎启动的时候，也可以推迟到容器需要该servlet为客户请求服务的时候。
首先容器必须先定位servlet类，在必要的状况下，容器使用一般的Java类载入工具载入该servlet，多是从本机文件系统，也可以是从远程文件系统甚至其余的网络服务。容器载入servlet类之后，它会实例化该类的一个实例。需要注意的是可能会实例化多个实例，好比一个servlet类因为有不一样的初始參数而有多个定义，或者servlet实现SingleThreadModel而致使容器为之生成一个实例池。

二、初始化
servlet载入并实例化后，容器必须在它可以处理client请求前初始化它。初始化的过程主要是读取永久的配置信息，昂贵资源（好比JDBC链接）以及其余仅仅需要运行一次的任务。经过调用它的init方法并给它传递惟一的一个（每个servlet定义一个）ServletConfig对象完毕这个过程。给它传递的这个配置对象赞成servlet訪问容器的配置信息中的名称－值对（name-value）初始化參数。这个配置对象同一时候给servlet提供了訪问实现了ServletContext接口的详细对象的方法，该对象描写叙述了servlet的运行环境。
    2.1初始化的错误处理
    在初始化期间，servlet实例可能经过抛出UnavailableException 或者 ServletException异常代表它不能进行有效服务。假设一个servlet抛出一个这种异常，它将不会被置入有效服务并且应该被容器立刻释放。在此状况下destroy方法不会被调用因为初始化没有成功完毕。在失败的实例被释放后，容器可能在不论何时实例化一个新的实例，对这个规则的惟一例外是假设失败的servlet抛出的异常是UnavailableException并且该异常指出了最小的无效时间，那么容器就会至少等待该时间指明的时限才会又一次试图建立一个新的实例。
    2.二、工具因素
    当工具（注：依据笔者的理解，这个工具多是应用server的某些检查工具，通常是验证应用的合法性和完整性）载入和内省（introspect）一个web应用时，它可能载入和内省该应用中的类，这个行为将触发那些类的静态初始方法被运行，所以，开发人员不能假定仅仅要当servlet的init方法被调用后它才处于活动容器运行状态（active container runtime）。做为一个样例，这意味着servlet不能在它的静态（类）初始化方法被调用时试图创建数据库链接或者链接EJB容器。

三、处理请求
在servlet被适当地初始化后，容器就可以使用它去处理请求了。每个请求由ServletRequest类型的对象表明，而servlet使用ServletResponse回应该请求。这些对象被做为service方法的參数传递给servlet。在HTTP请求的状况下，容器必须提供表明请求和回应的HttpServletRequest和HttpServletResponse的详细实现。需要注意的是容器可能会建立一个servlet实例并将之放入等待服务的状态，但是这个实例在它的生存期中可能根本没有处理过不论什么请求。
    3.一、多线程问题
    容器可能同一时候将多个client的请求发送给一个实例的service方法，这也就意味着开发人员必须确保编写的servlet可以处理并发问题。假设开发人员想防止这种缺省的行为，那么他可以让他编写的servlet实现SingleThreadModel。实现这个类可以保证一次仅仅会有一个线程在运行service方法并且一次性运行完。容器可以经过将请求排队或者维护一个servlet实例池知足这一点。假设servlet是分布式应用的一部分，那么，那么容器可能在该应用分布的每个JVM中都维护一个实例池。假设开发人员使用synchronizedkeyword定义service方法(或者是doGet和doPost)，容器将排队处理请求，这是由底层的java运行时系统要求的。咱们强烈推荐开发人员不要同步service方法或者HTTPServlet的诸如doGet和doPost这种服务方法。
    3.二、处理请求中的异常
    servlet在对请求进行服务的时候有可能抛出ServletException或者UnavailableException异常。ServletException代表在处理请求的过程当中发生了错误容器应该使用合适的方法清除该请求。UnavailableException代表servlet不能对请求进行处理，多是临时的，也多是永久的。假设UnavailableException指明是永久性的，那么容器必须将servlet从服务中移除，调用它的destroy方法并释放它的实例。假设指明是临时的，那么容器可以选择在异常信息里面指明的这个临时没法服务的时间段里面不向它发送不论什么请求。在这个时间段里面被被拒绝的请求必须使用SERVICE_UNAVAILABLE (503)返回状态进行响应并且应该携带稍后重试（Retry-After）的响应头代表不能服务仅仅是临时的。容器也可以选择不正确临时性和永久性的不可用进行区分而所有看成永久性的并移除抛出异常的servlet。
    3.3线程安全
    开发人员应该注意容器实现的请求和响应对象（注：即容器实现的HttpServletRequest和HttpServletResponese）没有被保证是线程安全的，这就意味着他们仅仅能在请求处理线程的范围内被使用，这些对象不能被其余运行线程所引用，因为引用的行为是不肯定的。

四、服务结束
容器没有被要求将一个载入的servlet保存多长时间，所以一个servlet实例可能仅仅在容器中存活了几毫秒，固然也多是其余更长的随意时间（但是确定会短于容器的生存期）
当容器决定将之移除时（缘由多是保存内存资源或者本身被关闭），那么它必须赞成servlet释放它正在使用的不论什么资源并保存不论什么永久状态（这个过程经过调用destroy方法达到）。容器在可以调用destroy方法前，它必须赞成那些正在service方法中运行的线程运行完或者在server定义的一段时间内运行（这个时间段在容器调用destroy以前）。一旦destroy方法被调用，容器就不会再向该实例发送不论什么请求。假设容器需要再使用该servlet，它必须建立新的实例。destroy方法完毕后，容器必须释放servlet实例以便它可以被垃圾回收。

 

3、    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但是仅仅向client返回doGet应该向client返回的头部的内容；
doOptions方法本身主动的返回servlet所直接支持的HTTP方法信息；
doTrace方法返回TRACE请求中的所有头部信息。

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

另外，HttpServlet定义了getLastModified方法以支持有条件的（conditional）get操做。有条件的get操做是指使用GET方式请求资源并且在头部指定仅仅有在资源内容在指定时间后被改动的状况下server才有必要回应请求并发送请求的内容。对于那些实现doGet方法并且在不一样请求之间内容一样的servlet而言，它应该实现这种方法以提升网络资源的利用率。

另外要说起的是，依照规范的要求，servlet容器至少要实现HTTP/1.0协议规范，推荐实现HTTP/1.1规范，在此基础上可以实现其余的基于请求回应模式（based request response model）的协议（好比HTTPS）。

 

4、    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定义。

 

5、    servlet 会话

HTTP协议是一种无状态的协议，而对于现在的web应用而言，咱们每每需要记录从特定client的一系列请求间的联系。现在已经有很是多会话跟踪的技术，但是对于程序猿而言都不是很是方便直接使用。servlet规范定义了一个简单的HttpSession接口以方便servlet容器进行会话跟踪而不需要开发人员注意实现的细节。

通常而言，有两种最常用的会话跟踪机制，一种就是URL重写。在client不接受cookie的状况下可以使用URL重写进行会话跟踪。URL重写包括向URL路径添加一些容器可以解释的数据。规范要求会话ID必须编码在URL路径中，參数名称必须是jsessionid，好比:
http://www.myserver.com/catalog/index.html;jsessionid=1234

还有一种就是现在最常用的cookie了，规范要求所有的servlet都必须支持cookie。容器向client发送一个cookie，client在兴许的处于同一个会话的请求中向server返回该cookie。会话跟踪cookie的名字必须是JSESSIONID。

新出现的一种会话功能是SSL会话，SSL（Secure Sockets Layer，安全套接字层）是HTTPS协议使用的一种加密技术，内建了会话跟踪功能，servlet容器可以很是easy的使用这些数据创建会话跟踪。（但是HTTPS不是规范要求servlet必须支持的协议） 

因为HTTP是一种基于请求响应的协议，所以会话仅仅有在client添�它之后才被新创建。当会话跟踪信息被成功的返回给server以指示会话给创建时client才算添�了一个会话。假设client没有添�会话，那么下一次请求不会被以为是会话的一部分。怎样client还不知道会话或者client选择不添�一个会话，那么会话被以为是新的。开发人员必须本身设计本身的应用中的会话处理状态，在什么地方没有添�会话，什么地方不能添�会话以及什么地方不需要添�会话。
规范要求HttpSession在应用或者servlet上下文级别有效，诸如cookie这种创建会话的底层机制可以在上下文中共享，但是对于那些外露的对象，以及更重要的是对象的那些属性是不能在上下文中共享的。

对于会话的属性的绑定而言，不论什么对象都可以绑定到某个命名属性。被绑定的属性对象对于其余处于一样ServletContext并且处于同一个会话处理中的其余servlet也是可见的。
某些对象在被添�会话或者被从会话中移除时要求获得通知，这种信息可以经过让该对象实现HttpSessionBindingListener接口获得。该接口定义了两个方法用以标记被绑定到会话或者从会话中被移除。
valueBound方法在对象经过getAttribute以前就被调用，而valueUnbound方法在对象已经不能经过getAttribute获得后才被调用。

因为HTTP是无状态协议，所以client再也不活动时没有什么明显的信号，这也就意味着仅仅有一种机制可以用于代表client再也不活动：超时。会话的缺省的时限由servlet容器定义并且可以经过HttpSession的getMaxInactiveInterval获得，开发人员也可以经过使用setMaxInactiveInterval方法进行设置，这些方法返回的单位是秒，假设时限被设置为－1，那么意味着永远不会超时。

经过调用HttpSession的getLastAccessedTime方法，咱们可以获得在当前请求以前的訪问时间。当会话中的一个请求被servlet上下文处理时会话就被以为被訪问了。

另外需要注意的就是一些很是重要的会话的语义问题。
多线程问题：多个请求线程可能会同一时候訪问同一个会话，开发人员有责任以适当的方式同步訪问会话中的资源。
分布式环境：对于被标记为可分布的应用而言，同一会话中的所有请求仅仅能被单一的VM处理。同一时候，放入HttpSession中的所有对象都必须实现Serializable接口，不然容器可能会抛出IllegalArgumentException（在jboss_tomcat下没有抛出这个异常，但是假设在关闭server时还有未完毕的会话，那么server在试图存储会话时会出现串行化异常，在又一次启动的时候会试图回复会话，也会出现异常）。这个限制意味着开发人员不会遇到非可分布容器中的那些并发问题。另外容器提供者可以经过将一个会话对象以及它的内容从分布式系统的一个活动节点移动到系统的其余不一样节点的能力来保证可伸缩性。
client的语义：基于cookie或者SSL证书通常是被web浏览器控制并且不联系到特定浏览器窗体的事实，从client应用的所有窗体发送到容器的请求均可能是同一个会话。为了达到最大的可移植性，开发人员不能总假设特定client的所有窗体的请求都处于同一个会话中。

6、    Bean 和 Servlet 的企业应用

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

　　Enterprise JavaBean技术是J2EE的主要基础。EJB技术对在分布式的计算环境中运行应用逻辑提供了一个可伸缩的框架结构。J2EE经过将EJB组件结构和其余的企业技术相结合，攻克了在Java平台上进行开发和配置服务端应用程序的无缝结合。

　　要使用J2EE开发您的企业应用，您必需要在您的机器上安装一个Webserver，还要支持XML。为了在浏览器中运行Java 2的API，还要给您的浏览器安装一个支持Java2的插件。

　　如下就介绍怎样用J2EE SDK写一个包括了HTML页面，Servlet和Session Bean的一个简单的瘦client的多层体系结构的企业应用程序。听起来是否是心动了呢？如下就開始吧。

还要提醒一点的就是：在编程的时候，适当的添加�catch子句是一个很是好编程风格。假设样例代码抛出了一个正确的异常，代码就被 try/catch这种程序结构包围。Catch子句应该中应该添�处理异常的代码，千万不要留成空白。至少，应该添�语句：e.printStackTrace()来在控制台显示异常信息。

　　J2EE SDK是一个J2EE平台上用于演示、教育等用途的非商业的东东。可以从javasoft的站点上免费下载。很是适合用来学习。假设你没有出国权限，还可以从国内各高校的FTPserver上去下载，速度比較快，但可能版本号不是最新的。


瘦client的多层体系结构的应用程序的样例：

　　本样例经过一个HTML页面的输入来调用一个Servlet，Servlet再用Java的名字文件夹服务接口（JNDI）APIs来寻找一个会话Session Bean，用这个Session Bean来运行一个计算。当Servlet获得了计算的结果的以后，Servlet把计算结果返回给HTML页面的用户。

　　之因此说这是一个瘦client的应用程序，是因为Servlet自己并无运行不论什么的应用逻辑。这个简单的计算是由一个Session Bean在J2EE的应用server上运行的。客户没有參与过程的不论什么操做，所有的计算都是由Session Bean完毕的。

　　所谓的多层体系结果其实是由三或者四层组成的。咱们的样例其实是四层的一个结构。三层的体系结构是在标准的两层的客户/server结构基础上，将一个多线程的应用server加到了非浏览器的client和后台数据库之间。而四层的体系结构是经过Servlet和JavaServer Pages技术将client的应用程序由浏览器和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/j2sdkee1.2.1

J2SE：C:/J2EE/jdk1.2.2


Path和ClassPath的设置：

　　下载的东西包括了J2EE的应用server、Cloudscape数据库、使用了加密套接字协议层的Webserver、开发和配置的工具、企业级的Java APIs。其Path和ClassPath的设置例如如下：

Path的设置：在Windows系统中，需要把Path的文件夹包括如下两个文件夹：

C:/J2EE/j2sdkee1.2.1/bin

C:/J2EE/jdk1.2.2/bin

Classpath的设置：在Windows系统中，需要把Classpath參数包括如下的文件：

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

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

J2EE_HOME=C:/J2EE/j2sdkee1.2.1

JAVA_HOME=C:/J2EE/jdk1.2.2

　　这样，就可以运行C:/J2EE/j2sdkee1.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的建立或者删除里面，你需要附加一些你本身的操做。否者，你并不需要提供这些方法的行为。

7、