下面是测试的一个简单的例子：

//Created by MyEclipse Struts
// XSL source (default): platform:/plugin/com.genuitec.eclipse.cross.easystruts.eclipse_4.1.0/xslt/JavaClass.xsl

package com.test.struts.action;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DispatchAction;

/** *//** 
 * MyEclipse Struts
 * Creation date: 04-21-2006
 * 
 * XDoclet definition:
 * @struts.action parameter="method"
 */
public class MyDispathAction extends DispatchAction {

 // --------------------------------------------------------- Instance Variables

 // --------------------------------------------------------- Methods

 /** *//** 
  * Method execute
  * @param mapping
  * @param form
  * @param request
  * @param response
  * @return ActionForward
  */

 public ActionForward Add(
   ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response) {
  request.setAttribute("method", new String("add"));
  return mapping.findForward("sucess");
 }
 public ActionForward Delete(
   ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response) {
  request.getSession().setAttribute("method", new String("delete"));
  return mapping.findForward("sucess");
 }
}

stuts-config.xml:

    <action
      parameter="method"
      path="/dispath"
      type="com.test.struts.action.MyDispathAction"
      validate="false" >
      <forward name="sucess" path="/sucess.jsp" />
     </action>

需要注意的是要将action中的execute方法删除！！！

调用：

http://127.0.0.1:8080/test/dispath.do?method=Add

http://127.0.0.1:8080/test/dispath.do?method=Delete

Struts标签库

一.html标签

1.html元素的标签:

a1.<html:link forward="index"> 链接<global-forwards>中的name </html:link>

a2. <html:link href="http://www.baidu.com" > 链接到站点外   </html:link>

a3. <html:link page="/HtmlBasic.do">同一个应用     </html:link>

如:包含请求参数: <html:link page="/HtmlBasic.do?prop1=abc&amp;prop2=123" />

   包含单个请求变量:<% String stringBean = "Value to Pass on URL";

                   pageContext.setAttribute("stringBean", stringBean);%>

<html:link page="/HtmlBasic.do" paramId="urlParamName" paramName="stringBean" />

<jsp:useBean id="javaBean" scope="page" class="CustomerBean" />

<jsp:setProperty name="javaBean" property="name" value="weiqin" /> //要有范围

<html:link page="/Html" paramId="url" paramName="javaBean" paramProperty="name"/>

包含多个请求变量: <% java.util.HashMap myMap = new java.util.HashMap();

                      myMap.put("myString", new String("myStringValue") );

                     myMap.put("myArray", new String[] { "str1", "str2", "str3" });

                     pageContext.setAttribute("map", myMap);%>

<html:link page="/HtmlBasic.do" name="map"> url </html:link>

b.<html:img>: <html:img page="/struts-power.gif" /> //也可以包含单个或多个请求变量

<html:img src="/struts-power.gif" paramId="urlParamName" paramName="stringBean" />

<html:img page="/struts-power.gif" name="map" />

2.基本表单标签:<html:form>,<html:text>,<html:hidden>,<html:submit>,<html:reset>

<html:cancel>Cancel</html:cancel> :Action中的取消事件:

FormBasicForm fbf = (FormBasicForm) form;

        if (isCancelled(request)) { fbf.setStatus("Cancel was pressed!");

            return (mapping.findForward("success"));      }//表示取消选中

 else { fbf.setStatus("Submit was pressed!");

            return (mapping.findForward("success"));    }

3.下拉列表和多选列表

<html:select property="colors" size="6" multiple="true" > // multiple下拉可多选

<html:option value="htmlselect.orange">Orange</html:option> //基本的页面输入

<html:option value="red" bundle="htmlselect.Colors" key="red"/>//从资源文件中显示

<% Vector colorCollection = new Vector(); colorCollection.add(

         new org.apache.struts.util.LabelValueBean("Pink", "htmlselect.pink"));

      colorCollection.add(              // Pink为label htmlselect.pink为value

         new org.apache.struts.util.LabelValueBean("Brown", "htmlselect.brown"));

      pageContext.setAttribute("colorCollection", colorCollection);   %>

<html:options collection="colorCollection" property="value" //实际值                   

labelProperty="label" />   </html:select>// labelProperty显示值

4.显示错误消息: errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage("key") );

a.显示全局:<html:errors property="org.apache.struts.action.GLOBAL_MESSAGE"/>

b.显示特定字段: errors.add("checkbox1", new ActionMessage("error.checkbox"));

<html:errors property="checkbox1" bundle="HtmlErrors" /> //bundle资源文件

5.显示信息<html:messages>:

a.<html:messages id=”message” message=”true”/>//如果为true则从全局中搜索

则:ActionMessages actionMessages=new ActionMessages();

actionMessages.add(ActionMessages.GLOBAL_MESSAGE,new ActionMessage(“key”));

saveMessages(request,actionMessages);

b.从一定的范围中查找:<html:messages id=”message”>

<bean:write name=”message” /> </html:messages>

则:protected void saveMessages(HttpServletRequest request,ActionMessages messages){

...request.setAttribute(GLOBAL_MESSAGE_key,messages); }

二:Struts Bean标签

1.访问http请求信息和JSP对象

a. <bean:cookie id="cookie" name="cookiedemo" value="firsttime"/> // value为默认值

     <% if (cookie.getValue().equals("firsttime")) {

         Cookie c = new Cookie("cookiedemo", "Hi Linda!");

         c.setComment("A test cookie");c.setMaxAge(3600);response.addCookie(c);} %>

输出: <bean:write name="cookie" property="value"/>

b. <bean:header id="lang" name="Accept-Language"/> <bean:write name="lang"/>

c. <bean:page id="this_session" property="session"/>//检索JSP范围,隐含对象

   <bean:write name="this_session" property="creationTime"/>

d. <bean:parameter id="arg1" name="testarg" value="noarg"/> // value为默认值

   <bean:write name="arg1"/>

检索多值：<bean:parameter id="arg2" multiple="yes" name="testarg" value="noarg"/>

通过链接传递参数：<html:link page="/this.jsp?testarg=123&testarg=456&testarg=789">

循环输出：<% for (int i=0; i <arg2.length; i++) {out.write(arg2[i] + "<BR>");} %>

2．访问WEB应用资源： <message-resources parameter="res" key="special" />

a. <bean:message key="hello" arg0="Linda" /> //默认资源文件中：hello=Hello,{0}

<% request.setAttribute("stringBean","hello"); SomeBean bean=new SomeBean();

        bean.setName("hello");   request.setAttribute("someBean",bean);   %>

通过变量名或javaBean得到key值再访问资源文件：

<bean:message bundle="special" name="stringBean"/>// bundle不能省,只能访问资源文件

<bean:message bundle="special" name="someBean" property="name"/>

