#配置根Logger
log4j.rootLogger  =   [ level ]   ,  appenderName1 ,  appenderName2 ,  …

#配置日志信息输出目的地Appender
log4j.appender.appenderName  =  fully.qualified.name.of.appender.class 
　　log4j.appender.appenderName.option1  =  value1 
　　… 
　　log4j.appender.appenderName.optionN  =  valueN 

#配置日志信息的格式（布局）
log4j.appender.appenderName.layout  =  fully.qualified.name.of.layout.class 
　　log4j.appender.appenderName.layout.option1  =  value1 
　　… 
　　log4j.appender.appenderName.layout.optionN  =  valueN 

其中 [level] 是日志输出级别，共有5级：

FATAL      0  
ERROR      3  
WARN       4  
INFO       6  
DEBUG      7

Appender 为日志输出目的地，Log4j提供的appender有以下几种：

org.apache.log4j.ConsoleAppender（控制台），
org.apache.log4j.FileAppender（文件），
org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），
org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），
org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

Layout：日志输出格式，Log4j提供的layout有以下几种：

org.apache.log4j.HTMLLayout（以HTML表格形式布局），
org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

打印参数: Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，如下:

　　%m   输出代码中指定的消息
　　%p   输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL 
　　%r   输出自应用启动到输出该log信息耗费的毫秒数 
　　%c   输出所属的类目，通常就是所在类的全名 
　　%t   输出产生该日志事件的线程名 
　　%n   输出一个回车换行符，Windows平台为“\r\n”，Unix平台为“\n” 
　　%d   输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss , SSS}，输出类似：2002年10月18日  22 ： 10 ： 28 ， 921  
　　%l   输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java: 10 ) 

2. 在代码中初始化Logger:
1）在程序中调用BasicConfigurator.configure()方法：给根记录器增加一个ConsoleAppender，输出格式通过PatternLayout设为"%-4r [%t] %-5p %c %x - %m%n"，还有根记录器的默认级别是Level.DEBUG.
2）配置放在文件里，通过命令行参数传递文件名字，通过PropertyConfigurator.configure(args[x])解析并配置；
3）配置放在文件里，通过环境变量传递文件名等信息，利用log4j默认的初始化过程解析并配置；
4）配置放在文件里，通过应用服务器配置传递文件名等信息，利用一个特殊的servlet来完成配置。

3. 为不同的 Appender 设置日志输出级别：
当调试系统时，我们往往注意的只是异常级别的日志输出，但是通常所有级别的输出都是放在一个文件里的，如果日志输出的级别是BUG！？那就慢慢去找吧。
这时我们也许会想要是能把异常信息单独输出到一个文件里该多好啊。当然可以，Log4j已经提供了这样的功能，我们只需要在配置中修改Appender的Threshold 就能实现,比如下面的例子：

[配置文件]

### set log levels ###
log4j.rootLogger = debug ,  stdout ,  D ,  E

### 输出到控制台 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern =  %d{ABSOLUTE} %5p %c{ 1 }:%L - %m%n

### 输出到日志文件 ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = logs/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG ## 输出DEBUG级别以上的日志
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

### 保存异常信息到单独文件 ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = logs/error.log ## 异常日志文件名
log4j.appender.D.Append = true
log4j.appender.D.Threshold = ERROR ## 只输出ERROR级别以上的日志!!!
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

[代码中使用]

public   class  TestLog4j  {
     public   static   void  main(String[] args)  {
        PropertyConfigurator.configure( " D:/Code/conf/log4j.properties " );
        Logger logger  =  Logger.getLogger(TestLog4j. class );
        logger.debug( " debug " );
        logger.error( " error " );
    }
}

运行一下，看看异常信息是不是保存在了一个单独的文件error.log中。


4、对不同的包设置不同输出信息级别
eg：
打印OppenSessionInViewFilter中debug级别信息方法：
log4j.logger.org.springframework.orm.hibernate3.support.OpenSessionInViewFilter=debug
打印Struts标签中warn级别信息的方法：
log4j.logger.org.apache.struts.util=WARN

