Jsp /servlet 总结

Jsp /servlet 总结
1. jsp原理
web服务器中的jsp引擎会编译并执行jsp文件。
Web服务器在遇到访问jsp网页的请求时，首先执行其中的程序片段，然后将执行的结果以html格式返回给客户端。

2. Jsp优点
2.1将内容的生成和显示进行分离。
2.2生成可重用的组件。
2.3采用标示简化页面开发
2.4jsp能提供所有servlets功能。
2.5健壮的存储管理和安全性。
6.一次编写，随处运行。
7.jsp的平台适应性更广。
8.java中连接数据库的技术是jdbc

Asp \ php  速度快（相对jsp）并且简单

指令：
1. jsp:include
<jsp:include page="/data/login.jsp" flush="true">
<jsp:param name="user" value="Joe Blow" />
</jsp:include>
Flush：必须为true
2.jsp:forward 标签重定向一个html文件，jsp文件，程序段
<jsp:forward page=”/temp/login.jsp” >
<jsp:param name=”userid” value=”333” />
</jsp:forward>
3.useBean
<jsp:useBean id=”name” scope=”page|request|session|application” typespec  />
Typespec :
Class=”classname|class=”classname” type=”typename” | beanName=”beanName” type=”typeName” | type=”typename”

3.1
<jsp:useBean id =”cart” scope=”session” class=”session.Carts” >
<jsp:setProperty> name=”checking” property=”balance” value=”0.0” />只在bean被实例化中才被执行。
</jsp:useBean>

3.2
<jsp:useBean id =”cart” scope=”session” class=”session.Carts”/ >
<jsp:setProperty> name=”checking” property=”balance” value=”0.0” />

4 jsp:plugin  java插件
<jsp:plugin type="applet" code="JavaCharter.class"
codebase="/java" vspace="0" hspace="0" width="60"
height="80" jrevision="1.2" >
<jsp:param name="ChartType" value="Bar" />
<jsp:fallback> Unable to initialize Java Plugin
</jsp:fallback>
</jsp:plugin>

<jsp:plugin type=”applet” code=”coo.class”
Codebase=”/examples/jsp/plugin/applet” jreversion=”1.2” width=”160” height=”150”>
<jsp:fallback> loading fail  </jsp:fallback>
</jsp:plugin>

JSP程序由JSP Engine(JSP引擎) 先将它转换成Servlet代码，接着将它编译成类文件载入执行。
只有当客户端第一次请求JSP时，才需要将其转换、编译


Directive 指令
Directive是编译期间执行的指令，常见的指令有：page include taglib

page:指明与JSP Container(JSP容器)的沟通方式
<%@ page language="java"
        import="java.io.*,java.util.*"     引入包和类
        errorPage="errorPageUrl"            如果页面出现错误，跳转到哪个页面
        isErrorPage="false"                  当前页面是否为一个错误页面
        contentType="text/html; charset=GB2312"字符编码形式
        extends="index.jsp"                  指明这个jsp页面是从哪个jsp继承过来的
        buffer="8KB"                           缓冲区，默认为8K。none代表不缓冲
        session="true"                        是否使用session，默认为true
        autoFlush="true"                      页面输出完成后，是否自动刷新到客户端
        info="InfoText"                       指明JSP相关的描述信息
%>

include: JSP Engine会在jsp程序的转换期间先把file属性设定的文件包含进来，然后开始执行转换及编译
<%@ include file="index.jsp"%>//index.jsp后面不能接参数。因为这是一个编译指令



Declaration 声明
<%
int i = 0;//这种声明，i为局部变量
%>
<%!
int j = 0;//这种声明，j为成员变量（全局变量）
public void getMessage(){}//我们可以在此定义成员方法
%>



Action 运行期间的指令
Action是运行期间的指令，常见的指令有:jsp:useBean   jsp:include   jsp:forward

jsp:include
用于动态的JSP程序或HTML文件
除非这个指令被执行到，否则它是不会被Tomcat等JSP Engine编译
<jsp:include page="URLSpec">
    <jsp:param name="ParamName" value="ParmValue"/> //用来设定include文件时的参数和值
