树形结构在实际开发中很常用，但是树形结构的开发往往也是难题，尤其是在显示这一条上，很难做到通用。通常有两种典型的树型结构。一种是论坛的帖子，其结构往往通过父子ID号相连,数据在一张表里。一种是级别，比如论坛中的Category->Forum->Thread这种结构，数据放在不同的表里。因为论坛恰好包含了这两种结构。因此。我们就能Jive的表结构来做这个例子。首先我们通过RsMetaDataTest来扫描数据库，得到需要的XML配置文件。拿一个xml为例，解释一下

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sql-map
PUBLIC "-//iBATIS.com//DTD SQL Map 1.0//EN"
"http://www.ibatis.com/dtd/sql-map.dtd">
<sql-map name="jivecategory">
<!-- =============================================
    mapped-statement find 
============================================= -->
<dynamic-mapped-statement name="findjivecategoryDao"  result-class="java.util.HashMap">
   select $listfield$  from JIVECATEGORY
   <dynamic prepend="where">
      <isPropertyAvailable prepend="and" property="CATEGORYID" >
         <isNotNull prepend="" property="CATEGORYID" >
             CATEGORYID=#CATEGORYID#
         </isNotNull>
      </isPropertyAvailable>
      <isPropertyAvailable prepend="and" property="NAME" >
         <isNotNull prepend="" property="NAME" >
             NAME=#NAME#
         </isNotNull>
      </isPropertyAvailable>
      <isPropertyAvailable prepend="and" property="DESCRIPTION" >
         <isNotNull prepend="" property="DESCRIPTION" >
             DESCRIPTION=#DESCRIPTION#
         </isNotNull>
      </isPropertyAvailable>
      <isPropertyAvailable prepend="and" property="CREATIONDATE" >
         <isNotNull prepend="" property="CREATIONDATE" >
             CREATIONDATE=#CREATIONDATE#
         </isNotNull>
      </isPropertyAvailable>
      <isPropertyAvailable prepend="and" property="MODIFIEDDATE" >
         <isNotNull prepend="" property="MODIFIEDDATE" >
             MODIFIEDDATE=#MODIFIEDDATE#
         </isNotNull>
      </isPropertyAvailable>
      <isPropertyAvailable prepend="and" property="LFT" >
         <isNotNull prepend="" property="LFT" >
             LFT=#LFT#
         </isNotNull>
      </isPropertyAvailable>
      <isPropertyAvailable prepend="and" property="RGT" >
         <isNotNull prepend="" property="RGT" >
             RGT=#RGT#
         </isNotNull>
      </isPropertyAvailable>
   </dynamic>	  
</dynamic-mapped-statement>

可见有一个名叫findjivecategoryDao，这是一个典型的动态查询。返回对象是HashMap。其中$listfield$表示动态读取的字段。可以这么说，通过这个查询。有关这样表的任何方式的查询都已经解决了。由于这个演示只用到四张表，因些我们在sql-map-config-storedb.xml也只加载了四张表的定义。

然后定义MenuDefine类，这个类是一个通用的定义，其主要属性如下。可以通过它建立一个四张表的树形关系。

然后建立一个XML的文件(此处简化了它的功能，就是把上面这个类序列化了一下)。把它放在classes目录下。