原理：
 Suppose   we   are   no   longer   interested   in   seeing   the   output   of   any   component   belonging   to   the   com.foo   package.   The   following   configuration   file   shows   one   possible   way   of   achieving   this.    
   
  log4j.rootLogger=DEBUG,   A1  
  log4j.appender.A1=org.apache.log4j.ConsoleAppender  
  log4j.appender.A1.layout=org.apache.log4j.PatternLayout  
   
  #   Print   the   date   in   ISO   8601   format  
  log4j.appender.A1.layout.ConversionPattern=%d   [%t]   %-5p   %c   -   %m%n  
   
  #   Print   only   messages   of   level   WARN   or   above   in   the   package   com.foo.  
  log4j.logger.com.foo=WARN  

1. hibernate的优化。这步很关键。我把所有一对多的hbm文件里的lazy属性都设置成true，另外，hibernate的fecthsize设置成1。这样就系统的性能就好了不少。
2. 设置jsp缓存。其实，appfuse本来就配置有oscache来缓存jsp的。但appfuse的作者觉得jsp缓存会影响jsp的调试，所以把oscache给禁止了。其实在生产环境里，用户是很少改动jsp的，所以应该打开jsp缓存。我们只需修改web.xml文件，把oscache的注释去掉就可以使用jsp缓存了。jsp缓存的效果非常好。
3. 把clickstreamFilter去掉。clickstream是用来给管理员查看用户点击url的历史记录用的。如果不关心这个，完全可以把clickstreamFilter去掉。因为它捕获每次点击，并在内存里存储，还是有些影响性能的。

二、spring 监听器　IntrospectorCleanupListener简介

spring中的提供了一个名为org.springframework.web.util.IntrospectorCleanupListener的监听器。它主要负责处理由　
JavaBeans  Introspector的使用而引起的缓冲泄露。spring中对它的描述如下：
 
它是一个在web应用关闭的时候,清除JavaBeans Introspector的监听器.在web.xml中注册这个listener.可以保证在web 应用关闭的时候释放与掉这个web 应用相关的class loader 和由它管理的类
 
如果你使用了JavaBeans Introspector来分析应用中的类，Introspector 缓冲中会保留这些类的引用.结果在你的应用关闭的时候,这些类以及web 应用相关的class loader没有被垃圾回收.
 
不幸的是,清除Introspector的唯一方式是刷新整个缓冲.这是因为我们没法判断哪些是属于你的应用的引用.所以删除被缓冲的introspection会导致把这台电脑上的所有应用的introspection都删掉.
 
需要注意的是,spring 托管的bean不需要使用这个监听器.因为spring它自己的introspection所使用的缓冲在分析完一个类之后会被马上从javaBeans Introspector缓冲中清除掉.
 
应用程序中的类从来不直接使用JavaBeans Introspector.所以他们一般不会导致内部查看资源泄露.但是一些类库和框架往往会产生这个问题.例如:Struts 和Quartz.
 
单个的内部查看泄漏会导致整个的web应用的类加载器不能进行垃圾回收.在web应用关闭之后,你会看到此应用的所有静态类资源(例如单例).这个错误当然不是由这个类自身引起的.

这个listener的源代码 :

package org.springframework.web.util;

import java.beans.Introspector;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class IntrospectorCleanupListener implements ServletContextListener {
    public void contextInitialized(ServletContextEvent event) {
    }

    public void contextDestroyed(ServletContextEvent event) {
        Introspector.flushCaches();
    }
}

大家可以看看他的flash演示http://rifers.org/，下载example试用...业谝淮慰吹絩uby on rails网站上面的演示一样。

rife简单来说就像rails一样，是一个包含了各层结构的、简化的开发框架，他包含了web层，IoC容器和持久层开发，等同于 Webwork/Spring/Hibernate的组合。不过rife的好处就是一个完整的框架，以统一的概念和操作方式来整合，并且对于domain model的运用和rails颇有异曲同工之妙。而rife的CRUD也类似于rails，异常简化了持久层开发。

此外，rife自身还包含了很多实用功能，例如异步发送Email，定时执行任务，web services功能，甚至还包含了一个cms框架！