</jsp:include>
jsp:forward
用于将一个jsp页面的内容传送到page所指定的jsp程序或者servlet中处理
<jsp:forward page="index.jsp">
    <jsp:param name="paramName" value="paramValue"/>
</jsp:forward>


<jsp:forward>与response.sendRedirect的区别

<jsp:forward>
       1、跳转发生在服务器端，跳转后，客户端的URL地址依然是1.jsp的地址
       2、<jsp:forward>在跳转的过程中，使用的是同一个request对象
       3、工作流程：客户端发出请求，传递到服务器1.jsp页面，1.jsp页面解析代码到<jsp:forward>语句后跳转到2.jsp页面。服务器将2.jsp页面的内容传递给客户端
response.sendRedirect
       1、跳转后，客户端的URL地址发生改变
       2、response.sendRedirect在跳转过程中，是不同的request对象
       3、工作流程：客户端发出请求后，传递到1.jsp页面。1.jsp向客户端发出响应，通知客户端重新访问2.jsp页面。客户端得到请求后，再向2.jsp发出请求。2.jsp将响应内容传递给客户端

<jsp:useBean>
Bean的基本要素：
       1、必须要有一个不带参数的构造器(构造函数)，在jsp元素创建Bean时会调用空构造器
       2、Bean类应该没有任何公共实例变量。也就是说不允许直接访问实例变量，变量名称首字母必须小写
       3、通过getter()和setter()方法来读或写变量值，并且将对应的变量首字母改成大写
       4、Bean要有包，不能使用裸体类

<jsp:useBean id="beanName" class="cn.wyd.testBean" scope="page" type="int">
</jsp:useBean>
id：Bean对象的实例名称
class：包名+类名
scope：这个Bean的作用范围，共有page,request,session,application四个值，默认为page，表示这个Bean只在当前页面有效。
type：Bean的实例类型，如果这个选择的是Object，则表示父类引用指向子类对象

<jsp:setProperty property="count" name="beanName" value="50"/>
设置Bean的属性，property="Bean中的变量名" 这句话相当于beanName.setCount(50);
<jsp:getProperty property="count" name="beanName" />
得到Bean的属性，相当于beanName.getCount();


JSP内置对象
内置对象是在JSP里直接可以使用的对象，包括：
       out request response pageContext session application config exception page

JSP内置对象out
       out内置对象是一个缓冲的输出流，用来给客户端返回信息。
       它是javax.servlet.jsp.JspWriter类的一个实例
常用方法:
       println():向客户端输出各种类型的数据
       write():
       newline():输出一个换行符
       close():关闭输出流
       flush():输出缓冲区里的数据
       clearBuffer():清除缓冲区里的数据，同时把数据输出到客户端
       clear():清除缓冲区里的数据
       getBufferSize():返回缓冲区的大小


JSP内置对象request
request内置对象表示的是调用JSP页面的请求。
它是javax.servlet.http.HttpServletRequest接口的一个实例
可以用此对象取得请求的Header信息，请求方式(get/post)，请求的参数名称、参数值、客户端主机名等
常用方法:
       getParameter(String paramName)  获得form提交过来的参数值,此参数值由paramName指定
       getMethod():返回客户端向服务器传送数据的方法
              getParameterNames():获得客户端传送给服务器的所有参数名，返回枚举类型(Enumeration)
              getParameterValues(String name):获得指定参数的所有值，由name指定
              getRequestURI():获得发出请求字符串的客户端地址
              getRemoteAddr():获取客户端的IP地址
              getRemoteHost():获取客户端的机器名称
              getServerName():获取服务器的名字
           getServerPort():获取服务器端的端口


JSP内置对象response
表示的是返回给客户端的响应
它是javax.servlet.http.HttoServletResponse接口的一个实例
经常用于设置HTTP标题，添加cookie，设置响应内容的类型和状态，发送HTTP重定向和编码URL
常用方法：
           sendRedirect(String url):重定向JSP文件
setContentType(String contentType):设置MIME类型和编码方式
addCookie(Cookie cookie):添加一个cookie对象，用于在客户端保存特定的信息
           addHeader(String name,String value):添加HTTP头信息，该Header信息将发送到客户端
           containsHeader(String name):判断指定名字的HTTP头文件是否存在
           sendError(int):向客户端发送错误的信息
  