<?xml version="1.0" encoding="UTF-8"?> 
<java version="1.4.2_03" class="java.beans.XMLDecoder"> 
 <object class="java.util.HashMap"> 
  <void method="put"> 
   <string>message</string> 
   <object class="com.ewuxi.champion.MenuDefine"> 
    <void property="keymap"> 
     <object class="java.util.HashMap"> 
      <void method="put"> 
       <string>MESSAGEID</string> 
       <string>PARENTMESSAGEID</string> 
      </void> 
     </object> 
    </void> 
    <void property="listField"> 
     <string>MESSAGEID,SUBJECT</string> 
    </void> 
    <void property="menuName"> 
     <string>message</string> 
    </void> 
    <void property="sqlMapName"> 
     <string>jivemessage</string> 
    </void> 
    <void property="sqlName"> 
     <string>findjivemessageDao</string> 
    </void> 
    <void property="submenuName"> 
     <string>message</string> 
    </void> 
    <void property="title"> 
     <string>文章</string> 
    </void> 
    <void property="titleField"> 
     <string>SUBJECT</string> 
    </void> 
   </object> 
  </void> 
  <void method="put"> 
   <string>category</string> 
   <object class="com.ewuxi.champion.MenuDefine"> 
    <void property="keymap"> 
     <object class="java.util.HashMap"> 
      <void method="put"> 
       <string>CATEGORYID</string> 
       <string>CATEGORYID</string> 
      </void> 
     </object> 
    </void> 
    <void property="listField"> 
     <string>CATEGORYID,NAME</string> 
    </void> 
    <void property="menuName"> 
     <string>category</string> 
    </void> 
    <void property="sqlMapName"> 
     <string>jivecategory</string> 
    </void> 
    <void property="sqlName"> 
     <string>findjivecategoryDao</string> 
    </void> 
    <void property="submenuName"> 
     <string>forum</string> 
    </void> 
    <void property="title"> 
     <string>大分类</string> 
    </void> 
    <void property="titleField"> 
     <string>NAME</string> 
    </void> 
   </object> 
  </void> 
  <void method="put"> 
   <string>forum</string> 
   <object class="com.ewuxi.champion.MenuDefine"> 
    <void property="keymap"> 
     <object class="java.util.HashMap"> 
      <void method="put"> 
       <string>FORUMID</string> 
       <string>FORUMID</string> 
      </void> 
     </object> 
    </void> 
    <void property="listField"> 
     <string>FORUMID,NAME</string> 
    </void> 
    <void property="menuName"> 
     <string>forum</string> 
    </void> 
    <void property="sqlMapName"> 
     <string>jiveforum</string> 
    </void> 
    <void property="sqlName"> 
     <string>findjiveforumDao</string> 
    </void> 
    <void property="submenuName"> 
     <string>thread</string> 
    </void> 
    <void property="title"> 
     <string>子分类</string> 
    </void> 
    <void property="titleField"> 
     <string>NAME</string> 
    </void> 
   </object> 
  </void> 
  <void method="put"> 
   <string>thread</string> 
   <object class="com.ewuxi.champion.MenuDefine"> 
    <void property="keymap"> 
     <object class="java.util.HashMap"> 
      <void method="put"> 
       <string>THREADID</string> 
       <string>THREADID</string> 
      </void> 
      <void method="put"> 
       <string>FORUMID</string> 
       <string>FORUMID</string> 
      </void> 
      <void method="put"> 
       <string>ROOTMESSAGEID</string> 
       <string>MESSAGEID</string> 
      </void> 
     </object> 
    </void> 
    <void property="listField"> 
     <string>THREADID,ROOTMESSAGEID</string> 
    </void> 
    <void property="menuName"> 
     <string>thread</string> 
    </void> 
    <void property="needShow"> 
     <boolean>false</boolean> 
    </void> 
    <void property="sqlMapName"> 
     <string>jivethread</string> 
    </void> 
    <void property="sqlName"> 
     <string>findjivethreadDao</string> 
    </void> 
    <void property="submenuName"> 
     <string>message</string> 
    </void> 
    <void property="title"> 
     <string>栏目</string> 
    </void> 
    <void property="titleField"> 
     <string>ROOTMESSAGEID</string> 
    </void> 
   </object> 
  </void> 
 </object> 
</java> 

    

关联关系是category表通过CATEGORYID与forum关联，forum通过FORUMID与thread关联，thread是一张特殊的表。它将不显示在树中，只是一个过渡关联，用于读出新建的文章。

thread通过FORUMID、FORUMID、ROOTMESSAGEID与message表关联(FORUMID、FORUMID、MESSAGEID)。而message表是一个自关联的表。MESSAGEID与PARENTMESSAGEID关联建立父子关系。

然后我们建立一个session类作为主要类

public class TreeDemoSession {
	//通过名称和参数来得到树
	public MenuComponent getMenu(String name, Map keys) throws Exception {
		Map menuMap =
			(Map) (new XmlUtils().read(Service.getPath() + "/menu.xml"));
		MenuComponent menu = new MenuComponent();

		if (menuMap.get(name) != null) {
			MenuDefine rootMenudefine = (MenuDefine) menuMap.get(name);
			menu.setTitle(rootMenudefine.getTitle());
			menu.setName(rootMenudefine.getMenuName());

			menu = submenuAdd(menu, keys, menuMap, name);
		}
		return menu;
	}