rife从作者描述来看是2001年底开始开发的，此前用perl和PHP开发web项目，曾经自己有过一些框架，这些PHP的框架是rife的原型。rife到现在已经发展很多年了，最近我也是因为webwork2.2集成了rife的continuations子项目才知道rife的，目前 rife还不太知名，不论国内外，google出来的评论都寥寥无几。

rife给我初感觉很惊艳，因为我自己也认为Webwork/Spring/Hibernate组合功能强大确实很强大，但是这么多框架内容太多，整个学习成本颇高，而且每个框架都有自己的哲学，概念并不完全一致，考虑到再整合sitemesh，freemarker等等小框架，这门槛也够高的了。

rails能够这么引人关注，无非就是简化开发，这些特点我从rife身上也看到了。当然，限于Java语言特性，没有办法做到rails那么简化和灵活，但是已经比Webwork/Spring/Hibernate简化得太多了，和rails有得一比了，而且基于Java这种最成熟的语言，也是一大优势。

先说说rife的优点：

1、是一个full-stack的Java框架，所谓full-stack大概指的是集成所需要的所有功能的框架，例如rails也是一个full-stack的框架。因而其学习成本自然比Webwork/Spring/Hibernate要小得多。

2、rife集成了常用的大部分功能，包括了一个组件方式的web框架，IoC支持和持久化框架，此外还有RSS支持，CMF支持，Web Service支持，异步邮件支持，Job schedule等等等等。

3、他有一些扩展的子项目很有意思，例如continuations，CRUD，openlaszlo等等。CRUD框架类似于rails，不需要配置映射，运行期动态生成所有需要的CRUD，continuations就不用多说了，openlaszlo支持输出为laszlo。

总体而言，rife是一个和rails相似度很高的框架。有意思的是，rife作者和rails作者还爆发过争吵，这个可以去search他们各自的blog。大意是这样的：

rails作者David Heinemeier Hansson搞了一个在线todolist网站：
www.tatalist.com
号称只用了600行ruby代码，而rife作者Geert Bevin看了这个网站之后，发现一些很严重的bug，在指出之余，狠狠贬低了一把rails，于是遭到了Hansson的嘲讽和rails爱好者的攻击。

Geert Bevin说写这么个简单的网站竟然用了600行代码，可以想像rails并不像它吹的那么好，于是rails爱好者说，你有本事也自己写一个啊，站着说话不腰疼。Geert Bevin就真的自己写了一个出来，这就是：
http://blablalist.com/
功能和tatlist完全一样。并且把所有代码开源出来，号称用了752行Java代码和100多行XML配置文件。

Hansson看了代码之后，又在自己的blog上面狠狠贬低了一把Geert Bevin的代码和rife框架，最后说Java社区太不诚实了，骗子太多。

针对rails网站的那个15分钟做出来一个simpleblog的视频，Geert Bevin也搞了一个40分钟做出来一个simpleblog的视频，录制的内容更加丰富，所以也比较长，总体来说，两者的开发过程很相似，也都很快捷，但限于语言特性，rife要略微繁复一些。

再说说rife的缺点：

实际上我只是简单的看了几个rife做出来的开源程序和quickstart，可能叙述未必客观。

1、rife的持久层映射不是O/R Mapping，这是我认为最致命的缺陷。rife的映射方式是完全忠实映射table column的方式，没有对象层次图。这种方式在某些情况来说也许很好，降低难度，但是在O/R Mapping如此普及的今天，这样用法多少有点落伍，也让用惯了O/R Mapping的开发人员无法接受。

2、rife的view模板用这样的HTML注释标记来嵌入服务器端逻辑，大量运用这种的HTML注释标记显得非常烦琐，既没有freemarker这样的${}方便，也没有JSP Tag方便。

3、rife虽然有IoC功能，也可以连接Spring，但是显然不那么重视DI这种编程习惯。在作者自己写的bamboo forum里面处处看得到类似程序自己去创建依赖对象的代码，让用惯了IoC的开发人员感觉很不好。

总之，rife确确实实提供了一条快速开发的方式，学习成本也显然比Webwork/Spring/Hibernate要低。不过对于Webwork/Spring/Hibernate掌握非常熟练的开发人员例如我来说，似乎改用rife也不会提供更高的开发效率。