b. <bean:include>同<jsp:include>,但将WEB资源存放在一个变量中，有forward,page,href

<bean:include id="tp1" page="/testpage1.jsp"/> <bean:write name="tp1" filter="false"/>

<bean:include id="tp2" forward="testpage2"/> <bean:write name="tp2" filter="false"/>

3.定义或输出javaBean，bean:write标签filter为true时会将特殊符号转换成普通字符串

a.value属性：<bean:define id="name" value="lib"/><bean:write name="name"/>

 name和property属性：<% request.setAttribute("sessionBean", session); %>

     <bean:define id="contextBean" name="sessionBean" property="servletContext"/>

// contextBean为javax.servlet.ServletContext类型，实例化

<bean:write name="contextBean" property="servletContextName"/>

  name和type属性（用于复制）：<bean:define id="contextBean_copy" name="contextBean"

                    type="javax.servlet.ServletContext"/>

<bean:write name="contextBean_copy" property="majorVersion"/>

三．Struts Logic标签：

1.逻辑判断：（greatEqual,lessEqual,greatThan...）

<% Cookie c = new Cookie("username", "Linda");      c.setComment("A test cookie");

         c.setMaxAge(3600);    response.addCookie(c); %>

a.<logic:equal cookie="username" value="Linda">UserName is Linda </logic:equal>

b. <% SomeBean bean=new SomeBean();    bean.setName("Linda");

        request.setAttribute("someBean",bean);%>

<logic:notEqual name="someBean" property="name" value="Tom">not Tom </logic:notEqual>

c. <% request.setAttribute("number","100"); %>

<logic:lessThan name="number" value="100.0a" > "100" 小于"100.0a"</logic:lessThan >

2．字符串匹配：变量中是否包含指定的字符串

<% request.setAttribute("authorName", "LindaSun");%>

a.<logic:match name="authorName" scope="request" value="Linda">

   <bean:write name="authorName"/> has the string 'Sun' in it.</logic:match>

  <logic:notMatch name="authorName" scope="request" value="Linda" /> //还有end属性

<logic:match name="authorName" scope="request" value="Linda" location="start">

<bean:write name="authorName"/> starts with the string 'Linda'.</logic:match>

3．判断指定内容是否存在

<% ActionErrors errors = new ActionErrors();

errors.add("totallylost", new ActionMessage("application.totally.lost"));

request.setAttribute(Globals.ERROR_KEY, errors);

request.setAttribute("myerrors",errors);request.setAttribute("emptyString","");%>

a.<logic:empty name="emptyString"> emptyString is empty! </logic:empty>

b.<logic:notPresent name="noSuchBean" property="noSuchProperty">

 判断指定的安全角色，用户,cookie,header或javaBean是否存在 </logic:notPresent>

c. <logic:messagesPresent name="myerrors" >在范围内检索key</logic:messagesPresent>

<logic:messagesNotPresent message="true">

从Globals.MESSAGE_KEY中检索，不同于Globals.ERROR_KEY </logic:messagesNotPresent>

<logic:messagesNotPresent  property="noSuchError">

     从指定的ActionMessages对象中检索 </logic:messagesNotPresent>

4．请求转发或重定向a.<logic:forward name="index"/>,与配置中<global-forwards>同名

b.<logic:redirect href="http://www.apache.org"/>,也有page,href和forward三种属性

5．循环遍历//offset为开始位置，indexId为序号

a. 遍历集合<% Vector animals=new Vector(); animals.addElement("Dog");

            animals.addElement("Cat"); animals.addElement("Bird");

request.setAttribute("Animals", animals);%>

<logic:iterate id="element" indexId="index" name="Animals" offset="1" length="2">

<bean:write name="index"/>.<bean:write name="element"/><BR></logic:iterate>

b. 遍历Map<% HashMap h= new HashMap();String fruits[ ] = {"apple","orange","banana"};

h.put("Fruits", fruits); request.setAttribute("catalog", h); %>

<logic:iterate id="map" name="catalog"> <bean:write name="map" property="key"/><BR>

<logic:iterate id="val" name="map" property="value"><bean:write name="val"/>

</logic:iterate>   </logic:iterate>   //如果value不是集合就不用嵌套了

四．利用Tiles模板和Tiles组件创建复合式网页

1.在web.xml中配置所需要的<tablib>url和location

2.建立tiles的xml文件放在WEB-INF下：<?xml version="1.0" encoding="ISO-8859-1" ?>

 <!DOCTYPE tiles-definitions PUBLIC

       "-//Apache Software Foundation//DTD Tiles Configuration 1.1//EN"

       "http://jakarta.apache.org/struts/dtds/tiles-config_1_1.dtd">

<tiles-definitions> <definition name="index-definition" path="/layout.jsp">

      <put name="header" value="header.jsp"/>  

      <put name="content" value="indexContent.jsp"/>  

      <put name="footer" value="footer.jsp"/> </definition>  

<definition name="product-definition" path="/layout.jsp">

      <put name="sidebar" value="sidebar.jsp"/>

      <put name="header" value="header.jsp"/>  

      <put name="content" value="productContent.jsp"/>  

      <put name="footer" value="footer.jsp"/>    </definition>

</tiles-definitions>

3．在struts配置文件中配置TilesPlugin插件（ctrl+n）:

<plug-in className="org.apache.struts.tiles.TilesPlugin" >

    <set-property property="definitions-config" value="/WEB-INF/tiles-defs.xml"/>

<set-property property="definitions-parser-validate" value="true"/> </plug-in>

4.在Action已经存在ActionServlet,并在struts配置文件中配置Action来调用Tiles组件

<action path="/index"   type="org.apache.struts.actions.ForwardAction"

parameter="index-definition">    </action>

ForwardAction为Action内置对象，专门负责转发功能，在将请求转发给parameter的组件

5．在index.jsp中插入Tiles组件<%@ page contentType="text/html; charset=UTF-8" %>

<%@ taglib uri="/WEB-INF/struts-tiles.tld" prefix="tiles" %>

<tiles:insert definition="index-definition"/>

6.在layout.jsp文件中进行布局并设计好其他页面：

<%@ taglib uri="/WEB-INF/struts-tiles.tld" prefix="tiles"%>

<table width="100%" height="100%">

 <tr><td height="15%"><tiles:insert attribute="header"/> </td>  </tr>

 <tr><td valign="top"><tiles:insert attribute="content"/> </td> </tr>

 <tr><td valign="bottom"><tiles:insert attribute="footer"/></td></tr> </table>

备注：在需要出现的页面只有写<tiles:insert definition="*"/>就可以插入框架，根据definition中的content改变主体。

7．Tiles组件的组合（type="definition"）以示区别