	/**一个典型的递归函数。用以组织树。
	 * @param menu
	 * @param map
	 * @param menuMap
	 * @param menuName
	 * @return
	 * @throws DaoException
	 * @throws Exception
	 */
	private MenuComponent submenuAdd(
		MenuComponent menu,
		Map map,
		final Map menuMap,
		String menuName)
		throws DaoException, Exception {
		try {
			//得到菜单定义
			MenuDefine menudefine = (MenuDefine) menuMap.get(menuName);
			//listfield,表示需要读取哪几个字段
			map.put("listfield", menudefine.getListField());
			//查询，返回列表。
			List list = DaoCommon.findbyName(map, menudefine.getSqlName());

			int namei = 0;
			for (Iterator iter = list.iterator(); iter.hasNext();) {
				Map element = (Map) iter.next();
                //建立当前节点
				MenuComponent submenu = new MenuComponent();
				submenu.setName(menu.getName() + String.valueOf(namei++));
				submenu.setTitle(
					String.valueOf(element.get(menudefine.getTitleField())));
					//如果不需要显示，则使用父节点作为当前节点
				if (!menudefine.isNeedShow())
					submenu = menu;
				//如果有子菜单，则递归调用。	
				if (menudefine.getSubmenuName() != null) {

					submenu =
						submenuAdd(
							submenu,
							getSubMenuInfo(menudefine, element),
							menuMap,
							menudefine.getSubmenuName());
				}
				//将当前节点放到树中。(如果不需要显示就不用放)
				if (menudefine.isNeedShow())
					menu.addMenuComponent(submenu);
			}
			return menu;
		} catch (DaoException e) {

			throw e;
		} catch (Exception e) {

			throw e;
		}
	}

	/**将父菜单的关键字段的值作为参数给子菜单
	 * @param menudefine
	 * @param element
	 * @return
	 */
	private HashMap getSubMenuInfo(MenuDefine menudefine, Map element) {
		HashMap map = new HashMap();
		for (Iterator iter = menudefine.getKeymap().keySet().iterator();
			iter.hasNext();
			) {
			String key = (String) iter.next();
			map.put(menudefine.getKeymap().get(key), element.get(key));
		}
		return map;
	}
} 

三个函数，非常简单，主函数读取配置文件的内容。一个递归函数用来建立树形结构。这棵树只有两个属性被设置。一个是名字和标题。其中标题采用从数据库里读出的字段。名字则采用流水号。读取数据库只有一句,其中map是参数的一个列表。后面是sql的名字。

而真正的实现代码也非常简单

下面我们来做Action的工作

这个函数也非常简单，就是把从request传来的内容生成一个Map对象。然后调用session,将返回结果以com.ewuxi.champion.menu为名字保存到request中去。

最后我们需要生成一个自定义的taglib。实际上很简单。只是因为struts-menu自身的taglib是写死了，我们不能利用，不过只要改一个地方就可以了,copy UseMenuDisplayerTag到我们的目录下。

找到上面这一段，改成

就OK了。然后需要建立一个JSP文件。我们把xtree.jsp借用过来。唯一需要改的就是<cp:displayMenu name="com.ewuxi.champion.menu"/>，当然还有几个link的路径。因为此处用treeDemo来所以就是href="/treeDemo/styles/xtree.css"

下面就可以自由的看效果了。

上面是几种不同的参数。主要的差别是menuName不同。然后也可以加数据库需要的参数，比如java分类的forumId=1。就在参数中加FORUMID=1,注意大小写要跟XML中的动态参数相同，此处全是大写。

在线演示看这样http://demo.ewuxi.com:8000/treejivedemo/,
源码下载
http://champion.ewuxi.com/old/opensource/struts-new/treeDemo.rar

既然我们知道了需要使用advisor向主要代码中注入“不可见的”advice，让我们实现一个Spring AOP的例子。在这个例子中，我们将实现一个before advice，这意味着advice的代码在被调用的public方法开始前被执行。以下是这个before advice的实现代码：

代码:
package com.company.springaop.test;

import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;

public class TestBeforeAdvice implements MethodBeforeAdvice {

public void before(Method m, Object[] args, Object target)
throws Throwable {
System.out.println("Hello world! (by "
+ this.getClass().getName()
+ ")");
}
}