顺便提一句ruby on rails，我觉得大家有些过于被表象吸引。实际上对于逻辑关系比较复杂的项目来说，如果自己对Webwork/Spring/Hibernate掌握熟练，又积累了些加速开发的工具类和模板，其开发速度并不会比rails低。

在appfuse的web.xml声明文件中有下面的类似声明：

<filter>
        <filter-name>rewriteFilter</filter-name>
        <filter-class>org.tuckey.web.filters.urlrewrite.UrlRewriteFilter</filter-class>
        <init-param>
            <param-name>logLevel</param-name>
            <param-value>commons</param-value>
        </init-param>
</filter>

<filter-mapping>
        <filter-name>rewriteFilter</filter-name>
        <url-pattern>/**//*</url-pattern>
</filter-mapping>

它所应用到的包存放在lib下的

urlrewrite-3.0-beta.jar

它和以上的两部分，以及

/web-inf/urlrewrite.xml

构成了对url地址的美化

打开这个文件，我们可以看到以下的声明：

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE urlrewrite PUBLIC "-//tuckey.org//DTD UrlRewrite 3.0//EN"
    "http://tuckey.org/res/dtds/urlrewrite3.0.dtd">

<!-- https://urlrewrite.dev.java.net/manual/3.0 -->
<urlrewrite>
    <rule>
        <from>^/user/(.*).html$</from>
        <to type="forward">/editUser.html\?username=$1</to>
    </rule>
</urlrewrite>

这样系统就完成了url地址的editUser.html?username=****的美化

如将
http://localhost/aaa/bbb.jsp?id=99&name=abc
表现为：
http://localhost/aaa/bbb/99_abc.html
配置如下：

<rule> 
    <from>
        /aaa/bbb/([0-9]+)_([a-z]+).html
    </from> 

    <to>
        /../aaa/bbb.jsp?id=$1&name=$2
    </to> 
</rule> 

以上软件请访问
http://raibledesigns.com/wiki/Wiki.jsp?page=AppFuseQuickStart_zh
根据相关提示下载
同时对以上变量，都设置相关的HOME变量及路径。

下面开始一步步操作完成appfuse的布署工作

1，解压appfuse1.8.2（或更高版本），会产生一个appfuse的目录。
2，打开eclipse3.0或eclipse3.1，选择菜单，“新建工程”-->"Java Project"---->工程名"appfuse"后，指定一个工程目录后，完成。
3，先复制第一步中appfuse目录下所有文件，然后右键点击"appfuse"工程名，选择“粘贴”，把appfuse的所有的文件导入到appfuse工程中。
4，在eclipse下选择"windows"菜单--->"Preference"菜单--->"ant"--->"Runtime"---->点“ant      home”按钮,设备ant-home目录，同时复制junit.jar到ant安装目录下的lib目录里
5,在安装mysql服务器后，如果设置了密码的话，要点，windows菜单--->show views---> ant 。出现ant工具界面，在界面上，点add buildfiles图标，把appfuse工程根目录下的build.xml文件中附加进来，然后再打开properties.xml文件，修改里面的root用户的密码为你的mysql数据库访问时的密码。然后在ant菜单界面中展开target列表，选择，setup目录安装所有装备工作，
详细ant任务可以参照http://www.kingbit.com/appfuse/index.php上所描述的ant任务详解。
运行ant setup-tomcat 然后再运行，ant start-tomcat
然后在浏览器中打http://localhost:8080/appfuse
看看有没有出现界面
操作用户名及密码是tomcat tomcat
6,当上面都配置正确后，我们就来开始写一个新的操作了，先写个dao类下的model类
在eclipse下，展开src/dao文档结构，在org.appfuse.model下面，建个Person.java文件，
内容如下图：

/*
 * Created on 2006-5-22
 *
 * TODO To change the template for this generated file go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
package org.appfuse.model;

/**
 * @author Administrator
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 * @hibernate.class table="person"
 */
public class Person  extends BaseObject{
 private Long id;
 private String first_name;
 
 /**
  * @return Returns the id.
  * @hibernate.id column="id"  generator-class="increment"
     *              
  */
 public Long getId() {
  return id;
 }
 /**
  * @param id The id to set.
  */
 public void setId(Long id) {
  this.id = id;
 }
 /* (non-Javadoc)
  * @see org.appfuse.model.BaseObject#toString()
  */
 
