1. 创建POJO Node.java
    最基本也是最重要的工作首先是建立这个菜单的POJO，源文件在这里下载吧，偶8多说了。

2. 使用AppGen生成代码
    这一步偶也8想多说了，只要使用过AppFuse的都应该知道啦，8知道的看偶前面的文章。

3. 单元测试
    接下来当然就是要修改生成的代码了，首先是单元测试类NodeDAOTest.java。我们要给它加几个测试方法
    - testChildren：测试添加和删除子节点
    - testParent：测试两级的父子关系
    - testDeleteMiddleNode：测试中间节点的删除
    具体怎么做的看这里吧，但是要注意最好不要直接下载替换原文件，如果AppFuse的版本不一样，测试方法也是不一样滴，最好把这几个方法单独copy过来。

4. Form Bean
    AppGen生产的NodeForm不能满足我们的要求了，所以把这个文件xdoclet-NodeForm.java放到metadata\web下。

5. Action
    Action是这里最重要的类了，它修改的地方也很多，所以就直接下载吧。不过偶有一点不太明白的是作者为虾米要把populate()方法的第二个参数设为long而不是Long，他传入的可是Long啊，自己手动改改吧。

6. JSP
    接下来是JSP，自动生成的代码基本没用了。这里nodeList.jsp可以删除，nodeForm.jsp被重新写过了。如果你的AppFuse版本比较新，是1.8版以上的，这个JSP下载下来后还需要改一下。搜索property="method"，这个是button里的属性，根据button的功能把他们分别修改成property="method.save"、property="method.delete"、property="method.add"等，否则按下按钮可是要报错的.
    修改了JSP也别忘了它的资源文件。把这个文件里关于nodeForm部分的内容copy到你自己的ApplicationResources下吧，当然可以汉化一下。
    接下来修改menuExpandable.css和menuExpandable.js，直接替换原文件就可以了。
    现在可能还是不能正常使用，因为我们的AppFuse下已经有一个菜单了，新的菜单会和原来的菜单起冲突，导致我们的新菜单打不开。到web\decorators下打开default.jsp文件，把含有<c:import url="/WEB-INF/pages/menu.jsp"/>的这一段代码挪到<div id="content"></div>代码段的下面，这样就可以正常使用了。

7. 问题
    在使用中我还发现一个问题，就是这个菜单的target有点问题，只有末节点的target有效，其它节点的target设了也灭有效果，8知道哪位大虾有好的解决办法，偶8胜感激。

用AppFuse有一段时间了，也发现了它的一些问题，或者说不适合我们开发的地方。

1. build.xml中的setup：setup是安装数据库、tomcat、生成源代码并部署的target，在初次使用时很方便。但以后使用就有点问题了，因为每次执行这个命令就要把数据库删除重新安装一遍，尤其是在多人同时开发的时候，每个人都setup一次实在有点麻烦。因此我在使用过一次setup后，就将命令depends="setup-db,setup-tomcat,deploy"修改为depends="package-dao,setup-tomcat,deploy"，以后再使用这个命令就不会再去动数据库了。如果有需要修改数据库的地方，单独运行ant setup-db。
2. ApplicationResources_zh_CN.properties & ApplicationResources_zh.properties：这个前面提到过，这两个中文资源文件中存在乱码，需要把乱码的地方修改过来。
3. AppGen：使用AppGen生成文件的时候常常会在sample-data处报错。原因我没仔细研究，但自我认为sample-data.xml在这里没有生成的必要，所以在extras\appgen\build.xml中搜索sample-data.xdt，将该处的template标签注释掉了。
4. struts_form.xdt：\metadata\templates下的struts_form.xdt是用来根据POJO生成FormBean的xdoclet文件。当POJO中含有同样是POJO类型的属性时（通常是表中的父表关系），FormBean倒不会有问题，可validation.xml会自动将这个父亲中的所有属性也纳入当前FormBean里进行验证。这意味着我们在做子表单时必须包含父表单中的所有属性，麻烦！validation.xml是根据FormBean生成的，所以到struts_form.xdt下查找struts.validator，其中有一行：@struts.validator，仔细读代码就知道了这里是判断如果是org.appfuse.model.BaseObject类型的属性，就在该属性前加@struts.validator注释，所以把这一行去掉。如果需要验证，手动在POJO的get方法前加一行@struts.validator就可以了。不过不知道如果想要单独对父亲属性中的某个属性进行验证该怎么做？
5. DAO单元测试：AppGen生成的DAO单元测试类不能通过测试。原来在DAO的测试类中，测试了DAO的CRUD方法。在testAdd方法中，会添加一条主键值为1的记录，可是在testRemove的测试中，删除的主键值却成了3，系统找不到这条记录，当然会报错了。在extras\appgen\src\detailed下有生成DAOTest类的模版DAOTest.xdt，找到testRemove方法，把第一句修改为<XDtMethodEx:idField getType="propertyType"/> removeId = <XDtForm:classNameLower/>Id; 这样，删除的记录主键值就与添加的主键值就一致了。不过如果主键是随机生成的，这个办法就不行了，那么自己修改测试类吧。
6. 密码加密：AppFuse默认是给用户密码加密的，如果不想加密，需要在properties.xml中设置属性encrypt.password为false，这样用户登录时系统就不会对密码加密了。但是用户注册和编辑信息时程序却没有进行判断，直接对密码加密。这里需要修改的地方有两个：SignupAction和UserAction，分别对加密的地方做一个判断。Boolean encrypt = (Boolean) getConfiguration().get(Constants.ENCRYPT_PASSWORD);一句可以拿到配置文件中的值。