<tiles-definitions>

   <definition name="sidebar-definition"   path="/sidebar-layout.jsp">

      <put name="top" value="flags.jsp"/>        </definition>

   <definition name="index-definition"   path="/layout.jsp">

      <put name="sidebar" value="sidebar-definition" type="definition"/>

      <put name="header" value="header.jsp"/>

   </definition>       </tiles-definitions>//将一个组件put成另一个组件的元素

在开始我们的例子前需要说明一下，这篇文章并不打算讲解如何使用struts和velocity，而是将目标锁定在struts和velocity的协同工作上面。

一切准备就绪后，就开始我们的第一个例子吧。

1、建立一个test.vm文件，和jsp放在同一目录中。

<% @ page pageEncoding = " utf-8 " %>
<%
request.setCharacterEncoding( " utf-8 " );
%>
< html >
< head >
< meta  http-equiv ="Content-Type"  content ="text/html; charset=utf-8" >
< title > struts velocity 六月天 </ title >
</ head >
< body >

${test.getTest()} //注意这里使用了velocity代码，从test对象中取数据。

</ body >
</ html >

2、新建Form Bean，使它拥有一个属性test。

public   class  TestForm  extends  ActionForm  {

     private  String test;

     public  String getTest()  {
         return  test;
    }
     public   void  setTest(String test)  {
         this .test  =  test;
    }
}

3、新建一个TestAction。

public   class  TestAction  extends  Action  {

     public  ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest req, HttpServletResponse res)  {

        TestForm cform  =  (TestForm)form;

        cform.setTest( " hello struts and velocity " );

         // 注意这里，将form置入request中，它的key是test
         // 这个key也就是vm页面中的test对象的引用${test.getTest()}
        req.setAttribute( " test " , cform);
         return  mapping.findForward( " success " );
    }
}

4、配置struts-config.xml文件

< form-beans >
< form-bean  name ="TestForm"  type ="org.junesky.form.TestForm" />
</ form-beans >
< action
name ="TestForm"
input ="/error.jsp"
scope ="request"
path ="/test"
validate ="false"
type ="org.junesky.action.TestAction"   >

< forward 
name ="success"
path ="/test.vm"   />
</ action >

检查没有错误后，运行，就会在页面上显示出hello struts and velocity。

　　关于struts和velocity的配置是很容易理解的，最令初学者头痛的是，velocity是如何取到数据的？我们在单独使用velocity进行开发时，需要初始化，并为其设置想要返回的页面。如下：

VelocityEngine ve  =   new  VelocityEngine();
ve.init();
Template t  =  ve.getTemplate(  " hellosite.vm "  );

而当与struts一同进行开发时，这一步就可以省去了，并且我们不必在为context中赋值：

VelocityContext context  =   new  VelocityContext();
context.put( " test " ,  " hello struts and velocity  " );

我们只需在Struts的Action层中将值置入request或session中即能达到相同的效果。

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=INFO, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.Threshold=INFO
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=- %m%n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.RollingFileAppender
log4j.appender.LOGFILE.File=webapps/ColorTone/logs/test.log

# 在windows平台可以不加后缀日志也能生成，
# 但在linix平台下需要加后缀。

log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.Threshold=ERROR
log4j.appender.LOGFILE.MaxFileSize=10000KB
log4j.appender.LOGFILE.MaxBackupIndex=1000
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n

该配置文件说明：
同时输出到控制台和test.log文件中，log文件最大为10m，最大为1000个；
当一个日志文件达到最大尺寸时，Log4J会自动把test.log重命名为test.log.1，然后重建一个新的test.log文件，依次轮转；
在控制台输出的级别为info；
在日志文件输出为error级；

如果需要改为每天一个日志文件，则为：

2、在ColorTone目录下建立logs目录

3、在action中增加
static Logger _log = Logger.getLogger(LoginAction.class.getName()); //log4j（1）
然后就可以在需要的地方进行日志记载
_log.debug("做下测试.debug");
_log.info("做下测试.info");
_log.warn("做下测试.warn");
_log.error("做下测试.error");
_log.fatal("做下测试.fatal");
注：日志文件最有有后缀，如logs.log，否则在linix版本下不能生成日志文件

    Struts与Spring结合的基本知识请阅读Struts使用要点。

1.DispatchAction

     以一个Controller响应一组动作绝对是Controller界的真理，Struts的DispatchAction同样可以做到这点。

    其中parameter="method" 设置了用来指定响应方法名的url参数名为method，即/admin/user.do?method=list 将调用UserAction的public ActionForward list(....) 函数。   

    public ActionForward unspecified(....) 函数可以指定不带method方法时的默认方法。

2. struts-config.xml使用通配符

     对一些CRUD的Action，可以使用通配符，如果这批action里某个action某个方法还存在特殊路径，可以在代码里直接new ActionForward("/foo.jsp");

3.No FormBean

    Struts 1.2.7 之后一共有三种方法，不需要定义FormBean Java类也不需要在struts-config.xml里详细定义formBean的每个属性。

    第一种是appfuse里使用的，定义DynaValidatorForm里，内嵌一个pojo属性.

    第二种是用BeanValidatorForm，直接把Pojo作FormBean，无需继承于FormBean接口。

    比如User对象 有 id,name,status三个属性，而form表单中只有id和name两个input框，如果使用方法1，2，直接把user 作为 form bean,  user对象的status因为没设值，将为null，  copy 到作为商业对象的user时，就会以null覆盖原值。而lazyBean就没有这个问题，如果form中没有status属性，它不会将它copy给商业对象。

    另外，apache commons-beantuils 1.7.0的lazybean仍有小bug,需要使用commons-1.7.1 snapshot版，而且它直接提供下载的snapshot版缺少了几个class，应使用springside提供的版本。

  4. 一些不必受困于Struts机制的简化写法

    一些简便直接的方法，大家可不必太受困于Struts的机制：

  4.1 不在struts-config.xml配置jsp路径，直接在代码里跳转

   4.2 不走jsp，直接输出字符串

 4.3. 不依赖Struts Taglib，EL直接输出FormBean 属性

普通FormBean：${bookForm.image}

LazyValidatorForm：${bookForm.map.image} 

其中bookForm 是formBean名。另一种输出属性的方式是使用jodd-form, 设<jodd:form bean="bookForm">

4.4 不用i18N地使用Message与Error

   Struts的ActionMessages很常用，但只接收i18N的key作为输入参数，老定义i18n很麻烦，偏方之一就是设一个message= {0}，然后直接new ActionMessage("message", message);

5. 终极化简--StrutsEntityAction

 SpringSide封装的EnttiyCRUDAction，，每个包含了CRUD操作的Action仅需如下代码，详细请阅读SpringSide的Struts封装

我将自己知道的web.xml的元素整理了一下：