 public String toString() {
  // TODO Auto-generated method stub
  return null;
 }
 /* (non-Javadoc)
  * @see org.appfuse.model.BaseObject#equals(java.lang.Object)
  */
 public boolean equals(Object o) {
  // TODO Auto-generated method stub
  return false;
 }
 /* (non-Javadoc)
  * @see org.appfuse.model.BaseObject#hashCode()
  */
 public int hashCode() {
  // TODO Auto-generated method stub
  return 0;
 }
 
 /**
  * @return Returns the first_name.
  * @hibernate.property column="first_name" not-null="true"
  */
 public String getFirst_name() {
  return first_name;
 }
 /**
  * @param first_name The first_name to set.
  * @spring.validator type="required" //该字段需要验证，用Spring的校验机制
  */
 public void setFirst_name(String first_name) {
  this.first_name = first_name;
 }
}

在以上代码中注释javadoc区域中添加上xdoclet在生成hibernate所用到的XML文件的一些O/R映射信息。

建好上以Person.java后，我们就开始利用xdoclet工具，配合ant任务，生成我们所需用到了数据库表结构了，
点ant db-create 后，可以在控制台下看到一系列建表的语句，同时可以到mysql控制台查看到相关信息.
表建好后，我们就开始利用appgen自动生成appfuse所需要的其它dao操作类，manage业务类，controller控制器类及Person.hbm.xml等相关文件
。操作过程如下，到dos命令行模式下，找到工程所在的根目录下\extras\appgen目录，点运行ant install-detailed
会根据提示，建Person及person相关文件。Build成功后，再回到eclipse下，右键点工程文件名appfuse,选择Refresh ,再运行ant deploy命令，再重新启TOMCAT,这样一个Person的添加，删除操作功能模块就完成了，开发就是这么easy and fast!!^_^
@spring.validator type="required" 是另外附

appgen生成的类文件如下：

PersonDAO接口类
PersonDAOHibernate接口实现类
PersonManager业务接口类
PersonManagerImpl.java业务接口实现类
PersonController.java控制器类(根据客户端提交的请求，显示的是信息列表)
PersonFormController页面控制器类（根据客户端提交的请求，修改，添加，删除操作控制类）

注意在生成dao接口类的时候，appgen会根据Person类中的hibernate的注释标记，生成对应的Person.hbm.xml文件
修改org.appfuse.dao.hibernate.applicationContext-hibernate.xml文件，
追加
 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="mappingResources">
            <list>
                <value>org/appfuse/model/Role.hbm.xml</value>
                <value>org/appfuse/model/User.hbm.xml</value>
                <value>org/appfuse/model/UserCookie.hbm.xml</value>
                <value>org/appfuse/model/Person.hbm.xml</value>
  <value>org/appfuse/model/Book.hbm.xml</value>    
            </list>
        </property>
        <!-- The property below is commented out b/c it doesn't work when run via
             Ant in Eclipse.  It works fine for individual JUnit tests and in IDEA ??
        <property name="mappingJarLocations">
            <list><value>file:dist/appfuse-dao.jar</value></list>
        </property>
        -->
        <property name="hibernateProperties">
        <props>
            <prop key="hibernate.dialect">@HIBERNATE-DIALECT@</prop>
            <!-- Create/update the database tables automatically when the JVM starts up
            <prop key="hibernate.hbm2ddl.auto">update</prop> -->
            <!-- Turn batching off for better error messages under PostgreSQL
            <prop key="hibernate.jdbc.batch_size">0</prop> -->
        </props>
        </property>
    </bean>
    同时指定动态指定接口的实现类
<!--Person-START-->
    <bean id="personDAO" class="org.appfuse.dao.hibernate.PersonDAOHibernate" autowire="byName"/>
    <!--Person-END-->
注意在业务接口类操作时，要运用SPRING的IOC进行对业务逻辑的处理，
修改org.appfuse.service目录下的，applicationContext-service.xml文件

追加以下配置