2. Manager测试
    接下来继续看测试UserManager的类UserManagerTest。它在test/service/**/service/中，继承自BaseManagerTestCase，这个父类起着与BaseDAOTestCase类似的作用。
    与UserDAOTest不同的是UserManagerTest使用了jMock帮助其测试。jMock用于解决UserManager的依赖，因为UserManager中需要调用UserDAO的方法，而单元测试的基本规则是一次只测试一个对象，jMock帮助你把UserManager孤立起来，使它不会受到UserDAO的影响，我们来看它到底怎么做。
    在setUp()里，我们把UserDAO和RoleDAO放到Mock中，让Mock来做UserDAO和RoleDAO的代理，并将这两个“假冒的”DAO注入到UserManager中。
    还是以testSaveUser()为例来看这个test类怎么工作。首先创建User对象，设置用户名为“tomcat”，权限为“user”。然后我们告诉Mock当UserManager调用UserDAO的getUser()方法并参数是“tomcat”时，我们期待UserDAO返回我们刚刚创建的那个对象。接下来调用UserManager的getUser()方法以获得“tomcat”的信息。修改电话号码的内容。然后重置我们对Mock的要求。这次我们要求当UserManager调用UserDAO的saveUser方法时，不返回任何值。然后调用UserManager的saveUser()方法，校验user是否为新的电话号码和权限是否还是一个，若是，测试成功。verify()用于检查所有应该调用的方法是否都被调用了。通常来说，每对Mock对象调用了一次expects()，使用完后都要执行一次verify()。
    在控制台执行ant test-service -Dtestcase=UserManager，看看结果。

3. Action测试
    我们继续看test/web/**/action下的UserActionTest。它继承自BaseStrutsTestCase，BaseStrutsTestCase继承MockStrutsTestCase，这个父类也做了类似BaseManagerTestCase的工作。
    Action是一个控制器，主要用于接收视图层的请求，调用模型层的方法，然后返回视图层。在这里我们不关心模型层或视图层，我们只要关心Action是否能够正确的得到请求和响应请求，以及能够正确的根据请求转向。MockStrutsTestCase给了我们测试这方面很好的支持。
    以testSave()为例，首先创建一个UserForm，在里面放入部分数据，将UserForm放入该Action所对应的范围内。使用setRequestPathInfo()设置请求路径为“/saveUser”，使用addRequestParameter()添加好请求参数，actionPerform()方法将模拟请求的全过程。然后使用verifyForward()方法验证请求转发路径是否正确。并验证能不能在Action范围内得到UserForm。
    运行ant test-web -Dtestcase=UserAction，OK。
    要注意一点，这里的单元测试虽然继承自MockStrutsTestCase，但没有使用Mock，也就是说，它会真正执行到所有相关的方法，包括修改数据库。

4. JSP测试
    我们同样可以对JSP进行测试。这里有一个工具叫做Canoo WebTest，它使用xml配置的方式来测试JSP。
    进入test/web/，有一个web-tests.xml文件，里面有所有struts-config.xml中存在的path的测试。
    以SaveUser这个target为例，我们做一个简单的说明。测试步骤包含在steps中，invoke中给这个step定一个ID号，设置请求的url：editProfile.html。接下来验证JSP页面的title是否与预期的一致。其中{webapp.prefix}和{userProfile.title}的内容在WEB-INF\classes中的ApplicationResources中定义。接下来给表单中的文本域填写内容，使用clickbutton点击保存按钮，验证保存后的页面标题是否为预期的标题。
    这一测试需要运行容器，因此首先运行Tomcat，再在控制台键入ant test-canoo -Dtestcase=UserTests或ant test-jsp -Dtestcase=PersonTests。使用ant run-all-tests无需运行Tomcat，Ant为你做这件事。

1. 程序描述
    视图层主要由JSP网页构成，此外还包括Resource Bundle资源文件及ActionForm Bean、Validation等，这些组件提供对国际化、接收用户输入的表单数据、表单验证和错误处理等的支持。
    与User的视图层有关的文件有：
    userList.jsp：用户列表页面，用于具有管理权限的用户对其他用户的管理。
    userForm.jsp：用户信息页面，用于对用户信息的增、删、改
    UserForm.java：与用户信息表单对应的ActionForm Bean
    validation.xml：对用户信息表单进行验证的配置文件
    Resource Bundle资源文件，中文的就是ApplicationResource_Zh_cn.properties
    default.jsp：用于复合网页的sitemesh文件
    JavaScript、CSS文件