web.xml首先是肯定要包含它的schema.

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">

</web-app>

其它的元素都放在<web-app></web-app>之中。

<discription></discription> 是对站台的描述
<display-name></display-name> 定义站台的名称
<distributable/> 是指定该站台是否可分布式处理


<context-param></context-param> 用来设定web站台的环境参数，它包含两个子元素：
    <param-name></param-name> 用来指定参数的名称
    <param-value></param-value> 用来设定参数值

比如：
<context-param>
    <param-name>my_param</param-name>
    <param-value>hello</param-value>
</context-param>

在此设定的参数，可以在servlet中用 getServletContext().getInitParameter("my_param") 来取得


<filter></filter> 是用来声明filter的相关设定，它包含以下子元素：
    <filter-name></filter-name> 这当然就是指定filter的名字
    <filter-class></filter-class> 这是用来定义filter的类的名称
    <init-param></init-param> 用来定义参数，它有两个子元素：
        <param-name></param-name> 用来指定参数的名称
        <param-value></param-value> 用来设定参数值

比如：
<filter>
        <filter-name>setCharacterEncoding</filter-name>
        <filter-class>com.myTest.setCharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>GB2312</param-value>
        </init-param>
</filter>

与<filter></filter>同时使用的是<filter-mapping></filter-mapping> 用来定义filter所对应的URL，它有两个子元素：
    <filter-name></filter-name> 指定filter的名字
    <url-pattern></url-pattern> 指定filter所对应的URL