接口MethodBeforeAdvice只有一个方法before需要实现，它定义了advice的实现。before方法共用三个参数，它们提供了相当丰富的信息。参数Method m是advice开始后执行的方法。方法名称可以用作判断是否执行代码的条件。Object[] args是传给被调用的public方法的参数数组。当需要记日志时，参数args和被执行方法的名称，都是非常有用的信息。你也可以改变传给m的参数，但要小心使用这个功能；编写最初主程序的程序员并不知道主程序可能会和传入参数的发生冲突。Object target是执行方法m对象的引用。

在下面的BeanImpl类中，每个public方法调用前，都会执行advice：

代码:
package com.company.springaop.test;

public class BeanImpl implements Bean {

public void theMethod() {
System.out.println(this.getClass().getName()
+ "." + new Exception().getStackTrace()[0].getMethodName()
+ "()"
+ " says HELLO!");
}
}

类BeanImpl实现了下面的接口Bean：

代码:
package com.company.springaop.test;

public interface Bean {
public void theMethod();
}

虽然不是必须使用接口，但面向接口而不是面向实现编程是良好的编程实践，Spring也鼓励这样做。

pointcut和advice通过配置文件来实现，因此，接下来你只需编写主方法的Java代码：
代码:

package com.company.springaop.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Main {

public static void main(String[] args) {
//Read the configuration file
ApplicationContext ctx
= new FileSystemXmlApplicationContext("springconfig.xml");

//Instantiate an object
Bean x = (Bean) ctx.getBean("bean");

//Execute the public method of the bean (the test)
x.theMethod();
}
}

我们从读入和处理配置文件开始，接下来马上要创建它。这个配置文件将作为粘合程序不同部分的“胶水”。读入和处理配置文件后，我们会得到一个创建工厂ctx。任何一个Spring管理的对象都必须通过这个工厂来创建。对象通过工厂创建后便可正常使用。

仅仅用配置文件便可把程序的每一部分组装起来。
代码:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<!--CONFIG-->
<bean id="bean" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>com.company.springaop.test.Bean</value>
</property>
<property name="target">
<ref local="beanTarget"/>
</property>
<property name="interceptorNames">
<list>
<value>theAdvisor</value>
</list>
</property>
</bean>

<!--CLASS-->
<bean id="beanTarget" class="com.company.springaop.test.BeanImpl"/>

<!--ADVISOR-->
<!--Note: An advisor assembles pointcut and advice-->
<bean id="theAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
<ref local="theBeforeAdvice"/>
</property>
<property name="pattern">
<value>com\.company\.springaop\.test\.Bean\.theMethod</value>
</property>
</bean>

<!--ADVICE-->
<bean id="theBeforeAdvice" class="com.company.springaop.test.TestBeforeAdvice"/>
</beans>

四个bean定义的次序并不重要。我们现在有了一个advice，一个包含了正则表达式pointcut的advisor，一个主程序类和一个配置好的接口，通过工厂ctx，这个接口返回自己本身实现的一个引用。

BeanImpl和TestBeforeAdvice都是直接配置。我们用一个唯一的ID创建一个bean元素，并指定了一个实现类。这就是全部的工作。

advisor通过Spring framework提供的一个RegexMethodPointcutAdvisor类来实现。我们用advisor的一个属性来指定它所需的advice-bean。第二个属性则用正则表达式定义了pointcut，确保良好的性能和易读性。

最后配置的是bean，它可以通过一个工厂来创建。bean的定义看起来比实际上要复杂。bean是ProxyFactoryBean的一个实现，它是Spring framework的一部分。这个bean的行为通过一下的三个属性来定义：

属性proxyInterface定义了接口类。

属性target指向本地配置的一个bean，这个bean返回一个接口的实现。

属性interceptorNames是唯一允许定义一个值列表的属性。这个列表包含所有需要在beanTarget上执行的advisor。注意，advisor列表的次序是非常重要的。

Spring工具

虽然你可以手工修改Ant构建脚本，但使用SpringUI（译注：SpringUI现在是Spring framework的一部分，并改名为spring-ide），使用Spring AOP变得很简单，只要点点鼠标即可。你可以把SpringUI安装成Eclipse的一个plug-in。然后，你只需在你的project上右击鼠标，并选择“add Spring Project Nature”。在project属性中，你可以在“Spring Project”下添加Spring配置文件。在编译前把下面的类库加入project：aopalliance.jar，commons-logging.jar，jakarta-oro-2.0.7.jar和spring.jar。运行程序时你会看到下面的信息：

... (logging information)
Hello world! (by com.company.springaop.test.TestBeforeAdvice)
com.company.springaop.test.BeanImpl.theMethod() says HELLO!