2. JSP页面
    与用户相关的JSP页面包括用户列表和用户信息。head及foot等通用信息放置在head.jsp、foot.jsp中，因此userList.jsp及userForm.jsp只包含与业务相关的标签。下面介绍主要的标签功能：
    <logic:messagesPresent>：判断指定的消息是否存在。若指定message属性为true，则从request范围内检索属性key为Globals.MESSAGE_KEY的ActionMessages对象。若不指定属性，则默认检索属性key为Globals.ERROR_KEY的ActionMessages对象。在本系统中一个检索Success消息，一个检索Error消息。
    <fmt:message>：JSTL标签。用于输出Resource Bundle中的一条消息。
    <bean:struts>：用于检索Struts框架内在的对象，如ActionFormBean、ActionForward、ActionMapping。在这里用于在JSP页面上定义一个ActionForward 变量以方便其它地方的引用。forward为struts-config.xml中定义的global-forward。
    <c:set>：JSTL标签。用于定义一个变量，以方便其它地方的引用。
    <c:out>：JSTL标签。用于在页面上显示一个EL表达式的值，如显示<c:set>定义的变量。EL是JSTL采用的简单的表达式语言，该语言提供一个访问和操作应用程序数据的简单方式。
    <c:if><c:when><c:forEach><c:choose>：JSTL标签。用于处理条件的标记，根据特定的逻辑条件来控制输出网页内容，或者循环遍历集合中的所有元素。
    <display>：Display Tag的标签，用于显示控制层返回的List。可以方便的定制表格是否分页、对列排序、导出数据等。
    <html:form>：用来定义HTML表单。Struts的HTML标签可以和标准的HTML元素完成相同的功能，Struts框架能够把表单中的数据自动映射到相应的ActionForm Bean中。
    <html:text><html:password><html:hidden>：在表单上生成相应的HTML元素。
    <html:submit><html:cancel>：在表单上生成提交按钮和取消按钮。当用户按下按钮时，将产生一个提交事件或取消事件，由Action类捕获。本系统中<html:submit><html:cancel>的属性相同（均为method），用户按下提交按钮或取消按钮后执行哪个方法由lookupMethods.properties决定。
    <html-el:multibox>：在表单上生成HTML的CheckBox标签。html-el使用了JSTL扩展，可以使用EL表达式。
    <html:messages><html:errors>：用于在网页中输出消息。<html:errors>用于输出错误消息，本系统中用于显示表单中字段级的错误信息，<html:messages>显示全局的消息。
    自定义标签：
    在你最初运行ant new时，AppFuse就会根据你键入的项目名自动生成一个标签文件，在userForm.jsp中你会看到这个标签。
    <YOURAPPNAME:label>：它用于显示表单输入域前的提示文本，对文本添加了一些特别的样式，如在必填项前自动加"*"号等。
    <YOURAPPNAME:country>：userForm中有设置国家一项，该标签用于显示国家的下拉列表。
    <YOURAPPNAME:constants>：用于在页面上显示常量类org.appfuse.Constants中的常量的值。

3. ActionForm Bean
    ActionForm Bean是Struts提供的表单数据传输对象，用于在视图层和控制层之间传递HTML表单数据。控制层可以从ActionForm Bean中读取用户输入的表单数据，也可以把来自模型层的数据存放到ActionForm Bean中，然后把它返回给视图。
    User表单的ActionForm Bean为UserForm。UserForm继承BaseForm。BaseForm是ActionForm的子类对象，扩展了三个通用方法：toString()、equals(Object o) 和hashCode()。并定义了一个验证，用于允许用户在点击"删除"或"取消"按钮时表单无须验证。
    UserForm中定义了与用户信息表单中的字段对应的属性。

4. Validator验证框架
    Validator验证框架负责数据验证，采用基于XML的配置文件来配置验证规则。其相关的文件有：
    validation.xml：针对具体的Struts表单，为ActionForm配置所需的验证规则。
    validator-rules.xml：框架自带文件，包含了一组通用的验证规则。
    validator-rules-custom.xml：自定义验证规则。本系统中定义了验证两个指定的输入域值是否相等的规则。用于验证密码和确认密码是否相等。其实将这个方法稍微修改一下，把“=”变为“<、>”就可以验证一个域不能大于/小于另外一个域，非常的实用。
    Resource Bundle：定义验证失败时显示的提示文本。Resource Bundle 中以errors为前缀的Key绝大部分用于Validator的错误提示。
    下面是在validation.xml 中配置的userForm验证规则
      <form name="userForm">
              <field property="username"
                     depends="required">

                  <arg0 key="userForm.username"/>
              </field>
    ……………………………
    </form>
    该配置通过depends="required"定义了userForm的username字段即用户名是必填项。
    <arg0 key="userForm.username"/>声明了该字段所对应的文本在Resource Bundle中的Key。Validator会在Resource Bundle中寻找errors.required对应的文本：'{0}' 为必填项，将userForm.username对应的文本带入{0}。如用户没有填写该项，Validator会提示“'用户名' 为必填项”的消息。
    validation.xml中使用正则表达式定义了一些简单的全局的规则，如电话号码的格式等。
    默认情况下，Validator框架在Web服务器端执行表单验证。validator-rules.xml里已经定义了客户端JavaScript的生成规则，可以在JSP网页中生成JavaScript脚本。需要进行客户端验证时，在JSP中包含：
    <html:javascript formName="userForm" cdata="false"
      dynamicJavascript="true" staticJavascript="false"/>
    <script type="text/javascript"
      src="<c:url value="/scripts/validator.jsp"/>"></script>
    并在<html:form>中定义onsubmit事件：
    onsubmit="return validateUserForm(this)"
    在userForm表单的提交和取消按钮中包含了onclick="bCancel=false"事件。bCancel是Validator定义的是否进行验证的变量。当用户点击删除或取消按钮时，表单无须验证，此时bCancel= true