比如：
<filter-mapping>
        <filter-name>setCharacterEncoding</filter-name>
        <url-pattern>/*</url-pattern>
</filter-mapping>


<listener></listener> 用来设定Listener接口，它的主要子元素为
    <listener-class></listener-class> 定义Listener的类名称

比如：
<listener>
    <listener-class>com.myTest.ContextListener</listener-class>
</listener>


<servlet></servlet> 用来声明一个servlet的数据，主要有以下子元素：
    <servlet-name></servlet-name> 指定servlet的名称
    <servlet-class></servlet-class> 指定servlet的类名称
    <jsp-file></jsp-file> 指定web站台中的某个JSP网页的完整路径
    <init-param></init-param> 用来定义参数，和前面的<init-param>差不多

同样，与<servlet></servlet>一起使用的是<servlet-mapping></servlet-mapping> 用来定义servlet所对应的URL，包含两个子元素：
    <servlet-name></servlet-name> 指定servlet的名称
    <url-pattern></url-pattern> 指定servlet所对应的URL

比如：
<servlet>
        <servlet-name>ShoppingServlet</servlet-name>
        <servlet-class>com.myTest.ShoppingServlet</servlet-class>
</servlet>
   
<servlet-mapping>
        <servlet-name>ShoppingServlet</servlet-name>
        <url-pattern>/shop/ShoppingServlet</url-pattern>
</servlet-mapping>


<session-config></session-config> 用来定义web站台中的session参数，包含一个子元素：
    <session-timeout></session-timeout> 用来定义这个web站台所有session的有效期限，单位为                                                              分钟


<mime-mapping></mime-mapping> 定义某一个扩展名和某一个MIME Type做对映，包含两个                                                        子元素：
    <extension></extension> 扩展名的名称
    <mime-type></mime-type> MIME格式

比如：
<mime-mapping>
    <extension>doc</extension>
    <mime-type>application/vnd.ms-word</mime-type>
</mime-mapping>
<mime-mapping>
    <extension>xls</extension>
    <mime-type>application/vnd.ms-excel</mime-type>
</mime-mapping>


<welcome-file-list></welcom-file-list> 用来定义首页的列单，包含一个子元素：
    <welcome-file></welcome-file> 指定首页的文件名称

比如：
<welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>index.html</welcome-file>
</welcom-file-list>


<error-page></error-page> 用来处理错误代码或异常的页面，有三个子元素：
    <error-code></error-code> 指定错误代码
    <exception-type></exception-type> 指定一个JAVA异常类型
    <location></location> 指定在web站台内的相关资源路径

比如：
<error-page>
    <error-code>404</error-code>
    <location>/error404.jsp</location>
</error-page>
<error-page>
    <exception-type>java.lang.Exception</exception-type>
    <location>/exception.jsp</location>
</error-page>


<taglib></taglib> 用来设定JSP网页所用到的Tag Library路径，有两个子元素：
    <taglib-uri></taglib-uri> 定义TLD文件的URI，在JSP网页中用taglib指令便可取得该URI的                                              TLD文件
    <taglib-location></taglib-location> 指定TLD文件相对于web站台的存放位置

比如：
<taglib>
      <taglib-uri>myTaglib</taglib-uri>
      <taglib-location>/WEB-INF/tlds/MyTaglib.tld</taglib-location>
</taglib>


<resource-ref></resource-ref> 定义利用JNDI取得站台可利用的资源，有五个子元素：
    <description></description> 资源说明
    <rec-ref-name></rec-ref-name> 资源名称
    <res-type></res-type> 资源种类
    <res-auth></res-auth> 资源经由Application或Container来许可
    <res-sharing-scope></res-sharing-scope> 资源是否可以共享，有Shareable和Unshareable两个                                                                     值，默认为Shareable

比如，配置数据库连接池就可在此配置：
<resource-ref>
        <description>JNDI JDBC DataSource of shop</description>
        <res-ref-name>jdbc/sample_db</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
</resource-ref>

配置web.xml来限制对某些servlet的请求

有时我们只希望通过认证的用户才能请求某些servlet的话，就可以在web.xml中来进行相应的配置，来达到此目的。

这就要用到<security-constraint></security-constraint>元素。
对于tomcat，中web.xml使用security-constraint元素需要在位于<Tomcat-installation-directory>/conf/tomcat-users.xml的XML文件中创建用户名和密码。比如下面的这个tomcat-users.xml文件：

<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
  <role rolename="tomcat"/>
  <role rolename="manager"/>
  <role rolename="admin"/>
  <user username="tomcat" password="tomcat" roles="tomcat"/>
  <user username="both" password="tomcat" roles="tomcat,manager"/>
  <user username="admin" password="admin" roles="admin"/>
</tomcat-users>

此XML片段包括一个tomcat-users根元素，它包含一个或多个role和user元素。


然后在Web应用程序的web.xml中创建security-constraint、login-config和security-role元素。

<security-constraint>
      <web-resource-collection>
          <web-resource-name>HelloServlet</web-resource-name>
          <url-pattern>/HelloServlet</url-pattern>
          <http-method>GET</http-method>
          <http-method>POST</http-method>
      </web-resource-collection>
      <auth-constraint>
          <description>This applies only to the "tomcat" security role</description>
          <role-name>admin</role-name>
      </auth-constraint>
      <user-data-constraint>
          <transport-guarantee>NONE</transport-guarantee>
      </user-data-constraint>
  </security-constraint>
 
  <login-config>
      <auth-method>BASIC</auth-method>
  </login-config>
  <security-role>
      <role-name>admin</role-name>
  </security-role>

其中security-constraint元素包含一个或多个web-resource-collection元素，它是描述Web应用程序中的哪些web资源受到指定安全限制的保护。http-method元素指定安全限制覆盖的HTTP方法。上面的例子中，当我们对/HelloServlet的GET或POST请求时将触发配置的安全机制。
auth-constraint元素用于描述允许访问Web组件的安全角色。此例中安全角色的例子有tomcat、manager、admin。而只有当作为admin角色的用户才可以访问HelloServlet。

Web应用程序通过login-config元素来认证用户，并确认该用户是否为正确的角色。
longin-config包含的transport-guarantee子元素用来指定认证方法，BASIC是一种常见的Web认证方式，浏览器给用户提示一个对话框，要求输入用户名和密码，随后Tomcat将给出的用户名和密码与tomcat-users.xml中的用户名和密码进行比较，然后使用前面的security-constraint配置来确定用户是否可访问受保护的servlet。

（除BASIC外，还可以是FORM、CLIENT-CERT、DIGEST等）

其实这种认证方法实际上有两个步骤：
1、检查提供的用户名和密码是否正确。
2、判断用户是否映射到特定的安全角色。例如，用户可能提供了正确的用户名和密码，但没有映射到特定的安全角色，也将被禁止访问特定的Web资源。



通过此次整理，对web.xml中元素有了更清楚的了解，以后继续努力...

一．配置JSTL

包括两个JAR文件，jstl.jar 和standard.jar。是什么没有必要管 

原文引入：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

二．Core标签库

Core标签库主要包括了一般用途的标签、条件标签、迭代标签和URL相关的标签。在JSP页面使用Core标签，要使用taglig指令，指定引用的标签库，如下：

<%@ taglib uri=”http://java.sun.com/jsp/jstl/core” prefix=”c” %>

一般用途的标签有<c:out>、<c:set>、<c:remove>、<c:cath>

1.<c:out>

用于计算一个表达式并将结果输出。类似于JSP 中<%=%>表达式，或者是EL中$ ${el-expression}。

2.<c:set>

用于设置范围变量的值或者javabean对象的属性。

看个实际例子：

<c:set var=”username” value=”lisi” scope=”session”/>

这样就相当于设置了session。

 3.<c:remove>

相对<c:set>其作用是移除范围变量。比如

<c:remove var=”nusername” scope=”session”/>

4.<c:catch>

 用于捕获在其中嵌套的操作所抛出的异常对象，并将异常信息保存到变量中。

我们将有可能抛出异常的代码放置到开始标签:<c:catch>和结束标签:</c:catch>之间。如果其中代码出现异常，异常对象将被捕获，保存在var声明的变量中，该变量总是有page范围。如果没有发生异常，而var所标识的范围变量将被移除。

如果没有指定var属性，异常只是简单的被捕获，异常信息并不会被保存。

Eg：

<c:catch var=”exception”>
<%
       int i = 5;
       int j = 0;
       int k=i/j;
%>
</c:catch>
<c:out value=”${exception}” /><br>
<c:out value=”${exception.massage}”/>

后一句相当于：exception.getMessage()

条件标签包括<c:if><c:choose><c:when><c:otherwise>

1.<c:if>
用于实现java中的if语句功能。

<c:if test=”${user.visitCount==1}”>

       This is your first visit .

</c:if>

若为true，会打印中间部分。也可以声明var，方便下一步判断。

<c:if test=”${param.name==’admin’}” value=”result”/>
<c:out value=”${result}” />

2.<c:choose>
<c:choose>和<c:when>、<c:otherwise>一起实现互斥条件执行，类似于java中的if else.
<c:choose>一般作为<c:when>、<c:otherwise>的父标签。

eg：

<c:choose>
       <c:when test="${row.v_money<10000}">
              初学下海
       </c:when>
       <c:when test="${row.v_money>=10000&&row.v_money<20000}">

            身手小试
        </c:when>
       <c:otherwise>
              商业能手
       </c:otherwise>
</c:choose>

迭代标签 迭代标签有<c:forEach>和</c:forEach>
//遍历记录集

<c:forEach items="${finalResult.rows}" var="row">        
<tr class="<%=tdClass[(rank+1)%2]%>">
<td align="center"><span><%=rank%> </span></td>
<td align="center"><span ><c:out value="${row.player_name}"/></span> </td>
<td align="center"><span >￥<c:out value="${row.money}"/></span></td>
</tr>
<%rank++;%>      
</c:forEach> 

也可以设定固定次数。

<c:forEach var =”i” begin=”100 “ end= “110”>

       ${i}

</c:forEach>

如果再加个step=“2”那么每次增长为2。

三．sql标签

//设置数据源：

<sql:setDataSource dataSource="proxool.breadTycoon" />

//将数据库某查询的结果声明为一个变量

<sql:query var="finalResult" >
    select player_name,money from tb_player order by money DESC LIMIT 10    
</sql:query>

       然后可以：

<c:forEach items="${ finalResult.rows}" var="row" varStatus="s">

        advCosts[${s.index}]=${row.adv_cost};

   </c:forEach>

      数据更新标签：

     <sql:update>   
                call proc_set_role_salespro(?,?,?,?,?);
                <sql:param value="30"/>
                <sql:param value="39"/>
                <sql:param value="<%=spID%>"/>
                <sql:param value="<%=productID%>"/>
                <sql:param value="1"/>                
     </sql:update>

四．格式化标签

<fmt: formatNumber value =”12.3” pattern=”.000”/>

将输出12.300.应用样式”.000”,将使格式化后的小数部分有3位。不足3位将以0补齐

   <fmt:formatDate value=”<%=new java.util.Date() %>” type=”date” />

 格式化的结果是：2007-5-27.

<fmt:formatDate value=”<%=new java.util.Date() %>” type=”time” />

格式化的结果是：9:25:11

<fmt:formatDate value=”<%=new java.util.Date() %>” type=”both” />

格式化的结果是： 2007-5-27 9:25:11

fn函数
JSTL1.1标签库还包含了许多其它经常使用的函数：

fn:contains(string, substring)
 如果参数string中包含参数substring，返回true
 
fn:containsIgnoreCase(string, substring)
 如果参数string中包含参数substring（忽略大小写），返回true
 
fn:endsWith(string, suffix)
 如果参数 string 以参数suffix结尾，返回true
 
fn:escapeXml(string)
 将有特殊意义的XML (和HTML)转换为对应的XML character entity code，并返回
 
fn:indexOf(string, substring)
 返回参数substring在参数string中第一次出现的位置
 
fn:join(array, separator)
 将一个给定的数组array用给定的间隔符separator串在一起，组成一个新的字符串并返回。
 
fn:length(item)
 返回参数item中包含元素的数量。参数Item类型是数组、collection或者String。如果是String类型,返回值是String中的字符数。
 
fn:replace(string, before, after)
 返回一个String对象。用参数after字符串替换参数string中所有出现参数before字符串的地方，并返回替换后的结果
 
fn:split(string, separator)
 返回一个数组，以参数separator 为分割符分割参数string，分割后的每一部分就是数组的一个元素
 
fn:startsWith(string, prefix)
 如果参数string以参数prefix开头，返回true
 
fn:substring(string, begin, end)
 返回参数string部分字符串, 从参数begin开始到参数end位置，包括end位置的字符
 
fn:substringAfter(string, substring)
 返回参数substring在参数string中后面的那一部分字符串
 
fn:substringBefore(string, substring)
 返回参数substring在参数string中前面的那一部分字符串
 
fn:toLowerCase(string)
 将参数string所有的字符变为小写，并将其返回
 
fn:toUpperCase(string)
 将参数string所有的字符变为大写，并将其返回
 
fn:trim(string)
 去除参数string 首尾的空格，并将其返回

 主要是替换
<sql:setDataSource var="dataSrc"
    url="jdbc:jtds:sqlserver://localhost/LOG_DB" driver="net.sourceforge.jtds.jdbc.Driver"
    user="sa" password="admin"/>
    <%-- Set number of rows to process --%>
    <c:set var="noOfRows" value="100" />
    <c:set var="msg" value="select top 100 * from L_ips_tb where id> (select max (id) from
(select top ard id from L_ips_tb order by id) as T
)     order by id"/>
 <c:set var="test" value="${fn:replace(msg,'ard',100)}" />

 <c:out value="${test}" />
    <sql:query var="empList"
      sql="${test}"       dataSource="${dataSrc}"
    />
   <c:out value="${fn:length(empList.rows)}"/>
使用反射
<c:setvar="arrayvalue"value="ID,SrcIP"/>
<c:setvar="delim"value=","/>
<c:setvar="array"value="${fn:split(arrayvalue,delim)}"/>
<c:setvar="count"value="${fn:length(array)}"/>

array是一个String数组，loghistory是一个Map

<c:forEachvar="loghistory"items="${loghistory}"varStatus="statusindex">

<c:forEachbegin="0"end="${count-1}""varStatus="index">
<c:outvalue="${loghistory[array[index.index]]}"/>
</c:forEach>
<c:choose>

使用二维数组
<c:forEach items="${applicationScope[param.answersMapName]}"
          var="a">
          ${a.key}) ${a.value}:
          ${applicationScope[param.votesMapName][a.key]}<br>
        </c:forEach〉

这是一个接口，其中只包含一个方法 convert (java.lang.Class type, java.lang.Object value) ，其功能是将输入参数 value 转换为指定类型 type 的实例。

范例：

我建立了一个 Rectangle 对象，并为这 rectangle 对象建立了一个 RectangleConverter ，随后将 RectangleConverter 注册进 ConvertUtils 中。形为 {3,2} 的字符串可以转变为一个 rectangle 。

这里唯一要说明的就是 RectangleConverter 中要实现两个 converter 方法，也就是要对接口 Converter 中定义的方法进行 overload ，从而可以实现字符串和 Rectangle 之间的互相转换了。

 

}

















1）创建如下类：
package com.forever.util;

import java.util.*;
import org.apache.commons.beanutils.*;
import java.text.SimpleDateFormat;

public class DateConvert implements Converter {
static SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// HH:mm:ss

public DateConvert() {
}

public Object convert(Class type, Object value) {
if(value==null)return null;
if(((String)value).trim().length()==0)
return null;
if(value instanceof String) {
try {
//解析接收到字符串
return df.parse((String)value);
} catch (Exception ex) {
//发生解析异常
throw new ConversionException("输入的日期类型不合乎yyyy-MM-dd HH:mm:ss" + value.getClass());
}
} else {
//其他异常
throw new ConversionException("输入的不是字符类型" + value.getClass());
}
}
}

2）然后在你的系统某处使用如下（如web的init方法）
ConvertUtils.register(new DateConvert(),java.util.Date.class);
参数用于表示DateConvert类负责处理java.util.Date类型的转化。如：
package com.forever.util;

import org.apache.struts.action.ActionServlet;
import javax.servlet.ServletException;
import org.apache.commons.beanutils.ConvertUtils;

public class ActiveServlet extends ActionServlet {

/**
* 重载init()方法
* 为struts解析重新注册一些改造过的表单元素数据解析方法
*/
public void init() throws ServletException {
super.init();
ConvertUtils.register(new DateConvert(), java.util.Date.class);
}
}
3）在web.xml文件中加入或修改成如下内容：