<!--Person-START-->
    <bean id="personManager" parent="txProxyTemplate">
        <property name="target">
            <bean class="org.appfuse.service.impl.PersonManagerImpl" autowire="byName"/>
        </property>
    </bean>
    <!--Person-END-->
在personManagerImpl.java文件中装PersonDao接口的Instance注入到personManager容器中。

PersonDAO接口类

package org.appfuse.dao;

import java.util.List;

import org.appfuse.model.Person;

public interface PersonDAO extends DAO {

    /**
     * Retrieves all of the persons
     */
    public List getPersons(Person person);

    /**
     * Gets person's information based on primary key. An
     * ObjectRetrievalFailureException Runtime Exception is thrown if
     * nothing is found.
     *
     * @param id the person's id
     * @return person populated person object
     */
    public Person getPerson(final Long id);

    /**
     * Saves a person's information
     * @param person the object to be saved
     */ 
    public void savePerson(Person person);

 /**
     * Removes a person from the database by id
     * @param id the person's id
     */
    public void removePerson(final Long id);
}

PersonDAOHibernate接口实现类

package org.appfuse.dao.hibernate;

import java.util.List;

import org.appfuse.model.Person;
import org.appfuse.dao.PersonDAO;

import org.springframework.orm.ObjectRetrievalFailureException;

public class PersonDAOHibernate extends BaseDAOHibernate implements PersonDAO {

    /**
     * @see org.appfuse.dao.PersonDAO#getPersons(org.appfuse.model.Person)
     */
    public List getPersons(final Person person) {
        return getHibernateTemplate().find("from Person");

        /* Remove the line above and uncomment this code block if you want
           to use Hibernate's Query by Example API.
        if (person == null) {
            return getHibernateTemplate().find("from Person");
        } else {
            // filter on properties set in the person
            HibernateCallback callback = new HibernateCallback() {
                public Object doInHibernate(Session session) throws HibernateException {
                    Example ex = Example.create(person).ignoreCase().enableLike(MatchMode.ANYWHERE);
                    return session.createCriteria(Person.class).add(ex).list();
                }
            };
            return (List) getHibernateTemplate().execute(callback);
        }*/
    }

    /**
     * @see org.appfuse.dao.PersonDAO#getPerson(Long id)
     */
    public Person getPerson(final Long id) {
        Person person = (Person) getHibernateTemplate().get(Person.class, id);
        if (person == null) {
            log.warn("uh oh, person with id '" + id + "' not found...");
            throw new ObjectRetrievalFailureException(Person.class, id);
        }

        return person;
    }

    /**
     * @see org.appfuse.dao.PersonDAO#savePerson(Person person)
     */   
    public void savePerson(final Person person) {
        getHibernateTemplate().saveOrUpdate(person);
    }

    /**
     * @see org.appfuse.dao.PersonDAO#removePerson(Long id)
     */
    public void removePerson(final Long id) {
        getHibernateTemplate().delete(getPerson(id));
    }
}

PersonManager业务接口类

package org.appfuse.service;

import java.util.List;

import org.appfuse.model.Person;
import org.appfuse.dao.PersonDAO;

public interface PersonManager extends Manager {

    /**
     * Setter for DAO, convenient for unit testing
     */
    public void setPersonDAO(PersonDAO personDAO);

    /**
     * Retrieves all of the persons
     */
    public List getPersons(Person person);

    /**
     * Gets person's information based on id.
     * @param id the person's id
     * @return person populated person object
     */
    public Person getPerson(final String id);

    /**
     * Saves a person's information
     * @param person the object to be saved
     */
    public void savePerson(Person person);

    /**
     * Removes a person from the database by id
     * @param id the person's id
     */
    public void removePerson(final String id);
}

PersonManagerImpl业务接口实现类

package org.appfuse.service.impl;

import java.util.List;

import org.appfuse.model.Person;
import org.appfuse.dao.PersonDAO;
import org.appfuse.service.PersonManager;

public class PersonManagerImpl extends BaseManager implements PersonManager {
    private PersonDAO dao;

    /**
     * Set the DAO for communication with the data layer.
     * @param dao
     */
    public void setPersonDAO(PersonDAO dao) {
        this.dao = dao;
    }