3.3 模型层结构
    Model层为整个系统的核心部分，完成应用的业务逻辑及与数据库的通信。AppFuse中将Model分为两层：持久层和业务层。采用Spring＋Hibernate框架实现，这里以对用户User数据的操作为例详细阐述其实现方式。

    对持久化数据的访问基于DAO（Data Access Object）模式实现。DAO模式提供了访问关系型数据库系统所需的所有接口操作的接口。DAO模式将底层数据访问操作与高层业务逻辑分离开，对上层提供面向对象的数据访问接口。

    Model层与User相关的类有：
    POJO：
    User：管理员表的业务对象。
    业务层：
    UserManager：业务层接口，为控制层所调用。
    UserManagerImpl：业务层接口的实现，调用持久层接口。
    持久层：
    UserDAO：持久层接口，为业务层实现所调用。
    UserDAOHibernate：持久层接口的实现。
    XML配置文件：
    applicationContext-service.xml：业务层接口的配置文件。
    applicationContext-hibernate.xml：持久层接口的配置文件。

3.3.2 Spring的IoC
    Ioc（Inversion of Control）即反转控制。Ioc模式即Dependency Injection模式是依赖注射的意思，也就是将依赖先剥离，然后在适当时候再注射进入。
    Spring的轻量级的bean容器为业务对象（business objects）、DAO对象和资源（如：JDBC数据源或者Hibernate SessionFactorie等）对象提供了IoC类型的装配能力。Spring使用一个xml格式的应用配置文件为开发者提供了一种通过解析定制的属性文件来手动管理单实例对象或者工厂对象的选择性。由于Spring将非入侵性做为一个重要的目标，因此可以由Spring配置管理的bean对象均不需要依赖Spring自有的接口和类就可以通过它们的bean属性完成配置。
    就实现上来讲Spring采取了配置文件的形式来实现依赖的注射，并且支持Type2 IOC（Setter Injection）以及Type3 IOC（Constructor Injection）。
    在Model层，使用Spring提供的Setter Injection(type2)注入方式。以User为例，下面是其用法。
    在applicationContext- hibernate.xml中定义
   

1<bean id="userDAO" class="org.appfuse.dao.hibernate.UserDAOHibernate">
2        <property name="sessionFactory"><ref local="sessionFactory"/></property>
3    </bean>
4

    在UserManager类中有一句：
    public void setUserDAO(UserDAO dao);
    这就是一个DAO Object设置方法（注射器）。UserDAO将被调用，和持久层通信。以这种方式创建UserDAO的实例，同样达到了由UserManager创建UserDao的目的。避免了直接实例化UserDAO的实现而使业务层和持久层紧密耦合。
 

    在控制层调用业务层方法时，使用服务定位器返回给Spring context，Spring的BeanFactory提供了getBean方法。BeanFactory是一个通用的Factory，它使对象能够按名称获取，并且能管理对象之间的关系。
    在applicationContext-service.xml中配置
   

1<bean id="userManager" parent="txProxyTemplate">
2        <property name="target">
3            <bean class="org.appfuse.service.impl.UserManagerImpl">
4                <property name="userDAO"><ref bean="userDAO"/></property>
5            </bean>
6        </property>
7    </bean>
8

    在控制层BaseAction定义通用方法： 
   

1 private static ApplicationContext ctx = null;
2    public Object getBean(String name) {
3        if (ctx == null) {
4            ctx = WebApplicationContextUtils
5                    .getRequiredWebApplicationContext(servlet.getServletContext());
6        }
7        return ctx.getBean(name);
8    }
9

    在UserAction中创建UserManager的实例：
        UserManager mgr = (UserManager) getBean("userManager");
    这样，通过BeanFactory的getBean方法，以及xml配置文件，避免了在UserAction类中直接实例化UserManager，消除了控制层与业务层及业务层与持久层之间的耦合，实现了依赖的注射。
    ApplicationContext 是BeanFactory的子接口，为下列东西提供支持：
        信息查找，支持着国际化
        事件机制，允许发布应用对象以及可选的注册以接收到事件
        可移植的文件和资源访问

3.3.3 Spring的事务管理
    在数据持久层的杰出贡献，可能是Spring最为闪亮的优点。
    Spring提供了通过容器的集约式参数化事务机制，实现事务的外部管理。容器管理的参数化事务为程序开发提供了相当的灵活性，同时因为将事务委托给容器进行管理，应用逻辑中无需再编写事务代码，大大节省了代码量（特别是针对需要同时操作多个事务资源的应用），从而提高了生产率。
    AppFuse在applicationContext-service.xml文件中进行了对事务的配置
   

 1<bean id="txProxyTemplate" abstract="true"
 2        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
 3        <property name="transactionManager"><ref bean="transactionManager"/></property>
 4        <property name="transactionAttributes">
 5            <props>
 6                <prop key="save*">PROPAGATION_REQUIRED</prop>
 7                <prop key="remove*">PROPAGATION_REQUIRED</prop>
 8                <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
 9            </props>