JSP内置对象session
常用方法：
       setAttribute(String name ,Object value)
           getAttribute(String name)
           isNew()
           getSessionId()

Servlet和JSP的通信
从JSP调用Servlet可用<jsp:forward>或者sendRedirect，请求信息自动跳转到servlet

从servlet调用JSP使用ResquestDispatcher接口的forward(request,response)方法或者使用sendRedirect跳转到JSP页面




index:
1，什么是Servlet
2，Servlet有什么作用
3，Servlet的生命周期
4，Servlet怎么处理一个请求
5，Servlet与JSP有什么区别
6，Servlet里的cookie技术
7，Servlet里的过滤器
8，Servlet里的监听器


一，什么是Servlet？

Servlet是一个Java编写的程序，此程序是基于Http协议的，在服务器端运行的(如tomcat)，

是按照Servlet规范编写的一个Java类。


二，Servlet有什么作用？

主要是处理客户端的请求并将其结果发送到客户端。


三，Servlet的生命周期？

Servlet的生命周期是由Servlet的容器来控制的，它可以分为3个阶段;初始化，运行，销毁。

初始化阶段：

1，Servlet容器加载servlet类，把servlet类的.class文件中的数据读到内存中。

2，然后Servlet容器创建一个ServletConfig对象。ServletConfig对象包含了Servlet的初始化配置信息。

3，Servlet容器创建一个servlet对象。

4，Servlet容器调用servlet对象的init方法进行初始化。


运行阶段：

当servlet容器接收到一个请求时，servlet容器会针对这个请求创建servletRequest和servletResponse对象。

然后调用service方法。并把这两个参数传递给service方法。Service方法通过servletRequest对象获得请求的

信息。并处理该请求。再通过servletResponse对象生成这个请求的响应结果。然后销毁servletRequest和

servletResponse对象。我们不管这个请求是post提交的还是get提交的，最终这个请求都会由service方法来处理。


销毁阶段：

当Web应用被终止时，servlet容器会先调用servlet对象的destrory方法，然后再销毁servlet对象，

同时也会销毁与servlet对象相关联的servletConfig对象。我们可以在destroy方法的实现中，释放

servlet所占用的资源，如关闭数据库连接，关闭文件输入输出流等。


在这里该注意的地方：

在servlet生命周期中，servlet的初始化和和销毁阶段只会发生一次，而service方法执行的次数则取决于servlet被客户端访问的次数



四，Servlet怎么处理一个请求？

当用户发送一个请求到某个Servlet的时候，Servlet容器会创建一个ServletRequst和ServletResponse对象。
在ServletRequst对象中封装了用户的请求信息，然后Servlet容器把ServletRequst和ServletResponse对象
传给用户所请求的Servlet，Servlet把处理好的结果写在ServletResponse中，然后Servlet容器把响应结果传给用户。


五，Servlet与JSP有什么区别？

1，jsp经编译后就是servlet，也可以说jsp等于servlet。

2，jsp更擅长页面(表现)。servlet更擅长逻辑编辑。 (最核心的区别)。

3，在实际应用中采用Servlet来控制业务流程,而采用JSP来生成动态网页.在struts框架中,

JSP位于MVC设计模式的视图层,而Servlet位于控制层。


六，Servlet里的cookie技术？

cookies是一种WEB服务器通过浏览器在访问者的硬盘上存储信息的手段，是由Netscape公司开发出来的。

cookie技术的好处：

    1、Cookie有效期限未到时，Cookie能使用户在不键入密码和用户名的情况下进入曾经浏览过的一些站点。

    2、Cookie能使站点跟踪特定访问者的访问次数、最后访问时间和访问者进入站点的路径。
   
创建一个cookie
Java代码
1. //里面的两个参数分别是cookie的名和cookie的值 
2.  
3. response.addCookie(new Cookie("abc","10000000")); 