优点和缺点

Spring比起其他的framework更有优势，因为除了AOP以外，它提供了更多别的功能。作为一个轻型framework，它在J2EE不同的部分都可以发挥作用。因此，即使不想使用Spring AOP，你可能还是想使用Spring。另一个优点是，Spring并不要求开发团队所有的人员都会用它。学习Spring应该从Spring reference的第一页开始。读了本文后，你应该可以更好地理解Spring reference了。Spring唯一的缺点是缺乏更多的文档，但它的mailing list是个很好的补充，而且会不断地出现更多的文档

在做hbiernate的many-to-many的双向关联时，一方要设置inverse="true"，另一方要设置inverse="false"。inverse="false"的一方保存时，维护多对多之间的关系，且只要将相互的关系告诉这一方即可。

如果inverse都设置为true，双方的关系将都不到维护。

如果都设置为false，双方将共同维护之间的关系，这时，要将双方的包含关系都要设置清楚，否则将会导致关系维护混乱。

如果设置了casade="save-update"，只能设置一方，如果双方都设置的话，当更新一方的时候，同时会更新另一方，另一方的更新又会导致一方的更新。

lazy loading指的是当实际要使用到某个数据字段时候，才将其从数据库中去出，避免内存的浪费。

inverse . inverse默认是false .当你指定inverse="true" cascade="none"  时，这个实体对这个属性是没有持久更新的权利的，它把这个属性的管理权利完全交给了关联的另一方了。

　　Eclipse 中已经集成了Ant，我们可以直接在Eclipse中运行Ant。

　　以前面建立的Hello工程为例，创建以下目录结构：

　　新建一个build.xml，放在工程根目录下。build.xml定义了Ant要执行的批处理命令。虽然Ant也可以使用其它文件名，但是遵循标准能更使开发更规范，同时易于与别人交流。

　　通常，src存放Java源文件，classes存放编译后的class文件，lib存放编译和运行用到的所有jar文件，web存放JSP等web文件，dist存放打包后的jar文件，doc存放API文档。

　　然后在根目录下创建build.xml文件，输入以下内容：

<xml version="1.0"?>
<roject name="Hello world" default="doc">

<-- properies -->
<roperty name="src.dir" value="src" />
<roperty name="report.dir" value="report" />
<roperty name="classes.dir" value="classes" />
<roperty name="lib.dir" value="lib" />
<roperty name="dist.dir" value="dist" />
<roperty name="doc.dir" value="doc"/>

<-- 定义classpath -->
<ath id="master-classpath">
<ileset file="${lib.dir}/*.jar" />
<athelement path="${classes.dir}"/>
<path>

<-- 初始化任务 -->
<arget name="init">
<target>

<-- 编译 -->
<arget name="compile" depends="init" description="compile the source files">
<kdir dir="${classes.dir}"/>
<avac srcdir="${src.dir}" destdir="${classes.dir}" target="1.4">
<lasspath refid="master-classpath"/>
<javac>
<target>

<-- 测试 -->
<arget name="test" depends="compile" description="run junit test">
<kdir dir="${report.dir}"/>
<unit printsummary="on"
haltonfailure="false"
failureproperty="tests.failed"
showoutput="true">
<lasspath refid="master-classpath" />
<ormatter type="plain"/>
<atchtest todir="${report.dir}">
<ileset dir="${classes.dir}">
<nclude name="**/*Test.*"/>
<fileset>
<batchtest>
<junit>
<ail if="tests.failed">
***********************************************************
**** One or more tests failed! Check the output ... ****
***********************************************************
<fail>
<target>

<-- 打包成jar -->
<arget name="pack" depends="test" description="make .jar file">
<kdir dir="${dist.dir}" />
<ar destfile="${dist.dir}/hello.jar" basedir="${classes.dir}">
<xclude name="**/*Test.*" />
<xclude name="**/Test*.*" />
<jar>
<target>