10        </property>
11    </bean>
12

    这里定义了一个名为txProxyTemplate的TransactionProxyFactoryBean服务。它对包含实际数据逻辑的持久层对象进行了事务的封装。在这里，通过transactionAttributes属性，我们指定了事务的管理策略，即将所有的名称以save和remove开头的方法纳入事务管理范围。如果此方法中抛出异常，则Spring将当前事务回滚，如果方法正常结束，则提交事务。
    而对所有其它方法则以只读的事务处理机制进行处理。设为只读型事务，可以使持久层尝试对数据操作进行优化，如对于只读事务Hibernate将不执行flush操作，而某些数据库连接池和JDBC 驱动也对只读型操作进行了特别优化。
    如果有其他的方法需要进行写数据库操作，可以在相应的Manager配置中声明。如在UserManager中，就添加了属性
       

1<property name="transactionAttributes">
2            <props>
3                <prop key="save*">PROPAGATION_REQUIRED</prop>
4                <prop key="remove*">PROPAGATION_REQUIRED</prop>
5                <prop key="*LoginCookie">PROPAGATION_REQUIRED</prop>
6                <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
7            </props>
8        </property>
9

    这样，以LoginCookie结尾的方法也可以写数据库了。
    Spring可以将任意Java Class 纳入事务管理，而无需对其进行任何修改，因此我们的类可能完全不知道它正在被进行事务管理。

3.3.3 Spring＋Hibernate操作持久层
    Spring对Hibernate有很好的支持。
    Hibernate中通过SessionFactory创建和维护Session。Spring对SessionFactory的配置进行了整合，无需再通过Hibernate.cfg.xml对SessionFactory进行设定。SessionFactory节点的mappingResources属性包含了映射文件的路径，list节点下可配置多个映射文件。hibernateProperties节点则容纳了所有的属性配置。可以对应传统的Hibernate.cfg.xml文件结构对这里的SessionFactory配置进行解读。
    下面是HibernateSessionFactory 和 HibernateTransactionManager的配置：
    在applicationContext-hibernate.xml中：
   

<bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
        <property name="dataSource"><ref bean="dataSource"/></property>
        <property name="mappingResources">
            <list>
                <value>com/mycompany/model/User.hbm.xml</value>
                ……………………………
            </list>
        </property> 

        <property name="hibernateProperties">
        <props>
            <prop key="hibernate.dialect">@HIBERNATE-DIALECT@</prop>
            <!--prop key="hibernate.show_sql">true</prop-->
            <!--prop key="hibernate.hbm2ddl.auto">update</prop-->
        </props>
        </property>
    </bean> 

    Spring 提供了一个 HibernateTransactionManager，采用面向Hibernate的TransactionManager实现：org.springframework.orm.hibernate.HibernateTransactionManager。他用线程捆绑了一个Hibernate Session，用它来支持transactions。
   

<bean id="transactionManager" class="org.springframework.orm.hibernate.HibernateTransactionManager">
        <property name="sessionFactory"><ref local="sessionFactory"/></property>
    </bean> 

    sessionFactory Bean引用了HibernateSessionFactory，而transactionManager Bean引用了HibernateTransactionManage。 transactionManager Bean中有个sessionFactory属性。 HibernateTransactionManager有个sessionFactory setter 和 getter方法，用来在Spring启动的时候实现“依赖注入” （dependency injection）的。 在sessionFactory 属性里引用sessionFactory Bean。这两个对象在Spring容器初始化后就被组装了起来了。
 
    User使用一个TransactionProxyFactoryBean，它定义了一个setTransactionManager()。能很方便的处理申明的事物还有Service Object。TransactionProxyFactoryBean 还有个setter. 这会被Business service object（UserManager）引用， UserManager定义了业务层，并且它还有个属性，由setUserDAO()引用。

    系统持久层中所有的类都继承自Spring提供的HibernateDaoSupport类，HibernateSupport实现了HibernateTemplate和SessionFactory实例的关联。HibernateTemplate对Hibernate Session操作进行了封装，提供了一个简单的方式实现了Hibernate-based DAO对象。借助HibernateTemplate我们可以脱离每次数据操作必须首先获得Session实例、启动事务、提交/回滚事务以及烦杂的try/catch/finally的繁琐操作。一个简单的Hibernate访问方法就完全解决了些麻烦! 无论是在多个DAO接口还是在多方事务的情况下，Spring使得多种DAO对象无缝地协同工作。
    对于简单的单步的动作，象find, load, saveOrUpdate或者delete的调用，HibernateTemplate提供更为便利的选择以代替象一行的回调的执行。此外HibernateDaoSupport类提供了setSessionFactory方法来接受一个SessionFactory，同时提供了getSessionFactory和getHibernateTemplate方法供其继承类使用。将这些结合起来，允许对于典型的需求给出了非常简单的DAO实现，如获得所有用户的方法：
   

 public List getUsers(User user) {
        return getHibernateTemplate().find("from User u order by upper(u.username)");
    }

    AppFuse实现的最主要的功能是对用户的管理。下面就以对用户的管理来说明一下AppFuse控制器的实现。

    与用户信息表单数据相关的FormBean是UserForm。UserForm用来存放用户的基本信息。
    UserForm的控制器是org.appfuse.webapp.action.UserAction。UserAction继承了BaseAction。BaseAction也是系统中几乎所有Action类的父类，它继承自Struts提供的DispatchAction，并提供了控制层通用的方法。