    /**
     * @see org.appfuse.service.PersonManager#getPersons(org.appfuse.model.Person)
     */
    public List getPersons(final Person person) {
        return dao.getPersons(person);
    }

    /**
     * @see org.appfuse.service.PersonManager#getPerson(String id)
     */
    public Person getPerson(final String id) {
        return dao.getPerson(new Long(id));
    }

    /**
     * @see org.appfuse.service.PersonManager#savePerson(Person person)
     */
    public void savePerson(Person person) {
        dao.savePerson(person);
    }

    /**
     * @see org.appfuse.service.PersonManager#removePerson(String id)
     */
    public void removePerson(final String id) {
        dao.removePerson(new Long(id));
    }
}

PersonController控制器类
注意在产生这个控制器类的作用是为了将PersonManager接口通过IOC注入并Instance
能够调用dao类取得的数据结果集返回给客户浏览器的请求。请求的mappingUrl地址又是在WEB/WEB-INF目录下action-servlet.xml
文件下进行配置的
<!--Person-BEAN-START-->
  <bean id="personController" class="org.appfuse.webapp.action.PersonController" autowire="byName"/>

    <bean id="personFormController" class="org.appfuse.webapp.action.PersonFormController" autowire="byName">
        <property name="commandName" value="person"/>
        <property name="commandClass" value="org.appfuse.model.Person"/>
        <property name="validator" ref="beanValidator"/>
        <property name="formView" value="personForm"/>
        <property name="successView" value="redirect:persons.html"/>
    </bean>
    <!--Person-BEAN-END-->

    <!--Person-URL-START-->
                <prop key="/persons.html">personController</prop>
                <prop key="/editPerson.html">personFormController</prop>
                <!--Person-URL-END-->
package org.appfuse.webapp.action;

import java.util.List;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.beanutils.BeanUtils;

import org.appfuse.Constants;
import org.appfuse.model.Person;
import org.appfuse.service.PersonManager;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

public class PersonController implements Controller {
    private final Log log = LogFactory.getLog(PersonController.class);
    private PersonManager personManager = null;

    public void setPersonManager(PersonManager personManager) {
        this.personManager = personManager;
    }

    public ModelAndView handleRequest(HttpServletRequest request,
                                      HttpServletResponse response)
    throws Exception {
        if (log.isDebugEnabled()) {
            log.debug("entering 'handleRequest' method...");
        }

        Person person = new Person();
        // populate object with request parameters
        BeanUtils.populate(person, request.getParameterMap());

        List persons = personManager.getPersons(person);

        return new ModelAndView("personList", Constants.PERSON_LIST, persons);
    }
}

PersonFormController添加修改删除操作控制器类。

package org.appfuse.webapp.action;

import java.util.Locale;

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

import org.apache.commons.lang.StringUtils;
import org.appfuse.model.Person;
import org.appfuse.service.PersonManager;
import org.springframework.validation.BindException;
import org.springframework.web.servlet.ModelAndView;

public class PersonFormController extends BaseFormController {
    private PersonManager personManager = null;

    public void setPersonManager(PersonManager personManager) {
        this.personManager = personManager;
    }

    protected Object formBackingObject(HttpServletRequest request)
    throws Exception {
        String id = request.getParameter("id");
        Person person = null;

        if (!StringUtils.isEmpty(id)) {
            person = personManager.getPerson(id);
        } else {
            person = new Person();
        }

        return person;
    }

    public ModelAndView onSubmit(HttpServletRequest request,
                                 HttpServletResponse response, Object command,
                                 BindException errors)
    throws Exception {
        if (log.isDebugEnabled()) {
            log.debug("entering 'onSubmit' method...");
        }

        Person person = (Person) command;
        boolean isNew = (person.getId() == null);
        Locale locale = request.getLocale();

        if (request.getParameter("delete") != null) {
            personManager.removePerson(person.getId().toString());

            saveMessage(request, getText("person.deleted", locale));
        } else {
            personManager.savePerson(person);

            String key = (isNew) ? "person.added" : "person.updated";
            saveMessage(request, getText(key, locale));

            if (!isNew) {
             return new ModelAndView("redirect:editPerson.html", "id", person.getId());
            }
        }

        return new ModelAndView(getSuccessView());
    }
}