使用cookie
Java代码
1. Cookie[] cook =request.getCookies();//用一个Cookie数组来接收 
2.  
3. for(int j=0;j<cook.length;j++){//通过循环来打印Cookie 
4.  
5.         cook[j].getName()://取cookie的名   
6.         cook[j].getValue()://去cookie的值 
7.  
8. } 


七，Servlet里的过滤器？

过滤器的主要作用

1，任何系统或网站都要判断用户是否登录。

2，网络聊天系统或论坛，功能是过滤非法文字

3，统一解决编码

(2)怎么创建一个过滤器：

1，生成一个普通的class类，实现Filter接口(javax.servlet.Filter;)。

2，重写接口里面的三个方法：init，doFilter，destroy。

3，然后在web.xml配置过滤器。


八，Servlet里的监听器？

监听器的作用：自动执行一些操作。

三种servlet监听器:

对request的监听。对session的监听。对application的监听。

怎么创建一个session监听器：

1，生成一个普通的class类，如果是对session的监听，则实现HttpSessionListener。

2，然后重写里面的五个方法:

Java代码
1. public void sessionCreated(HttpSessionEvent arg0) {} // 创建 
2.  
3. public void sessionDestroyed(HttpSessionEvent arg0) {} // 销毁 
4.  
5. public void attributeAdded(HttpSessionEvent arg0) {} // 增加 
6.  
7. public void attributeRemoved(HttpSessionEvent arg0) {} // 删除 
8.  
9. public void attributeReplaced(HttpSessionEvent arg0) {} // 替换 


Servlet规范简介
引言
Web 框架一般是通过一个 Servlet 提供统一的请求入口，将指定的资源映射到这个 servlet, 在这个 servlet 中进行框架的初始化配置，访问 Web 页面中的数据，进行逻辑处理后，将结果数据与的表现层相融合并展现给用户。 WEB 框架想要在符合 Servlet 规范的容器中运行，同样也要符合 Servlet 规范。
将一个 WEB 框架注入到一个 servlet 中，主要涉及到 Servlet 规范中以下部分：
         部署描述符
         映射请求到 Servlet
         Servlet 生存周期
         请求分发
Servlet 相关技术规范简介
部署描述符
部署描述符就是位于 WEB 应用程序的 /WEB-INF 目录下的 web.xml 的 XML 文件，是 WEB 应用程序不可分割的部分，管理着 WEB 应用程序的配置。部署描述符在应用程序开发人员，应用程序组装人员，应用程序部署人员之间传递 WEB 应用程序的元素和配置信息。
在 WEB 应用程序的部署描描述符中以下类型的配置和部署信息是所有的 servlet 容器必须支持的：
         ServletContext 初始化参数
         Session 配置
        Servlet 声明
        Servlet 映射
        应用程序生存周期监听器
         Filter 的定义和映射
         MIME 类型的映射
        欢迎文件列表
        错误文件列表
出现在部署描述符中的安全信息可以不被支持，除非这个 Servlet 容器是 J2EE 规范实现的一部分。
所有正确的 WEB 应用程序部署描述符 (Servlet2.3 规范 ) 必须包含下面的 DOCTYPE 声明：
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web
Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">