<-- 输出api文档 -->
<arget name="doc" depends="pack" description="create api doc">
<kdir dir="${doc.dir}" />
<avadoc destdir="${doc.dir}"
author="true"
version="true"
use="true"
windowtitle="Test API">
<ackageset dir="${src.dir}" defaultexcludes="yes">
<nclude name="example/**" />
<packageset>
<octitle>[CDATA[<1>ello, test<h1>]>doctitle>
<ottom>[CDATA[<>ll Rights Reserved.<i>]>bottom>
<ag name="todo" scope="all" description="To do:" />
<javadoc>
<target>
<project>

　　以上xml依次定义了init（初始化），compile（编译），test（测试），doc（生成文档），pack（打包）任务，可以作为模板。

　　选中Hello工程，然后选择“Project”，“Properties”，“Builders”，“New…”，选择“Ant Build”：

　　填入Name：Ant_Builder；Buildfile：build.xml；Base Directory：${workspace_loc:/Hello}（按“Browse Workspace”选择工程根目录），由于用到了junit.jar包，搜索Eclipse目录，找到junit.jar，把它复制到Hello/lib目录下，并添加到Ant的Classpath中：

　　然后在Builder面板中钩上Ant_Build，去掉Java Builder：

　　再次编译，即可在控制台看到Ant的输出：

Buildfile: F:\eclipse-projects\Hello\build.xml

init:

compile:
[mkdir] Created dir: F:\eclipse-projects\Hello\classes
[javac] Compiling 2 source files to F:\eclipse-projects\Hello\classes

test:
[mkdir] Created dir: F:\eclipse-projects\Hello\report
[junit] Running example.HelloTest
[junit] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.02 sec

pack:
[mkdir] Created dir: F:\eclipse-projects\Hello\dist
[jar] Building jar: F:\eclipse-projects\Hello\dist\hello.jar

doc:
[mkdir] Created dir: F:\eclipse-projects\Hello\doc
[javadoc] Generating Javadoc
[javadoc] Javadoc execution
[javadoc] Loading source files for package example...
[javadoc] Constructing Javadoc information...
[javadoc] Standard Doclet version 1.4.2_04
[javadoc] Building tree for all the packages and classes...
[javadoc] Building index for all the packages and classes...
[javadoc] Building index for all classes...
[javadoc] Generating F:\eclipse-projects\Hello\doc\stylesheet.css...
[javadoc] Note: Custom tags that could override future standard tags: @todo. To avoid potential overrides, use at least one period character (.) in custom tag names.
[javadoc] Note: Custom tags that were not seen: @todo
BUILD SUCCESSFUL
Total time: 11 seconds

　　Ant依次执行初始化，编译，测试，打包，生成API文档一系列任务，极大地提高了开发效率。将来开发J2EE项目时，还可加入部署等任务。并且，即使脱离了Eclipse环境，只要正确安装了Ant，配置好环境变量ANT_HOME=<nt解压目录>Path=…;%ANT_HOME%\bin，在命令行提示符下切换到Hello目录，简单地键入ant即可。

1：配置web.xml文件。定义DispatcherServlet，DispatcherServlet处理的请求（.htm）也在同一个web.xml文件里使用url-mapping定义映射。

 <servlet>
  <servlet-name>upload</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet
  </servlet-class>
  <load-on-startup>1</load-on-startup>
 </servlet>
 
 <servlet-mapping>
  <servlet-name>upload</servlet-name>
  <url-pattern>*.htm</url-pattern>
 </servlet-mapping>
2：定义upload-servlet.xml文件。
<bean id="multipartResolver"
       class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- set the max upload size100MB -->
        <property name="maxUploadSize">
        <value>104857600</value>
    </property>
    <property name="maxInMemorySize">
        <value>4096</value>
    </property>
   </bean>
 <bean id="urlMapping"
  class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">       
 <property name="mappings">           
  <props>               
  <prop key="/upload.htm">uploadController</prop>           
  </props>       
 </property>   
 </bean>
     <bean id="uploadController" class="FileUploadController">
      <property name="commandClass"><value>FileUploadBean</value></property>
      <property name="uploadDir"><value>E:/</value></property>
      <property name="formView"><value>fail</value></property>
  <property name="successView"><value>confirmation</value></property>
</bean>  
3：定义控制类，commandClass及方法。控制类中最重要的方法是initBinder()它给spring注册了一个编辑器对
request中的multipart实体进行处理，如果没有这个方法，上传将不能进行。
<--------------------------控制类------------------->
public class FileUploadController extends SimpleFormController {
    private static Log log =
        LogFactory.getLog(FileUploadController.class);
    private String uploadDir;//上传文件路径

    protected ModelAndView onSubmit(HttpServletRequest request,
            HttpServletResponse response, Object cmd, BindException errors)
            throws Exception {

            FileUploadBean bean = (FileUploadBean) cmd;
            byte[] bytes = bean.getFile();
          
            //cast to multipart file so we can get additional information
            MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
            CommonsMultipartFile file = (CommonsMultipartFile) multipartRequest.getFile("file");

            String uploadDir = this.getUploadDir();

            File dirPath = new File(uploadDir);
            if (!dirPath.exists()) {
                dirPath.mkdirs();
            }
            String sep = System.getProperty("file.separator");
            if (log.isDebugEnabled()) {
                log.debug("uploading to: " + uploadDir + sep +
                file.getOriginalFilename());
                }
            File uploadedFile = new File(uploadDir + sep
                    + file.getOriginalFilename());
            FileCopyUtils.copy(bytes, uploadedFile);
            System.out.println("********************************");
            System.out.println(uploadedFile.getAbsolutePath());
            System.out.println(bytes.length);
            System.out.println("********************************");
           
     
        return new ModelAndView(getSuccessView() + ".jsp");
    }

    protected void initBinder(HttpServletRequest request,
            ServletRequestDataBinder binder) throws ServletException {
        binder.registerCustomEditor(byte[].class,
                new ByteArrayMultipartFileEditor());
    }
    public void setUploadDir(String uploadDir){
        this.uploadDir = uploadDir;
    }
    public String getUploadDir(){
        return this.uploadDir;
    }
}
<--------------------------控制类------------------------->
<---------------------定义commandClass-------------------->
public class FileUploadBean {

    private byte[] file;

    public void setFile(byte[] file) {
        this.file = file;
    }

    public byte[] getFile() {
        return file;
    }

}
<---------------------定义commandClass-------------------->
4：定义一个form表单index.jsp
<form method="post" action="upload.htm" enctype="multipart/form-data">
<input type="file" name="file"/>
<input type="submit"/>
5：定义confirmation.jsp及fail.jsp
confirmation.jsp如下：
<%@ page contentType="text/html; charset=GBK" %>
<html>
<head>
<title>
successView
</title>
</head>
<body bgcolor="#ffffff">
<h1>
Upload Successful
</h1>
</body>
</html>

fail.jsp如下：
<html>
<head>
<title>Upload a file please</title>
</head>
<body>
<h1>no file,Please upload a file</h1>
<form method="post" action="uploadfile.htm" enctype="multipart/form-data">
<input type="file" name="file"/>
<input type="submit"/>
</form>
</body>
</html>
6：运行tomcat。
预览 ie里面:http://localhost/springmvc/index.jsp
注：
a：文件目录为tomcat-HOME/webapps/springmvc/
.jsp文件都放在根目录下，.class文件放在/WEB-INF/classes/中

其他文件放在/WEB-INF/里面。
b：如果连上面的你都有疑问，那还是去看看spring的基础知识吧。

软件文档(document)也称文件，通常指的是一些记录的数据 和数据媒体，它具有固定不变的形式，可被人和计算机阅读。它和 计算机程序共同构成了能完成特定功能的计算机软件(有人把源 程序也当作文档的一部分)。我们知道，硬件产品和产品资料在整 个生产过程中都是有形可见的，软件生产则有很大不同，文档本 身就是软件产品。没有文档的软件，不成其为软件，更谈不到软件 产品。软件文档的编制(documentation)在软件开发工作中占有突 出的地位和相当的工作量。高效率、高质量地开发、分发、管理和维 护文档对于转让、变更、修正、扩充和使用文档，对于充分发挥软 件产品的效益有着重要意义。

    然而，在实际工作中，文档在编制和使用中存在着许多问 题，有待于解决。软件开发人员中较普遍地存在着对编制文档不感 兴趣的现象。从用户方面看，他们又常常抱怨：文档售价太高、文 档不够完整、文档编写得不好、文档已经陈旧或是文档太多，难于 使用等等。究竟应该怎样要求它，文档应该写哪些，说明什么问 题，起什么作用?这里将给出简要的介绍。

图9.2 文档桥梁作用

    文档在软件开发人员、软件管理人员、维护人员、用户以及计 算机之间的多种桥梁作用可从图9．2中看出。软件开发人员在各 个阶段中以文档作为前阶段工作成果的体现和后阶段工作的依 据，这个作用是显而易见的。软件开发过程中软件开发人员需制定 一些工作计划或工作报告，这些计划和报告都要提供给管理人员， 并得到必要的支持。管理人员则可通过这些文档了解软件开发项 目安排、进度、资源使用和成果等。软件开发人员需为用户了解软 件的使用、操作和维护提供详细的资料，我们称此为用户文档。以 上三种文档构成了软件文档的主要部分。我们把这三种文档所包 括的内容列在图6中。其中列举了十三个文档，这里对它们作 一些简要说明：

可行性研究报告：说明该软件开发项目的实现在技术上、经 济上和社会因素上的可行性，评述为了合理地达到开发目标可供 选择的各种可能实施的方案，说明并论证所选定实施方案的理 由。
 
项目开发计划：为软件项目实施方案制定出具体计划，应 该包括各部分工作的负责人员、开发的进度、开发经费的预算、所 需的硬件及软件资源等。项目开发计划应提供给管理部门，并作 为开发阶段评审的参考。

软件需求说明书：也称软件规格说明书，其中对所开发软 件的功能、性能、用户界面及运行环境等作出详细的说明。它是用 户与开发人员双方对软件需求取得共同理解基础上达成的协议， 也是实施开发工作的基础。

数据要求说明书：该说明书应给出数据逻辑描述和数据采 集的各项要求，为生成和维护 系统数据文卷作好准备。

概要设计说明书：该说 明书是概要设计阶段的工作 成果，它应说明功能分配、模 块划分、程序的总体结构、输 入输出以及接口设计、运行设 计、数据结构设计和出错处理 设计等，为详细设计奠定基 础。

 详细设计说明书：着重 描述每一模块是怎样实现的， 包括实现算法、逻辑流程等。

用户手册：本手册详细 描述软件的功能、性能和用户 界面，使用户了解如何使用该软件。

文档		用户文档		用户手册
				操作手册
				维护修改建议
				软件需求（规格）说明书
		开发文档		软件需求（规格）说明书
				数据要求说明书
				概要设计说明书
				详细设计说明书
				可行性研究报告
				项目开发计划
		管理文档		项目开发计划
				测试计划
				测试报告
				开发进度月报
				开发总结报告

图9.3 三种文档

操作手册：本手册为操作人员提供该软件各种运行情况的 有关知识，特别是操作方法的具体细节。

测试计划：为做好组装测试和确认测试，需为如何组织测试 制定实施计划。计划应包括测试的内容、进度、条件、人员、测试用 例的选取原则、测试结果允许的偏差范围等。

测试分析报告：测试工作完成以后，应提交测试计划执行 情况的说明。对测试结果加以分析，并提出测试的结论意见。

开发进度月报：该月报系软件人员按月向管理部门提交的 项目进展情况报告。报告应包括进度计划与实际执行情况的比较、 阶段成果、遇到的问题和解决的办法以及下个月的打算等。

项目开发总结报告：软件项目开发完成以后，应与项目实 施计划对照，总结实际执行的情况，如进度、成果、资源利用、成本 和投入的人力。此外还需对开发工作作出评价，总结出经验和教 训。

维护修改建议，软件产品投入运行以后，发现了需对其进 行修正、更改等问题，应将存在的问题、修改的考虑以及修改的影 响估计作详细的描述，写成维护修改建议，提交审批。 以上这些文档是在软件生存期中，随着各阶段工作的开展适 时编制。其中有的仅反映一个阶段的工作，有的则需跨越多个阶 段。表5给出了各个文档应在软件生存期中哪个阶段编写。这 些文档最终要向软件管理部门，或是向用户回答以下的问题：
表9.2 软件生存期各阶段编制的文档

阶段 文档	可行性药酒与计划	需求分析	设计	代码编写	测试	运行与维护
可行性研究报告
项目开发计划
软件需求说明
数据要求说明
概要设计说明
星系设计说明
测试计划
用户手册
操作手册
测试分析报告
开发进度月报
项目开发总结
维护修改建议

哪些需求要被满足，即回答“做什么?”

所开发的软件在什么环境中实现以及所需信息从哪里来， 即回答“从何处?”

某些开发工作的时间如何安排，即回答“何时干?”

某些开发(或维护)工作打算由“谁来干?”

某些需求是怎么实现的?

为什么要进行那些软件开发或维护修改工作?

    上述十三个文档都在一定程度上回答了这六个方面的问题。这可从表中看到。

表9.3 文档所回答的问题

    至此，我们对文档的作用有了进一步的理解。每一个文档的任 务也是明确的，任何一个文档都此是多余的。