2. Action
Action是用户请求和业务逻辑之间的桥梁，每个Action充当客户的一项业务代理。主要完成以下任务：
    1. 接收用户请求。
    2. 根据用户请求，调用合适的模型组件来执行相应的业务逻辑。
    3. 获取业务逻辑执行结果
    4. 根据当前状态以及业务逻辑执行结果，选择合适的视图组件返回给用户。

3. DispatchAction
    org.apache.struts.actions.DispatchAction是org.apache.struts.action.Action的子类。
    Action的execute()方法是调用模型的业务方法，完成用户请求的业务逻辑，然后根据执行结果把请求转发给其它合适的Web组件。通常，在一个Action类中只能完成一种业务操作（通过execute()方法）。
    DispatchAction允许用户将完成一个业务逻辑所需要的连续动作和相关动作集中于一个Action类中。无须覆盖execute()方法，而是可以创建一些实现实际业务操作的方法，用户通过method请求参数指定所需要使用的方法。

4. BaseAction
    BaseAction中实现了系统中Action子类需要用到的通用方法，主要有：
    1. public Object getBean(String name):通过读取Spring的applicationContext-service.xml配置文件来创建实例从而实现“依赖注入”的方法。
    2. public ActionMessages getMessages(HttpServletRequest request)：初始化Struts的ActionMessages，并返回。
    3. protected Object convert(Object o) ：POJO与FormBean之间的转换方法。
    4. execute()：置换了原始的execute()方法。作用是根据请求的url寻找相关的业务方法（没有method请求参数时）。例如请求的页面是editUser.html,则执行edit()方法。
    5. protected ActionForm getActionForm(ActionMapping mapping, HttpServletRequest request)：在mapping范围内得到一个Action FormBean。
    6. protected User getUser(HttpSession session) ：从Session中拿到当前登录用户信息。
    7. protected void updateFormBean(ActionMapping mapping, HttpServletRequest request, ActionForm form)：在指定的范围内更新当前Action 所对应的Form Bean对象。
    8. protected void removeFormBean(ActionMapping mapping, HttpServletRequest request)：去除无用的Form Bean。 

5. UserAction
    UserAction是用户数据管理的控制器，提供了对用户数据的添加、修改、删除、查询等操作的控制，其包含的业务方法有：
    1. add()：进入添加用户页面。
    2. cancel()：当用户在表单中点击“取消”按钮时，执行该方法。如果用户是通过用户列表进入该表单，即当前用于拥有管理其它用户的权限，返回到用户列表，否则返回到主页面。
    3. delete()：根据请求的用户ID调用业务层的removeUser ()方法删除相应的记录，返回到用户列表。
    4. edit()：首先校验用户请求的URL是否为editProfile.html，若是，表示当前登录用户要查看自己的信息，此时请求路径中不应该含有用户ID（用户ID从Session中取得）或用于标识请求是通过用户列表的from参数，如果含有这两个参数，发出“无权限”的错误信息。若不是，表示当前用户是通过用户列表进行请求。根据请求的用户ID调用业务层的getUser ()方法取得相应的记录。更新相应的FormBean。
    5. save()：当需要要添加或修改用户信息时，执行该方法。首先校验请求参数中是否有“encryptPass”并值为“true”，若是，表示密码需要加密，随即将密码加密。然后调用业务层的getRole ()方法将提交的用户权限持久化。调用业务层的saveUser ()方法，保存用户信息。如果用户编辑的是自己的信息，更新Session中的当前登录用户信息。如果用户在登录时选择了“记住我”，更新保存的Cookie。如果用户编辑的是其它用户的信息，根据version判断是新添数据还是修改数据，在ActionMessages中存储不同的消息，返回到添加/修改用户信息页面。若是新添数据，调用sendNewUserEmail()给新用户发送一封Email。
    6. search()：具有管理权限的用户进入用户列表时执行该方法。调用业务层的getUsers ()方法，取得包含所有用户信息的List。返回到用户列表页面。
    7. unspecified()：如果请求的url没有包含method参数，通过BaseAction的execute()方法也找不到指定的方法时，执行该方法。在该方法中转到search()方法。
    以上是很多Action需要用到的基本的方法。
    8. sendNewUserEmail()：根据FormBean中的内容给用户发送一封Email。
    9. checkForCookieLogin()：如果用户是通过Cookie登录（用户在登录时选择了“记住我”），发出一个消息警告用户不能修改密码。

    AppFuse还给我们提供或介绍了很多好用的工具，能大大加快我们的开发速度。如果能够很好的使用这些工具，我们可以只给出一个表的POJO，它们就能够自动生成所有的操作该POJO对应的数据表通常需要的增、删、改、查功能的模型层、控制层、视图层文件，几乎不用再修改就可以完成对这张表的所有基本操作。