在布署公司的产品过程中，mine的WAR应用，在执行ant compile-dao过程中，会报一个，找不到org.eclipse.jta的错误，
这是由于ant找不到eclipse的关于jta的插件的原因！解决办法是，在ant架包中，把eclipse 安装目录下的plugns目录下的org.eclipse.jdt.core_3.0.
（E:\eclipse\plugins\org.eclipse.jdt.core_3.0.0\）目录中两个jar文件加入到ant的lib目录下！

xdoclet在执行ant的deploy的任务时，有时候生成的XML文件格式会出现小小的问题，解决的办法是修改相关的JAVA文件，然后运行deploy脚本重新利用
xdoclet来生成相关的xml文件！直至成功！

首页登录在调用loginServlet时候，login.jsp页面能正确显示出来，但是提交到服务器的/authorize的action映射找不到，也就是找不到服务，
这是由于tomcat是启动在8080端口的服务，而程序中，用户登录的校验是根据properties.xml文件中，配置的
<property name="http.port" value="8080"/>这个端口号，默认的是80端口，可以通过把TOMCAT启动时监听80端口或，修改properties.xml文件中
http.port的value="8080",就可以找到服务器响应。注意，这里/authorize的映射,不是通过spring的IOC操作的，而是通过在web.xml文件中加入一个
 <filter>
  <filter-name>securityFilter</filter-name>
  <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class>
- <init-param>
  <param-name>targetClass</param-name>
  <param-value>net.sf.acegisecurity.util.FilterChainProxy</param-value>
  </init-param>
  </filter>
<filter-mapping>
  <filter-name>securityFilter</filter-name>
  <url-pattern>/j_security_check</url-pattern>
  </filter-mapping>

来实现的

但是一定要记得，文件net.sf.acegisecurity.util.FilterChainProxy是在acegi-security-x.x.x.jar包里面的，调用前一定要记得放在应用的WEB-INF/lib/目录下才能正常使用。

当系统启动时会自动加载spring配置文件中所声明的类，在appfuse中这一声明是放在action-servlet.xml中的，因此必须将这个文件同其他的applicationContext.xml一起在web.xml中声明为contextConfigLocation的内容，如下：

   <context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath*:META-INF/applicationContext-*.xml /WEB-INF/applicationContext-*.xml /WEB-INF/schedulingContext-timer.xml</param-value>
  </context-param>

在action-servlet.xml中定义如下（这个文件必须符合spring-beans.dtd的规范）：

<beans>   
   
    <bean id="userAction" class="com.mywap.webwork.action.UserAction" singleton="false">
        <property name="userManager"><ref bean="userManager"/></property>
    </bean>
   
    <!-- Add additional actions here -->
</beans>

acegi出了0.8,改动还真不少，原先0.7的应用，改了一个多小时才完全升级成功。备忘一下：

1 最贴心的改变莫过于 filter chains可以放在spring 容器中加载了，再也不用在Web.XML中声明长长的一串filter了。例如：

 <bean id="filterChainProxy" class="net.sf.aceGISecurity.util.FilterChainProxy">
      <property name="filterInvocationDefinitionSource">
         <value>
         CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
          PATTERN_TYPE_APACHE_ANT
            /**=httpSessionContextIntegrationFilter,authenticationProcessingFilter,......
         </value>
      </property>
    </bean>

2 HttpSessionIntegrationFilter 已经消失，使用net.sf.acegisecurity.context.HttpSessionContextIntegrationFilter取而代之，如：
    <bean id="httpSessionContextIntegrationFilter" class="net.sf.acegisecurity.context.HttpSessionContextIntegrationFilter">
      <property name="context"><value>net.sf.acegisecurity.context.security.SecureContextImpl</value></property>
    </bean>

这个"context"属性不可不设哟。

3 新增了一个功能，可以在web.xml中声明一个HttpSessionEventPublisher context listener,想想Spring的现在还不很成熟的消息发布机制(AOP),主要是用来记日志。我暂时还没用到这个功能。

mine在通过ant deploy任务到TOMCAT下,会把hibernate的表映射文件,连同持久化的类文件,打包成一个,mine-dao.jar架包,放到web-inf/lib私有目录下