下面说明在部署描述符中是如何进行 Servlet 声明和映射的，这个 DTD 的全部内容可以在下面这个地址获得：
http://java.sun.com/dtd/web-app_2_3.dtd
在这个 DTD 中有关 Servlet 声明和映射和映射的部分如下：
<!--
The servlet element contains the declarative data of a
servlet. If a jsp-file is specified and the load-on-startup element
is present, then the JSP should be precompiled and loaded.
Used in: web-app
-->
<!ELEMENT servlet (icon?, servlet-name, display-name?, description?,
(servlet-class|jsp-file), init-param*, load-on-startup?, runas?,
security-role-ref*)>
<!--
The servlet-class element contains the fully qualified class name
of the servlet.
Used in: servlet
-->
<!ELEMENT servlet-class (#PCDATA)>
<!--
The servlet-mapping element defines a mapping between a servlet
and a url pattern
Used in: web-app
-->
<!ELEMENT servlet-mapping (servlet-name, url-pattern)>
<!--
The servlet-name element contains the canonical name of the
servlet. Each servlet name is unique within the web application.
Used in: filter-mapping, servlet, servlet-mapping
-->
<!ELEMENT servlet-name (#PCDATA)>
根据以上 DTD ，一个典型的 Servlet 的声明的格式如下：
<servlet>
<servlet-name>catalog</servlet-name>
<servlet-class>com.mycorp.CatalogServlet</servlet-class>
<init-param>
<param-name>catalog</param-name>
<param-value>Spring</param-value>
</init-param>
</servlet>
一个典型的Servlet映射如下：
<servlet-mapping>
<servlet-name>catalog</servlet-name>
<url-pattern>/catalog/*</url-pattern>
</servlet-mapping>

通过上面的方法，我们就声明了一个名称为 catalog 的Servlet,它的实现类为com.mycorp.CatalogServlet，并且带有一个catalog参数，参数值为Spring，所有向/catalog/*的请求都被映射到名称为catalog的Servlet。

映射请求到 Servlet
接 收到一个请求后，WEB容器要确定转到哪一个WEB应用程序。被选择的应用程序的最长的上下文路径必须和请求的URL开始部分匹配。URL匹配的部分是映射到Servlet的上下文路径。
WEB 容器下一步必须按照下面的程序定位处理请求的Servlet。
用来映射到Servlet的路径是请求对象的URL减去上下文的路径。下面的URL路径映射规则按顺序执行，容器选择第一个成功的匹配并且不在进行下一个匹配：
        容器试着对请求的路径和Servlet的路径进行精确匹配，如果匹配成功则选择这个Servlet。
        容器会循环的去试着匹配最长的路径前缀：把’/’当作路径分隔符，按照路径树逐级递减的完成，选择最长匹配的Servlet。
        如果这个URL路径的最后有扩展名（比如.jsp）,Servlet容器会试着匹配处理这个扩展名的Servlet。
        如果前面的没有与前面三条规则相匹配的Servlet，容器会试着为资源请求提供适当的资源，如果有“默认”的Servlet定义给这个应用程序，那么这个Servlet会被使用。

容器必须使用一个大小写敏感的匹配方式。
在部署描述符中，用下面的语法定义映射：
        一个以’/’开始并且以’/*’结束的字符串用来映射路径。
        一个以’*.’为前缀的字符串用来映射扩展名。
        一个只包含’/’的字符串指示着这个应用程序“默认”的Servlet，在这种情况下，servlet的路径是请求的URI减去上下文路径，并且这个路径是null。
        所有其他的字符只用来精确匹配。
如果容器内置JSP容器，那么*.jsp被映射到这个容器，并允许JSP页面在需要的时候被执行。这种映射叫做隐含映射。如果WEB应用程序中定义了*.jsp的映射，那么这个映射有比隐含映射高的优先级。
WEB 容器允许显式的声明隐含映射以获得优先级，例如，*.shtml的隐含映射可以在服务器上被映射为包含功能。
映射实例：
path pattern servlet
/foo/bar/* servlet1
/baz/* servlet2
/catalog servlet3
*.bop servlet4
下面是实际请求映射的结果
incoming path servlet handling request
/foo/bar/index.html servlet1
/foo/bar/index.bop servlet1
/baz servlet2
/baz/index.html servlet2
/catalog servlet3
/catalog/index.html “default” servlet
/catalog/racecar.bop servlet4
/index.bop servlet4
请注意/catalog/index.html 和/catalog/racecar.bop这两种情况，因为是精确匹配，所以并没有映射到处理/catalog的servlet。

Servlet 生存周期
在介绍 Servlet 的生存周期之前需要先介绍一下 javax.servlet.Servlet 接口。所有的 Servlet 必须实现或者间接实现这个借口，我们通常可以通过继承javax.servlet.GenericServlet 或者 javax.servlet.http.HttpServlet. 类来实现这个接口。
这个接口中定义了下面 5 种方法：¬¬
public void init(ServletConfig config);
public ServletConfig getServletConfig();
public void service(ServletRequest req, ServletResponse res);
public String getServletInfo();
public void destroy() ;

init() 方法
init 方法在容器器装入 Servlet 时执行， Servlet 容器在实例化后只调用一次 init 方法， init 方法必须在 servlet 接收到任何请求之前完成。
这个方法通常用来进行一些资源的管理和初始化，如从配置文件读取配置数据，读取初始化参数，初始化缓冲迟等一次性的操作。
getServletConfig() 方法
GetServletConfig 方法返回一个 ServletConfig 对象，该对象用来返回这个 Servlet 的初始化信息和启动参数。返回的是传递到 init 方法 ServletConfig 。
Service() 方法
Service 方法是应用程序逻辑的进入点，是 servlet 方法的核心， WEB 容器调用这个方法来响应进入的请求，只有 servlet 成功被 init() 方法初始化后， Service 方法才会被调用。
getServletInfo() 方法
这个方法返回一个字符串对象，提供有关 servlet 的信息，如作者、版本等。
destroy() 方法
destroy 方法在容器移除 Servlet 时执行，同样只执行一次。这个方法会在所有的线程的 service() 方法执行完成或者超时后执行，调用这个方法后，容器不会再调用这个servlet 的方法，也就是说容器不再把请求发送给这个 Servlet 。       这个方法给 servlet 释放占用的资源的机会，通常用来执行一些清理任务。

这个接口定义了初始化一个 servlet, 服务请求和从容器中移除 servlet 的方法。他们按照下面的顺序执行：
1.         servlet 被实例化后，用 init 方法进行初始化
2.         客户端的任何请求都调用 service 方法
3.         servlet 被移除服务，调用 destroy 方法销毁
servlet 的生存周期如下图：
 
请求分发
请求分发可以让一个Servlet把请求分配到另外一个资源，RequestDispatcher接口提供了实现他的机制。可以通过下面两种方式从ServletContext中获得一个实现了RequestDispatcher接口的对象：
• getRequestDispatcher
• getNamedDispatcher
getRequestDispatcher方法接受一个指向目标资源的URL路径
RequestDispatcher rd = getServletContext().getRequestDispatcher(“/catalog”);


getNamedDispatcher方法接受一个Servlet名称参数，这个名称是在部署描述符中<servlet-name>元素指定的那个名称。
RequestDispatcher rd = getServletContext().getNamedDispatcher (“catalog”);


RequestDispatcher接口有两个方法，允许你在调用的servlet完成初步处理后把请求响应分配到另外一个资源，
forward()方法：
public void forward(ServletRequest request, ServletReponse reponse) throws SwerletException,IOException
forward方法上让你把请求转发到另外的Servlet或者jsp或者html等资源，由这个资源接下来负责响应。如：
RequestDispatcher rd = getServletContext().getRequestDispatcher(“/catalog”);
rd. forward(request,response);

include()方法：
public void include (ServletRequest request, ServletReponse reponse) throws SwerletException,IOException
include方法让你的Servlet响应中包含另外一个资源生成内容
RequestDispatcher rd = getServletContext().getRequestDispatcher(“/catalog”);
rd. include(request,response);


结合WebWork的具体分析
WebWork是由OpenSymphony组织开发实现MVC模式的J2EE Web框架。在介绍完servlet规范的相关内容后，我们看看WebWork是如何注入到一个Servlet中的，假设我们有一个上下文环境为“/WebWorkdDemo”的WEB应用。
部署描述符
在部署描述符中，我们需要进行如下配置：
<servlet>
<servlet-name>webwork</servlet-name>
<servlet-class>com.opensymphony.webwork.dispatcher.ServletDispatcher</servlet-class>
</servlet>
……
<servlet-mapping>
<servlet-name>webwork</servlet-name>
<url-pattern>*.action</url-pattern>
</servlet-mapping>
我们声明了一个名为webwork的Servlet和*.action到这个Servlet的映射，这个Servlet就是webwork中的controller，担任MVC框架中非常重要的控制器角色。
映射请求到Servlet
在XWork的配置文件xwork.xml中有如下片段：
<action name="demo" class=" webworkapp.DemoAction">
    <result name="success" type="dispatcher">
       <param name="location">/demo.jsp</param>
    </result>
</action>
这样我们由http://localhost:8080/WebWorkDemo/demo.action这个URL向服务器发出请求时，WEB容器首先确定转到哪一个WEB应用程序，容器将请求URL和上下文环境进行匹配后知道将转到/WebWorkdDemo这个WEB应用。
接下来容器会在/WebWorkdDemo这个应用的部署描述符中进行查找处理这个请求的servlet，根据后缀*.action找到名称为webwork这个Servlet，这样根据部署描述符，这个请求被映射到webwork中的controller组件com.opensymphony.webwork.dispatcher.ServletDispatcher来处理。这个担任控制器组件的Servlet在他的service()方法中在根据请求的路径解析出对应的action来进行处理。
通过上面的的处理，实现了将web请求转到了webwork中的控制器ServletDispatcher。不止是webwork，实现MVC的web框架都需要进行类似的处理来将web请求转入到自己的controller.以便进行进一步的处理。
Servlet生存周期
ServletDispatcher这个Servlet的存周期可以如下：
1)      在服务器启动的时候，容器首先实例化ServletDispatcher
2)        实例化完成后，将调用init()方法，在init方法中执行了以下操作：
         初始化Velocity引擎
         检查是否支持配置文件重新载入功能。如果支持，每个request请求都将重新装载xwork.xml配置文件，在开发时非常方便。
         设置一些文件上传的信息，比如：上传临时目录，上传的最大字节等。
3)      每次请求都调用service（）方法,在service方法中执行了以下方法
         通过request请求取得action的命名空间
         根据servlet请求的Path,解析出要调用该请求的Action的名字（actionName）
         创建Action上下文（extraContext），遍历HttpServletRequest、HttpSession、ServletContext 中的数据，并将其复制到Webwork的Map实现中，至此之后，所有数据操作均在此Map结构中进行，从而将内部结构与Servlet API相分离。
         以上述信息作为参数，调用ActionProxyFactory创建对应的ActionProxy实例。ActionProxyFactory 将根据Xwork 配置文件（xwork.xml）中的设定，创建ActionProxy实例，ActionProxy中包含了Action的配置信息（包括Action名称，对应实现类等等）。
         执行proxy的execute()方法
4)      容器移除Servlet 时执行destroy()，在ServletDispatcher这个Servlet中并没有重写destroy方法，在移除Servlet时，将什么也不做。
请求分发
WebWork提供了多种活灵活视图展现方式，例如还是我们上面在xwork.xml中的配置：
<action name="demo" class=" webworkapp.DemoAction">
    <result name="success" type="dispatcher">
       <param name="location">/demo.jsp</param>
    </result>
</action>
根据以上配置当DemoAction的返回值为"success"时的处理类型为"dispatcher"，当result的type为"dispatcher"时，通过javax.servlet.RequestDispatcher的forward()或include()方法将处理结果和表现层融合后展现给用户
我们可以看看WebWork提供的dispatcher类型Result Type的实现类com.opensymphony .webwork.dispatcher.ServletDispatcherResult中的代码片断：
  HttpServletRequest request = ServletActionContext.getRequest();
  HttpServletResponse response = ServletActionContext.getResponse();
  RequestDispatcher dispatcher = request.getRequestDispatcher(finalLocation);

  if (dispatcher == null) {
    response.sendError(404, "result '" + finalLocation + "' not found"); 
    return;
  }

  if (!response.isCommitted() && (request.getAttribute("javax.servlet.include.servlet_path") == null)) {
    request.setAttribute("webwork.view_uri", finalLocation);
    request.setAttribute("webwork.request_uri", request.getRequestURI());
  
    dispatcher.forward(request, response);
  } else {
    dispatcher.include(request, response);
  }
ServletDispatcherResult类的从ServletActionContex中得到HttpServletRequest和HttpServletResponse，然后调用request.getRequestDispatcher(finalLocation)方法得到一个RequestDispatcher实例，如果返回的是null，则输出404页面未找到的错误，否则将调用dispatcher.forward(request, response)或者dispatcher.include(request, response)进行请求分发，将处理结果和表现层融合后展现给用户。

结束语
       通过以上的介绍，我们对web框架是如何注入到servlet中有了简单的了解，如果想更深入的研究，可以阅读Servlet规范以及一些成熟框架的源码。