1. AppGen
    AppFuse给我们提供了一个通过xdoclet生成代码的工具——AppGen，我们来看看它怎么用。
    POJO（Plain Old Java Object）代表一个存储在持久性存储器（如数据库）中的实体的对象视图。它通过hbm.xml配置文件与存储器中的数据相映射。
    首先，你需要有这个表的POJO，放在src\dao\org\appfuse\model中。
    在控制台中进入项目下的extras\appgen路径，键入ant -Dmodel.name=XXX -Dmodel.name.lowercase=xxx，第一个XXX处写你的POJO类名，第二个xxx处写这个对象在小写时的名字。当控制台出现BUILD SUCCESSFUL时，代码就生成了。代码在extras\appgen\build\gen文件夹下，包括java源代码（DAO、Service、Action）、单元测试、JSP、资源文件、xml配置文件、源数据等，目录结构与原项目一致，你只要把需要的目录拖到相应的项目根目录下就可以了，当然了，有的代码是需要在已有的文件上进行修改的，主要是属性文件和xml文件，这时需要你把新的代码手动转移到原来的文件中。
    AppGen也可以为你省去这个麻烦，只要在前面的那段命令中加一个install，即ant install -Dmodel.name=XXX -Dmodel.name.lowercase=xxx，AppGen会直接把代码生成到你的项目中去，包括修改已存在的文件。这时为了保险起见，最好先备份一下代码。

2. xdoclet注释
    AppGen生成的文件缺少了hbm.xml和Action Form Bean，难道我们要自己写吗？不是的。仔细察看build.xml文件就会发现实际上我们下载的AppFuse最初的源代码中并没有hbm.xml、FormBean，甚至连web.xml、struts-config.xml、validation.xml都没有，这些文件都是在我们执行ant setup时build.xml使用xdoclet自动生成的。 甚至连数据库和表、表里的数据也可以自动生成。奥秘都在POJO中。
    查看User.java这个POJO你会发现里面除了java代码，还有很多注释，有@hibernate开头的，@struts开头的，这些都是xdoctlet的标签。我们大致讲解一下：
    @struts.form：用来生成Form Bean，如User.java中写了@struts.form include-all="true" extends="BaseForm"，意思是该POJO中每一个属性在Form Bean中都要有，并且生成的Form Bean文件要继承BaseForm。如果不希望生成的FormBean包含POJO的所有属性，可以在相关的属性get方法前填写注释@struts.form-field，意思是该属性要在FormBean中生成。那么如果我们要在FormBean中添加一些POJO没有的属性或方法怎么做呢？打开metadata\web文件夹，可以看到有一个xdoclet-UserForm.java文件，里面是User.java在生成Form Bean时新加入的代码，我们同样可以把我们自己在FormBean中增加的代码新建到一个xdoclet-POJOFrom.java文件中就好了。
    @struts.validator：用来生成validation.xml文件。最常用的如@struts.validator type="required"，意为该属性在表单中需要有必填的验证。当然前提是这个属性也在FormBean中。validation还有一项配置是自定义的校验规则，使用正则表达式表示。metadata\web中有一个文件validation-global.xml，里面就有邮编等规则的配置。
    @hibernate：这个是比较复杂的，用来生成hbm.xml文件。其实内容与hbm.xml基本一致，所以如果会写hbm.xml，这个也就会写了。初学者可以先建表，使用工具生成hbm.xml，再仿照生成的hbm.xml内容写这个标签。一旦标签写好了，不光可以生成hbm.xml，build.xml还可以自动在数据库中建表。
    @struts.action/@struts.action-forward：POJO不能生成struts-config.xml，这个标签是要写到Action中的。如果使用AppGen生成Action，你会看到@struts.action已经写好了，这个标签的作用就是生成当前Action在struts-config.xml中的映射代码，写法与struts-config.xml中一致，其实就是把xml中的配置移植到Action中。还有一个问题，如果我们要在struts-config.xml中进行与Action无关的全局的配置，如global-forwards呢？浏览metadata\web文件夹你会发现里面有多个xml文件，其中以global和struts开头的文件就是写这些配置的。build.xml在setup时会自动将这些文件联合Action中的注释生成一个完整的struts-config.xml文件。
    接下来还有web.xml文件，你一定猜到了同样需要在metadata\web中配置。除了刚才提到的那些xml文件，剩下的基本都是用于配置web.xml的了。我们自定义的filter和listener是有具体类的，所以我们同样可以在这些filter和listener类中添加注释，具体例子参考AppFuse中的filter吧，很简单的。
    进行了所有配置后，运行ant setup，build.xml会根据POJO、Action等自动生成FormBean、hbm.xml、struts-config.xml、validation.xml、web.xml，并在数据库中创建相应的表。看起来可能有点复杂，但如无特殊要求，对数据表的增、删、改、查，只需要写好POJO，一切都可以搞定。

3. Commonclipse
    org.appfuse.model中有一个抽象类BaseObject，定义了三个抽象方法：hashCode()、equals()和toString()，其中前两个是Hibernate要求POJO必须实现的方法。所有的POJO都继承自这个类，当然也要实现这三个方法，这个工具可以帮助你实现这三个方法。
    我们可以使用Eclipse在线获得这个工具。步骤：依次点击"Help" -> "Software updates" -> "Find and Install" -> "Search for new features to install"，点击"add update site"，输入http://commonclipse.sourceforge.net，OK。
    接下来需要对Commonclipse进行一些配置。点击"Window"->"Preferences"，选择"Java"，你会在菜单中看到Commonclipse。点击General标签，将复选框全部钩掉（全不选）。点击"OK"。
    选中一个类，右击，你会在菜单中看到Commonclipse。选择要生成的方法，就这么简单。