< servlet >
< servlet-name >action< /servlet-name >
< servlet-class >com.forever.util.ActiveServlet< /servlet-class >
< init-param >
< param-name >config< /param-name >
< param-value >/WEB-INF/struts-config.xml< /param-value >
< /init-param >
...........
< /servlet >

当用到BeanUtils.getProperty()时，碰到Date这种类型就发生转换

在示范中心项目中，我们把ActionForm中日期类型的字段指定为String类型，而在对应的JavaBean中指定为java.sql.Date类型。当用户提交表单的时候，在Action里使用BeanUtils.copyProperties()方法从ActionForm构造JavaBean对象（详见利用BeanUtils在对象间复制属性）。这个方法在大部分时候都很好，但有一个问题，就是当用户没有填写日期类型字段时（而该字段并非必填），validator不会提出警告，而在copyProperties()时会报类型转换异常，原因是这时ActionForm中的该字段的值是空字符串（""），负责字符串向Date转换的SqlDateConverter类调用Date.valueOf("")方法，显然""是无法转换为日期的，所以会抛出异常。

通过查看代码和资料，我发现这个问题的解决方法其实非常简单。只要把带缺省值参数的SqlDateConverter重新注册一下，覆盖原有的注册信息就可以了，这个注册语句一般是写在系统初试化的地方，对于Struts应用程序，当然做在PlugIn里最方便。代码如下：

package etc;

import javax.servlet.ServletException;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.beanutils.converters.SqlDateConverter;
import org.apache.struts.action.ActionServlet;
import org.apache.struts.action.PlugIn;
import org.apache.struts.config.ModuleConfig;

public class ConverterPlugIn implements PlugIn{

    public  void  init(ActionServlet servlet, ModuleConfig config) throws ServletException {
        ConvertUtils.register( new  SqlDateConverter( null ),java.sql.Date.class);
    }