下面分别介绍各层的功能：
    1. Controller：控制器的作用是从客户端接受请求，并且选择执行相应的业务逻辑，然后把响应结果送回到客户端。Controller功能核心是一个Servlet类型的对象ActionServlet，它用来接受客户端的请求。ActionServlet包括一组基于配置的ActionMapping对象，每个ActionMapping对象实现了一个请求到一个具体的Action控制器对象之间的映射。所有的Action对象都是从Struts的Action类派生的子类。Action对象封装了具体的控制逻辑，调用Model层的业务逻辑模块，并且把响应提交到合适的View组件以产生响应。Struts提供的ActionForm组件对象为显示提供一个模型，可以通过定义属性描述客户端表单数据。从它派生子类对象，利用它和Struts提供的自定义标记库结合可以实现对客户端的表单数据的良好封装和支持。通过ActionForm组件对象实现了对View和Model之间交互的支持。同时，控制器会负责处理异常及UI验证
    2. Model：代表的是应用的业务逻辑。Model分为两层：持久层和业务层，用这种模式将底层数据访问操作与高层业务逻辑分离开。持久层使用ORM开源框架：Hibernate。 Hibernate为java提供了OR持久化机制和查询服务。业务层框架使用Spring。Spring着手于“依赖注入”这样的概念。Spring把程序中所涉及到包含业务逻辑和Dao的Objects——例如transaction management handler（事物管理控制）、Object Factoris(对象工厂)、service objects（服务组件）——都通过XML来配置联系起来，降低了各个组件的耦合度。
    3. View：View是应用的表示面，通过JSP技术实现。Struts提供了自定义的标记库可以使用，通过这些自定义标记可以非常好地和系统的Model部分交互，通过使用这些自定义标记创建的JSP表单，可以实现和ActionForm的映射，完成对用户数据的封装。

    Action调用Model层方法时通过读取Spring框架配置文件来创建实例。Spring框架控制主体公共部分，而把用户要使用的部分定义了接口，然后用Spring框架调用这个接口，实现回调。Model层分为两层：业务层（Manager）和持久层（DAO），每一层又分接口和实现两部分。Action调用Manager层的接口，Manager的Implement实现高层业务逻辑并调用DAO接口实现对数据库的操作。这三层之间的调用均通过Spring的“依赖注入”机制实现。

MYSQL_HOME
%TOOLS_HOME%\mysql-5.0.24-win32

SDKS_HOME
D:\AppConfig\SDKs

ANT_HOME
%TOOLS_HOME%\apache-ant-1.7.0

CATALINA_HOME
%TOOLS_HOME%\apache-tomcat-5.5.17

JAVA_HOME
%SDKS_HOME%\jdk1.5.0_06

PATH
%JAVA_HOME%\bin;%ANT_HOME%\bin;%CATALINA_HOME%\bin;%MYSQL_HOME%\bin 

看这个配置，应该很容易知道相关的目录结构。

第三步：Eclipse相关配置
1、解压appfuse-1.9.4-src.zip文件，并复制appfuse\lib\junit3.8.1目录下的junit.jar文件，粘贴到ant的lib目录下（也可以之后在Eclipse的Ant运行环境中加入）；
2、打开Elipse，依次找到Window——Preferences——Ant——Runtime——Classpath——Ant Home，点击后从打开目录对话框中选定你的Ant的所在目录，我这里的目录是：D:\AppConfig\Tools\apache-ant-1.7.0当然你也可以用Elipse缺省的Ant，但是这里你要把appfuse\lib\junit3.8.1目录下的junit.jar文件从外部导入进来。
3、将解压appfuse-1.9.4-src.zip后的文件从Elipse中导入进来，假设项目名称为：appfuse。
4、打开Ant运行窗口，导入appfuse下Buile.xml并执行new指令，来创建你的第一个AppFuse项目Hello。要注意项目名称不能使用"test"或者包含"appfuse"或者以数字开头。然后按照向导提示完成相关设置就可以了。 这是在Eclipse下创建你的第一个AppFuse应用，当然，如果你喜欢，也可以在控制下完成同样的动作，因为已经在环境变量中加入了相关映射，从而使得在控制台下运行成为可能。你还需要添加支持Tomcat的jar包和属性文件。同样在Window → Preferences → Ant → Runtime中，点击Add External JARs按钮，在Tomcat安装目录的/server/lib中选择catalina-ant.jar。添加到classpath中。然后点击Properties书签，点击Add Files按钮，选择项目Hello\lib\ant-contrib-1.0b1中的tomcatTasks.properties作为全局的属性文件。
5、在Eclipse中将刚刚创建的名为Hello的应用导入进来。他就在你解压appfuse-1.9.4-src.zip后appfuse文件的同级目录下。 打开Ant运行窗口，导入Hello下Buile.xml并执行setup指令,如果你的MySql设置了密码的话，他会提示出错，新项目的缺省密码为空。这时候你可以打开Hello下的properties.xml文件，找到<property name="database.admin.username" value="root"/><property name="database.admin.password" value=""/>修改你的用户名和密码，保存后重新运行setup，Ant会自动完成资料库及相关代码的创建。运行start.tomcat启动Tomcat服务器。访问：http://localhost:8080/Hello访问你创建的第一个应用，看看AppFuse的效果吧！
至此，第一个AppFuse应用完成。