    public  void  destroy() {
        ConvertUtils.deregister();
    }
}

注意SqlDateConverter的构造方法是带有参数null的，这表示遇到不能解析的字符串就返回空值。而deregister()方法的作用是恢复ConvertUtils的缺省注册表。为了使这个PlugIn起作用，要在struts-config.xml里增加一句话：

< plug - in  className = " etc.ConverterPlugIn "   />

日期字段往往会给我们的开发带来麻烦，其实在Struts应用程序里，只要把这些转换类搞熟了，总可以找到很方便的办法。常见的问题还有如何指定日期输入格式，怎样处理java.util.Date的转换，等等，在这个链接里有解决这些问题的方法，道理都是一样的。

ServletContextAttributeListener监听对ServletContext属性的操作，比如增加、删除、修改属性。

ServletContextListener监听ServletContext。当创建ServletContext时，激发contextInitialized(ServletContextEvent sce)方法；当销毁ServletContext时，激发contextDestroyed(ServletContextEvent sce)方法。

HttpSessionListener监听HttpSession的操作。当创建一个Session时，激发session Created(HttpSessionEvent se)方法；当销毁一个Session时，激发sessionDestroyed (HttpSessionEvent se)方法。

HttpSessionAttributeListener监听HttpSession中的属性的操作。当在Session增加一个属性时，激发attributeAdded(HttpSessionBindingEvent se) 方法；当在Session删除一个属性时，激发attributeRemoved(HttpSessionBindingEvent se)方法；当在Session属性被重新设置时，激发attributeReplaced(HttpSessionBindingEvent se) 方法。

下面我们开发一个具体的例子，这个监听器能够统计在线的人数。在ServletContext初始化和销毁时，在服务器控制台打印对应的信息。当ServletContext里的属性增加、改变、删除时，在服务器控制台打印对应的信息。

要获得以上的功能，监听器必须实现以下3个接口：

HttpSessionListener

ServletContextListener

ServletContextAttributeListener

我们看具体的代码，见示例14-9。

【程序源代码】

1 // ==================== Program Discription =====================
2 // 程序名称：示例14-9 : EncodingFilter .java
3 // 程序目的：学习使用监听器
4 // ==============================================================
5 import javax.servlet.http.*;
6 import javax.servlet.*;
7
8 public class OnLineCountListener implements HttpSessionListener,
ServletContextListener,ServletContextAttributeListener
9 {
10  private int count;
11  private ServletContext context = null;
12  
13  public OnLineCountListener()
14  {
15   count=0;
16   //setContext();
17  }
18  //创建一个session时激发
19  public void sessionCreated(HttpSessionEvent se)
20  {
21   count++;
22   setContext(se);
23   
24  }
25  //当一个session失效时激发
26  public void sessionDestroyed(HttpSessionEvent se)
27  {
28   count--;
29   setContext(se);
30  }
31  //设置context的属性，它将激发attributeReplaced或attributeAdded方法
32  public void setContext(HttpSessionEvent se)
33  {
34   se.getSession().getServletContext().
setAttribute("onLine",new Integer(count));
35  }
36   //增加一个新的属性时激发
37  public void attributeAdded(ServletContextAttributeEvent event) {
38 
39  log("attributeAdded('" + event.getName() + "', '" +
40      event.getValue() + "')");
41 
42     }
43    
44    //删除一个新的属性时激发
45     public void attributeRemoved(ServletContextAttributeEvent event) {
46
47  log("attributeRemoved('" + event.getName() + "', '" +
48      event.getValue() + "')");
49 
50     }
51
52  //属性被替代时激发
53     public void attributeReplaced(ServletContextAttributeEvent event) {
54 
55   log("attributeReplaced('" + event.getName() + "', '" +
56       event.getValue() + "')");
57     }
58     //context删除时激发
59      public void contextDestroyed(ServletContextEvent event) {
60 
61   log("contextDestroyed()");
62   this.context = null;
63 
64     }
65 
66     //context初始化时激发
67     public void contextInitialized(ServletContextEvent event) {
68 
69   this.context = event.getServletContext();
70   log("contextInitialized()");
71 
72     }
73     private void log(String message) {
74 
75      System.out.println("ContextListener: " + message);
76     }  
77 }
 

【程序注解】
在OnLineCountListener里，用count代表当前在线的人数，OnLineCountListener将在Web服务器启动时自动执行。当OnLineCountListener构造好后，把count设置为0。每增加一个Session，OnLineCountListener会自动调用sessionCreated(HttpSessionEvent se)方法；每销毁一个Session，OnLineCountListener会自动调用sessionDestroyed(HttpSessionEvent se)方法。当调用sessionCreated(HttpSessionEvent se)方法时，说明又有一个客户在请求，此时使在线的人数（count）加1，并且把count写到ServletContext中。ServletContext的信息是所有客户端共享的，这样，每个客户端都可以读取到当前在线的人数。
 

从作用域范围来说,Servlet的作用域有ServletContext,HttpSession,ServletRequest.

Context范围:

ServletContextListener:
对一个应用进行全局监听.随应用启动而启动,随应用消失而消失主要有两个方法:

contextDestroyed(ServletContextEvent event)

在应用关闭的时候调用

contextInitialized(ServletContextEvent event)

在应用启动的时候调用

这个监听器主要用于一些随着应用启动而要完成的工作,也就是很多人说的我想在容器
启动的时候干..........
一般来说对"全局变量"初始化,如

public void contextInitialized(ServletContextEvent event){
ServletContex sc = event.getServletContext();
sc.setAttribute(name,value);
}

以后你就可以在任何servlet中getServletContext().getAttribute(name);
我最喜欢用它来做守护性工作,就是在contextInitialized(ServletContextEvent event)
方法中实现一个Timer,然后就让应用在每次启动的时候让这个Timer工作:
程序代码：
public void contextInitialized(ServletContextEvent event){
timer = new Timer();
timer.schedule(new TimerTask(){
public void run(){
//do any things
}
},0,时间间隔);
}

有人说Timer只能规定从现在开始的多长时间后,每隔多久做一次事或在什么时间做
一次事,那我想在每月1号或每天12点做一项工作如何做呢?
你只要设一个间隔,然后每次判断一下当时是不是那个时间段就行了啊,比如每月一号做,那你
时间间隔设为天,即24小时一个循环,然后在run方法中判断当时日期new Date().getDate()==1
就行了啊.如果是每天的12点,那你时间间隔设为小时,然后在run中判断new Date().getHour()
==12,再做某事就行了.

ServletContextAttributeListener:

这个监听器主要监听ServletContex对象在setAttribute()和removeAttribute()的事件,注意
也就是一个"全局变量"在被Add(第一次set),replace(对已有的变量重新赋值)和remove的时候.
分别调用下面三个方法:
public void attributeAdded(ServletContextAttributeEvent scab)这个方法不仅可以知道
哪些全局变量被加进来,而且可获取容器在启动时自动设置了哪些context变量:
程序代码：
public void attributeAdded(ServletContextAttributeEvent scab){
System.out.println(scab.getName());
}
public void attributeRemoved(ServletContextAttributeEvent scab)

public void attributeReplaced(ServletContextAttributeEvent scab)

Session范围:
HttpSessionListener:
这个监听器主要监听一个Session对象被生成和销毁时发生的事件.对应有两个方法:
程序代码：
public void sessionCreated(HttpSessionEvent se)

public void sessionDestroyed(HttpSessionEvent se)

一般来说,一个session对象被create时,可以说明有一个新客端进入.可以用来粗略统计在线人
数,注意这不是精确的,因为这个客户端可能立即就关闭了,但sessionDestroyed方法却会按一定
的策略很久以后才会发生.

HttpSessionAttributeListener:
和ServletContextAttributeListener一样,它监听一个session对象的Attribut被Add(一个特定
名称的Attribute每一次被设置),replace(已有名称的Attribute的值被重设)和remove时的事件.
对就的有三个方法.
程序代码：
public void attributeAdded(HttpSessionBindingEvent se)

public void attributeRemoved(HttpSessionBindingEvent se)

public void attributeReplaced(HttpSessionBindingEvent se)

上面的几个监听器的方法,都是在监听应用逻辑中servlet逻辑中发生了什么事,一般的来说.
我们只要完成逻辑功能,比如session.setAttribute("aaa","111");我只要把一个名为aaa的变量
放在session中以便以后我能获取它,我并不关心当session.setAttribute("aaa","111");发生时
我还要干什么.(当然有些时候要利用的),但对于下面这个监听器,你应该好好发解一下:

HttpSessionBindingListener:
上面的监听器都是作为一个独立的Listener在容器中控制事件的.而HttpSessionBindingListener
对在一对象中监听该对象的状态,实现了该接口的对象如果被作为value被add到一个session中或从
session中remove,它就会知道自己已经作为一个session对象或已经从session删除,这对于一些非
纯JAVA对象,生命周期长于session的对象,以及其它需要释放资源或改变状态的对象非常重要.
比如:
session.setAttribute("abcd","1111");
以后session.removeAttribute("abcd");因为abcd是一个字符中,你从session中remove后,它就会
自动被垃圾回收器回收,而如果是一个connection:(只是举例,你千万不要加connection往session
中加入)
程序代码：
session.setAttribute("abcd",conn);

以后session.removeAttribute("abcd");这时这个conn被从session中remove了,你已经无法获取它
的句柄,所以你根本没法关闭它.而在没有remove之前你根本不知道什么时候要被remove,你又无法
close(),那么这个connection对象就死了.另外还有一些对象可以在被加入一个session时要锁定
还要被remove时要解锁,应因你在程序中无法判断什么时候被remove(),add还好操作,我可以先加锁
再add,但remove就后你就找不到它的句柄了,根本没法解锁,所以这些操作只能在对象自身中实现.
也就是在对象被add时或remove时通知对象自己回调相应的方法:
程序代码：
MyConn extends Connection implements HttpSessionBindingListener{
public void valueBound(HttpSessionBindingEvent se){
this.initXXX();
}
public void valueUnbound(HttpSessionBindingEvent se){

this.close();
}
}

session.setAttribute("aaa",new MyConn());
这时如果调用session.removeAttribute("aaa"),则触发valueUnbound方法,就会自动关闭自己.
而其它的需要改变状态的对象了是一样.

        Log4j 由三个重要的部件构成：记录器（ Loggers ）、输出源（ Appenders ）和布局（ Layouts ）。

    记录器按照布局中指定的格式把日志信息写入一个或多个输出源。输出源可以是控制台、文本文件、 XML 文件或 Socket ，甚至还可以把信息写入到 Windows 事件日志或通过电子邮件发送。我们可以通过配置文件来部署这些组件。

    Log4j提供两种配置方法： 代码配置和文件配置

    Log4j 允许程序员定义多个记录器，每个记录器有自己的名字。但有一个记录器叫根记录器，它永远存在，且不能通过名字检索或引用，在配置文件中，可以如下定义根记录器

log4j.rootLogger  =  [ level ] , appenderName, appenderName, … 

             Level 是记录器的级别，它是日志记录的优先级，分为 OFF 、 FATAL 、 ERROR 、 WARN 、 INFO 、 DEBUG 、 ALL 或者您定义的级别。 Log4j 建议只使用四个级别： ERROR 、 WARN 、 INFO 、 DEBUG ：   
右边的级别比左边的高。如果一条log信息的级别，大于等于记录器的级别值，那么记录器就会记录它。例如level被设置为INFO级别，那么应用程序中所有的DEBUG的日志信息将不被打印出来。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。

     日志信息输出源 Appender
           log4j 还允许日志记录请求打印到多个输出目的地，按 log4j 的叫法是输出源。一个记录器可以有多个输出源。一条 log 信息如果可被这个记录器处理，则该记录器会把这条信息送往每个它所拥有的输出源，以及层次结构中更高级的输出源。例如，根记录器以控制台作为输出源，则所有可被纪录的日志都将至少打印到控制台。

# For JBoss: Avoid to setup Log4J outside $JBOSS_HOME / server / default / deploy / log4j.xml !
# For all other servers: Comment out the Log4J listener in web.xml to activate Log4J.
# log4j.rootLogger = INFO, stdout, logfile         
log4j.rootLogger = INFO, stdout                 //配置根记录器

配置日志信息输出源，其语法为:

log4j.appender.stdout = org.apache.log4j.ConsoleAppender                       //控制台
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern =% d  % p [ % c]  -   % m % n

log4j.appender.logfile = org.apache.log4j.RollingFileAppender                //文件大小到一定就会产生一个新的文件 
log4j.appender.logfile.File = $ {espc.root} / WEB - INF / espc.log               //指定记录文件的位置  
log4j.appender.logfile.MaxFileSize = 512KB                                   //文件最大限制
# Keep three backup files.
log4j.appender.logfile.MaxBackupIndex = 3
# Pattern to output: date priority [category]  -  message
log4j.appender.logfile.layout = org.apache.log4j.PatternLayout                 //文件的布局
log4j.appender.logfile.layout.ConversionPattern =% d  % p [ % c]  -   % m % n          # %d{}:日志信息产生时间      # %p:日志信息级别 # %c:日志信息所在地（类名）
                                                                                                                                                       # %m:产生的日志具体信息# %n:输出日志信息换 行