如果您参与的项目正在使用 Subversion 进行版本控制，您将需要使用 Subversion 访问和更改项目源文件。您可以点击项目的左侧导航窗格上的“Subversion”链接，在线浏览源代码以查看该项目的目录结构和文件。

“Subversion”页面显示三个子目录：branches/、tags/、trunk/ 和一个自述文件。自述文件可以使您对 Subversion 存储库有一个整体了解。您可以点击“访问选项”，查看 Subversion 客户端安装说明。您的本地计算机上必须安装有 Subversion 客户端。

获取项目的本地工作副本：svn checkout

若要获取最新源文件的“工作副本”，您必须首先签出这些源文件，这一过程会将文件从存储库复制到您的系统中。在您的外壳程序或终端客户端，请键入：

当系统提示您时输入您的用户密码。此密码应与您在本站点中的用户帐号的密码相同。不指定目录将签出整个项目源代码。您可能希望签出“trunk/”目录，因为此目录具有工作“www/”文件夹。

请参见基本工作周期、初始签出、工作副本。

注意：如果站点未启用 SSL（安全套接字层），则在执行 Subversion 操作时，请使用 http 而不是 https。例如，若要从项目的存储库中签出最新的源代码，请使用以下命令：

svn checkout https://(项目名称).(域)/svn/(项目名称)/(DIR) (项目名称) --username [在此处输入用户名]

处理 Subversion 存储库中的文件

从项目存储库中签出本地副本后，您可以在本地计算机上编辑现有文件、创建新文件和目录、以及删除文件。在您将所做的任何更改提交回 Subversion 存储库之前，这些更改只对项目文件的本地副本起作用。

将工作副本中的文件/目录添加到存储库中：svn add

在您第一次在工作目录中创建并编辑新文件后，可以将此文件添加到存储库中，或添加一个目录，目录中有无内容均可。

这样就会在您的工作副本中添加文件/目录，并安排它们以添加到存储库中。您下次提交时，会上载这些文件/目录，并将它们添加到存储库中。如果您了添加内容，但在提交前又改变了主意，则可以使用 svn revert 取消添加内容的安排。

请参见添加文件/目录示例。

查看带有修订和作者信息的特定文件的内容：svn blame

若要在线查看指定文件的作者和修订信息，请键入：

每行文本的开始处都以上次更改该行的作者（用户名）和修订版本号作为批注。

查看特定文件的内容：svn cat

有时，与存储库相比较，您的工作副本可能已过时；或者您可能已修改了本地工作副本。在这些情况下，在提交更改或决定编辑您的工作副本之前，您会希望查看指定文件的内容差异。运行 svn cat FILENAME 将自动从存储库中取出 HEAD 修订版本。这条子命令主要用于检索具有较旧修订版本号的文件，并将其显示在屏幕上。通过在此站点上浏览项目源代码，也可以执行相同的操作。

清理工作副本：svn cleanup

有时可能会出现“工作副本已锁定”错误。若要删除锁定，并递归清理工作副本，请使用 svn update。

请参见 svn cleanup。

复制工作副本或存储库中的文件或目录：svn copy

在项目中，您可能需要用到过去的旧文档。例如，您可能想要使用一个已存在的 HTML 文件，使用其代码作为参考以在创建新内容时保持产品外观和感觉。创建文件时，您无需从头开始，只需使用 svn copy 复制此文件，然后将其另存为其它名称并更改其内容。您可以从存储库将文件复制为本地工作副本，也可以将本地工作副本复制回存储库文件。您还可以在本地工作副本内部复制文件。Subversion 不支持在存储库之间进行复制。可使用 svn copy SRC DST 完成此操作。

请参见 svn copy。

从本地工作副本中删除文件或目录：svn delete

您可能希望从本地工作副本中删除不需要的文件。使用 svn delete FILENAME 可安排删除文件。仅当您提交时，才会在存储库中将该文件实际删除。

转换：--force, --force-log, --message (-m) TEXT, --file (-F) FILE, --quiet (-q), --targets FILENAME, --username USER, --password PASS, --no-auth-cache, --non-interactive, --editor-cmd EDITOR, --encoding ENC, --config-dir DIR

查看文件之间的差异：svn diff

可以使用 svn diff 显示工作副本中的指定文件相对于存储库中相应文件所做的本地修改。在命令提示符处，请键入：

例如，若要将本地修改后的文件“index.html”与项目存储库中的相应文件进行比较，请键入：

除此之外，您也可以转到该文件所属的目录，并键入：

该命令将显示差异，并且带有修订版本号。

请参见检查历史、svn diff。

在本地计算机上导出空目录树：svn export

在您的本地计算机上，可以从项目存储库或本地工作副本内部提取一个无版本的副本，也称为空目录树。若要从存储库中获得较旧修订版本的空目录，请键入：

该命令将从 URL 指定的存储库中的修订版本 REV 位置（如果指定，否则从 HEAD 位置）将空目录树导出到 PATH。如省略 PATH，则该 URL 的最后一部分将用作本地目录名称。除此之外，您也可以在本地计算机内部，从一个工作副本（由 PATH1 指定）向另一工作副本（由 PATH2 指定）导出空目录树。这将保留所有的本地更改，但不会复制版本控制中的文件。若要执行此操作，请键入：

转换：--revision (-r) REV, --quiet (-q), --force, --username USER, --password PASS, --no-auth-cache, --non-interactive, --config-dir DIR

获取有关 Subversion 的帮助：svn help

Subversion 可以在命令行界面为您提供帮助。若要获得有关特定子命令的帮助，请键入：

转换：--version, --quiet (-q)

将您的更改提供给 SVN 存储库

对文件和/或目录进行本地更改后，您必须向 SVN 存储库提交这些更改。

提交您的更改：svn commit

若要向共享存储库提交您的更改，请键入：

如果您不包括对该文件更改的描述，系统将提示您调用文件编辑器添加描述，然后 svn 才能完成提交操作；否则将会出现“提交失败”错误。所有的提交都会被自动记录，并发布到项目的提交讨论中。

请参见提交您的更改、editor-cmd。

将无版本的文件或树导入到项目存储库中：svn import

您可以使用 svn import 将无版本的文件或树递归提交到项目存储库中。将根据需要在存储库中创建父目录。使用下面的命令可以从 PATH 向 URL 递归提交副本。如果省略 PATH，将认为其为“.”。

示例：若要在您的本地计算机上创建带有一个文件的无版本目录 (D)。请点击项目左侧导航窗格中的“Subversion”链接，找到 Subversion 页面。请注意，“浏览源代码”下未列出 NEWDIR。若要将 D 导入项目存储库，请键入：

刷新该页面。请注意，此时“浏览源代码”下列出了 D。点击 D 查看该文件。

打印有关工作副本中路径的信息：svn info

有时，您将需要有关工作副本中文件的具体信息，以执行某些子命令。键入 svn info，将打印出详尽且有用的信息，这些信息涉及工作副本中的工作副本路径中的项，其中包括：路径、名称、URL、修订版本、节点类型、上次更改、作者、上次更改修订版本、上次更改日期、上次更新的文本、上次更新的属性以及校验和。

查看存储库中的目录项列表：svn list

在开始处理项目或取出“工作副本”之前，您可能希望查看项目存储库中的内容（即目录和文件），或查看本地工作副本中的目录项。在命令提示符处键入 svn list [TARGET...]，也可以查看这些内容。除此之外，您也可以找到项目中的“软件配置管理”页，查看项目存储库。

查看提交日志信息：svn log

如果要查看“工作副本”或存储库中文件/目录的各个文件/目录历史，以跟踪修订信息，请键入：

该命令会显示出文件/目录的修订信息，从最近所做的修订版本开始显示提交信息和作者姓名等信息。除此之外，您也可以使用该站点，查看项目存储库中各个文件的提交日志信息。请点击项目左侧导航窗格中的“Subversion”链接。将出现 Subversion 页。搜索“浏览源代码”的目录中的文件，然后点击文件名。这时将会显示一个提交日志信息页面。

请参见 svn log。

合并更改：svn merge

您可以运行 svn merge 命令，以指示 Subversion 将存储库中最新版本的文件合并到您的工作副本中。

请参见 svn merge、解决冲突（合并其他人的更改）、分支和合并：常见合并使用案例、合并最佳实践。

使用存储库

创建新目录：svn mkdir

若要在您的工作副本中创建新目录，请键入：

若要在您的项目存储库中创建新目录，请键入：

PATH 或 URL 的最后一部分决定目录名称。在立即提交时在存储库中创建目录，所以还需要一条提交信息

移动文件或目录：svn move

您可以使用 svn move SRC DST 在工作副本或项目存储库内部移动文件或目录。此命令等效于在使用 svn copy 后，再使用 svn delete。在工作副本内部移动文件或目录，不仅会移动该文件或目录，而且还将安排它以便于下次提交时进行添加。在项目存储库内部移动文件或目录属于封闭单元式提交，所以需要一条提交信息。

使用属性

Subversion 具有很多具体属性，这些属性影响或决定其行为。您可以修改、提交和撤消属性更改，就像对文件内容所执行的操作一样。您还可以从本地工作副本或项目存储库的文件、目录或修订版本中，删除、编辑、打印、列出以及设置属性。

请参见 属性、无版本属性、元数据属性、svn propdel、svn propedit、svn propget、svn proplist、svn propset、Hook 脚本。

解决冲突：svn resolved

更新本地工作副本时，可能会遇到冲突。您需要解决此冲突。解决冲突后，键入 svn resolved PATH...，通知工作副本该冲突已“解决”。

转换：--targets FILENAME, --recursive (-R), --quiet (-q), --config-dir DIR

请参见解决冲突（合并其他人的更改）。

撤消您的更改：svn revert

使用 Subversion 时，您会发现 svn revert PATH... 等效于 Windows 中的 Ctrl Z。您可以：

• 撤消本地工作副本中的任何本地更改，从而解决冲突状态。
• 撤消工作副本中的条目内容及属性更改。
• 取消任何进度安排操作，如添加文件、删除文件等。

注意，如不提供目标，会导致工作副本中的更改丢失。

转换：--targets FILENAME, --recursive (-R), --quiet (-q), --config-dir DIR

获取文件/目录的状态：svn status

在版本控制中，将更改提交到项目存储库之前最好对其进行审查。可以运行 svn status 打印工作副本中的文件和目录的状态。打印结果为八列编码输出。由于每列都有详尽的图例，若要从此输出中得出“无错误”的结论几乎不可能。若要使此任务更加简单，并同时可看到示例，请在命令提示符处键入 svn help status。

转换：--show-updates (-u), --verbose (-v), --non-recursive (-N), --quiet (-q), --no-ignore, --username USER, --password PASS, --no-auth-cache, --non-interactive, --config-dir

请参见检查你的更改。

转换工作副本：svn switch

可以使用 svn switch URL [PATH] 更新工作副本，以镜像新的 URL。您还可以将工作副本或部分工作副本移动到新的分支。您可以将此子命令用作分支的快捷方式。

转换：--revision (-r) REV, --non-recursive (-N), --quiet (-q), --diff3-cmd CMD, --relocate, --username USER, --password PASS, --no-auth-cache, --non-interactive, --config-dir DIR

请参见转换工作副本、分支和合并以及 svn switch。

更新工作副本：svn update

为了进行更好的版本控制，建议您每天用项目存储库更新本地工作副本，请使用：

svn update [PATH...]

列出的已更新条目以及它们的当前状态显示如下：

• A = 已将一个文件添加到您的工作副本中。
• U = 已更新您的工作副本中的一个文件。
• D = 已从您的工作副本中删除一个文件。
• R = 已替换您的工作副本中的一个文件。
• G = 已成功合并了一个文件。
• C = 一个文件已合并了必须手动解决的冲突

转换：--revision (-r) REV, --non-recursive (-N), --quiet (-q), --diff3-cmd CMD, --username USER, --password PASS, --no-auth-cache, --non-interactive, --config-dir DIR

请参见更新你的工作副本、手动合并冲突。

分支和标记

项目的主干通常用作开发主线，而分支通常用作主线的变更。分支是正在进行的开发线。在软件开发生命周期中，如果软件产品的发布版本已到期，经常会用到分支，使测试者可以使用候选版本，使新的开发可以继续进行，不受测试的约束。分支还用于实验性工作，以及完成代码重写。标记是将一组文件修订版本标记为整体的方式。虽然分支和标记都是使用 svn copy 子命令创建的，但它们是完全不同的。分支表示多个修订版本而标记只表示单个修订版本。

本站点上您项目的 Subversion 存储库支持对您的源文件进行分支和标记。对于 Subversion 来说，标记和分支属于简单实用的“复制”操作。

若要创建分支或标记项目文件，请键入：

svn copy SRC DST -m "在此处键入您的信息"

打开spring的下载包的mock文件夹(路径...mock\org\springframework\mock\web),就发觉有如下几个文件:

MockHttpServletRequest:是HttpServletRequest接口的mock实现，用来模拟客户端的HTTP请求，很常用的一个类。

MockHttpServletResponse:是HttpServletResponse接口的mock实现，用于模拟服务器对客户端的响应。

MockHttpSession:是对HttpSession接口的mock实现。

DelegatingServletInputStream:是对ServletInputStream接口的mock实现。

DelegatingServletOutputStream:ServletOutputStream的mock实现。需要拦截和分析服务器的输出的流的内容，可以使用该类。

其他的，例如MockFilterConfig,MockPageContext(可以测试预编译的JSP),MockRequestDispatcher,MockServletConfig看名称就知道大概是mock什么的。
举一个例子：
    MockHttpServletRequest request =  new MockHttpServletRequest("POST","/index.do");  
    request.addParameter("username","name");  
    request.addParameter("password","word"); 

利用spring来进行集成测试：
1、AbstractSpringContextTests类[1],该类全部方法是protected的，通常不使用这个类，而使用它的子类们。

2、AbstractDependencyInjectionSpringContextTests类[2]：继承于类[1]：名字N长的。如果仅仅使用Spring依赖注入功能，可以让测试用例继承该类。

3、AbstractTransactionalSpringContextTests类[3]:继承于类[2]，继承该类的测试用例在spring管理的事务中进行，测试完后对数据库的记录不会造成任何影响。你对数据库进行一些操作后，它会自动把数据库回滚，这样就保证了你的测试对于环境没有任何影响

4、AbstractTransactionalDataSourceSpringContextTests：继承于类[3]，功能更强大，用于测试持久层组件,看其源代码，有一行"protected JdbcTemplate jdbcTemplate;"，提供了一个JdbcTemplate的变量，通过该对象可以直接操作数据库。

http://lighter.javaeye.com/blog/41733 还提供了两个用spring来进行集成测试(对数据库操作进行测试)，业务测试(对业务层进行测试)的例子供下载。

***如何在你的TestCase Class里取得spring context (注意路径问题)？***

你的TestCase Class必须继承的是上述四个AbstractXXXSpringContextTests中的其中一个，那么就必须实现下面这个方法来取得spring context：

   protected abstract String[] getConfigLocations();

例如：

 public String[] getConfigLocations() {
    String[] configLocations = { "applicationContext.xml","hibernate-context.xml" };
    return configLocations;
 }

请 注意要加载的context xml file的路径问题：上述的代码是基于classpath，因此applicationContext.xml和hibernate- context.xml必须放在classpath里（方法一是把xml files放到WEB-INF/classes目录下，另一种方法就是在project properties里把xml files的路径加到classpath里）

那么如果你一定要把context xml files放到WEB-INF目录下，也是可以的，那么应该基于file(基于file的相对路径是相对于project root folder)，代码如下：

 public String[] getConfigLocations() {
    String[] configLocations = { "file:WebContent/WEB-INF/applicationContext.xml"};
    return configLocations;
 }

AbstractXXXSpringContextTests就会根据根据getConfigLocations方法返回的context xml位置的数组来加载并且对加载的Context提供缓存。 这是非常重要的，因为如果你在从事一个大项目时，启动时间可能成为一个问题－－这不是Spring自身的开销，而是被Spring容器实例化的对象在实例 化自身时所需要的时间。例如，一个包括50-100个Hibernate映射文件的项目可能需要10-20秒的时间来加载上述的映射文件，如果在运行每个 测试fixture里的每个测试案例前都有这样的开销，将导致整个测试工作的延时，最终有可能（实际上很可能）降低效率。

在某种极偶然的情况下，某个测试可能“弄脏”了配置场所，并要求重新加载－－例如改变一个bean的定义或者一个应用对象的状态－－你可以调用 AbstractDependencyInjectionSpringContextTests 上的 setDirty() 方法来重新加载配置并在执行下一个测试案例前重建application context

当类 AbstractDependencyInjectionSpringContextTests（及其子类）装载你的Application Context时，你可以通过Setter方法来注入你想要的来自context的bean,而不需要显式的调用applicationContext.getBean(XXX)。因为AbstractDependencyInjectionSpringContextTests会从getConfigLocations()方法指定的配置文件中帮你自动注入

下面的例子就是通过setter方法来获得context里的ProductManager bean：

public class MyTest extends AbstractDependencyInjectionSpringContextTests {
    ProductManager productManager;

    public String[] getConfigLocations() {
        String[] configLocations = { "file:WebContent/WEB-INF/applicationContext.xml" };
        return configLocations;
    }

    public void testGetProduct() {
       assertEquals("tomson",productManager.getProductByName("tomson").getName());
    }
   

    //通过setter方法自动从context里注入productManager bean，而不用显示调用applicationContext.getBean(XXX)
    public void setProductManager(ProductManager productManager) {
       this.productManager = productManager;
    }
}

但是如 果context里有多个bean都定义为一个类型（例如有多个bean都是ProductManager class类型的），那么对这些bean就无法通过setter方法来自动依赖注入（因为有多个bean同一个类型，不知要自动注入哪个）。在这种情况下 你需要显示的调用applicationContext.getBean(XXX)来注入。如：

public class MyTest extends AbstractDependencyInjectionSpringContextTests {
   ProductManager productManager;

   public String[] getConfigLocations() {
      String[] configLocations = { "file:WebContent/WEB-INF/applicationContext.xml" };
      return configLocations;
   }

   public void onSetUp() {
       productManager = (ProductManager) applicationContext.getBean("productManager");
   }

   public void testGetProduct() {
       assertEquals("tomson",productManager.getProductByName("tomson").getName());
   }
 
}

如果你的TestCase不使用依赖注入，只要不定义任何setters方法即可。或者你可以继承 AbstractSpringContextTests －－这个 org.springframework.test 包中的根类，而不是继承AbstractDependencyInjectionSpringContextTests（及其子类）。这是因为AbstractSpringContextTests 只包括用来加载Spring Context的便利方法但没有自动依赖注入的功能。

• 点对点消息传递模型：在点对点模型中，每个消息都有一个发送者和一个接收者，见PPT3.在JMS中如果有多个接收者监听队列，就没办法直到某条特定的消息会被哪个接收者处理。这种不确定性实际上有很多好处，因为它可以让程序之用为队列添加监听器就能增大消息处理的能力。

  发布--订阅消息传递模型：在此模型中，消息会被发送给一个主题。像使用队列一样，可以让多个接收者监听一个主题。但是，与队列不同的是消息不再被只投递给一个接收者，所有主题的订阅者都会收到消息，见PPT4。

• 声明一个ActiveMQ队列： 

    <bean id="rantzDestination" class="org.apache.activemq.command.ActiveMQQueue">

          <constructor-arg index="0" value="rantz.marketing.queue" />

   </bean>

  声明一个ActiveMQ主题：

    <bean id="rantzDestination" class="org.apache.activemq.command.ActiveMQTopic">

          <constructor-arg index="0" value="rantz.marketing.topic" />

   </bean>

• 使用JMS模板：JmsTemplate是Spring消除冗长和重复JMS代码的解决方案。JmsTemplate可以创建连接，获取会话，以及发送和接收消息。它使你可以专注于构建要发送的消息或者处理收到的消息。另外，JmsTemplate可以处理任何被抛出的JMSException。如果JMSException在JmsTemplate工作中被抛出，JmsTemplate将捕获这个异常，并且用一个未受查的JmsException的子类再次抛出它。见PPT7

  置入JmsTemplate模板：

  <bean id ="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">

     <property name="connectionFactory" ref="connectionFactory">

  </bean>

  • 发送消息：在RoadRantz端，我们使用JmsTemplate向RoandRantz市场发送驾驶员信息。RantzMarketingGatewayImpl是RoadRantz与市场系统进行交互的类。见PPT8，因此，当我们在Spring中配置RantzMarKetingGatewayImpl类时，必须置入jmsTemplate和rantzDestination Bean的参考：

      <bean id="marketingGateway"  class="com.roadrantz.marketing.RantzMarketingGatewayImpl">

            <property name="jmsTemplate" ref ="jmsTemplate"  />

            <property name="destination" ref="rantzDestination"  />

     </bean>

    设置默认目标：如果每次发送消息都指定一个目标，不如为JmsTemplate置入一个默认目标：

    <bean id ="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">

       <property name="connectionFactory" ref="connectionFactory" />

      <property name="defaultDestination" ref="rantzDestination" />

    </bean>

    现在，调用JmsTemplate的send()方法就可以去掉第一个参数了。这种send()方法的形式只带有一个MessageCreator。因为没有指定目标，JmsTemplate会假设你要将消息发送给默认目标。所以不必再为RantzMarketingGatewayImpl注入目标了。它的声明很简单：

      <bean id="marketingGateway"  class="com.roadrantz.marketing.RantzMarketingGatewayImpl">

            <property name="jmsTemplate" ref ="jmsTemplate"  />

     </bean>

    消费消息：使用JmsTemplate接收消息十分简单。只需要调用JmsTemplate的receive()方法，如PPT9. 默认情况下，对receive()方法的调用会造成阻塞，直到消息到达目标--如果必要，会永远等待下去。为了避免对消息的内部等待，可以通过配置JmsTemplate时，通过设置receiveTimeout属性来指定接收时间。下面配置的接收超时时间为一分钟（60000毫秒）。

    <bean id ="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">

       <property name="connectionFactory" ref="connectionFactory" />

      <property name="defaultDestination" ref="rantzDestination" />

      <property name="receiveTimeout" value="60000" />

    </bean>

    在PPT9中，receive()方法会从默认目标接收消息。如果你希望指定一个目标，可以为其传递一个目标：

    MapMessage message = (MapMessage) jmsTemplate.receive(destination);

    此外，还可以通过名称指定目标，并且让Spring的目标解析器自动解析这个目标：

     MapMessage message = (MapMessage) jmsTemplate.receive("rantz.marketing.queue");

    转换消息：为了简化示例，没有在发送和接收消息的代码中添加处理消息转换的代码。但是，如果在程序中的多个位置都需要发送或接收相同的消息，可能就需要通过消息转换器来避免不必要的映射代码。尽管将消息转换代码抽象成自己的工具类并不是很困难，但是你仍然需要明确的调用工具类来进行转换。幸运的是，Spring通过MessageConverter接口提供了对消息转换的支持：

        public interface MessageConverter {

            public Message toMessage(Object  object, Session session);

            public Object fromMessage (Message message) ;

     } 

       见PPT10，展示了一个MessageConverter接口的实现MotoristMessageConverter,可以将Motorist对象转换为消息，也可以将消息转换为SpammedMotorist对象。

    • 发送和接收被转换的消息：我们可以在发送消息前不用明确的调用toMessage()方法，只需要调用JmsTemplate的convertAndSend()方法。因此，PPT8中的sendMotoristInfo()方法将变得更加简单：

             public void sendMotoristInfo (final Motorist motorist){

                 jmsTemplate.converAndSend(motorist);  }      消息被发向JmsTemplate的默认目标(假设已经指定了一个默认目标)。不过我们也可以在调用convertAndSend()方法时指定一个特定的目标：             jmsTemplate.connverAndSend(destination,motorist);  另外，我们也可以通过名称指定目标：                     jmsTemplate.convertAndSend("rantz.marketing.queue",motorist);  接收端：         public SpammedMotorist receiveSpammedMotorist() {    return (SpammedMotorist) jmsTemplate.receiveAndConvert();        }   除非有特殊的指定，recieveAndConvert()会从默认目标接收消息。不过，我们也可以通过为receiveAndConvert()方法传递一个参数来选择一个目标：          return (SpammedMotorist) jmsTemplate.receiveAndConvert(destination);    或者使用目标的名称： return (SpammedMotorist) jmsTemplate.receiveAndConvert("rantz.marketing.queue");

      置入消息转化器：  <bean id="motoristConverter" class="com.roadrantz.marketing.MotoristMessageConverter" />

      最后，JmsTemplate需要了解这个消息转换器。为了提供消息转换器，我们会将motoristConverter Bean置入到JmsTemplate的messageConverter属性中：

      <bean id ="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">

         <property name="connectionFactory" ref="connectionFactory" />

        <property name="defaultDestination" ref="rantzDestination" />

        <property name="messageConverter" ref="motoristConverter" />

      </bean>

  将Spring的网关支持类应用于JMS: Spring通过提供JdbcDaoSupport使JdbcTemplate的应用比原先变得更简单一些。与此类似，Spring也提供了一个用于JMS网关类的基类JmsGatewaySupport(见PPT11)。 那么JmsGatewaySupport从哪里得到JmsTemplate呢？你可以直接在jmsTemplate属性中注入JmsTemplate，就像处理常规的RantzMarketingGatewayImpl一样。或者，可以为connectionFactory属性置入连接工厂，来满足对JmsTemplate Bean的所有需求：

   <bean id = "marketingGateway" class="com.roadrantz.marketing.RantzMarketingGatewayImple">

      <property name="connectionFactory " ref="connectionFactory" />

  </bean>

    当这种方法配置时，JmsGateSupport将基于被注入的连接工厂自动创建一个JmsTemplate对象。因此不必在Spring中声明JmsTemplate Bean。 在直接将连接工厂置入到网关之前，你应该了解这种方法有两个缺点：

  1、只能在JmsTemplate上指定默认目标。如果JmsGateSupport创建了自己的JmsTemplate，就没有机会再指定默认的目标了。你必须在调用send()或receive()时明确地选择一个目标。

  2、只能将消息转换器置入到JmsTemplate中。如果JmsGatewaySupport创建了自己JmsTemplate，将不能使用消息转换器。因此，必须明确地在网关代码中处理消息的转换。

创建消息驱动POJO：EJB2.0规范的其中一个重要内容是包含了消息驱动Bean(MDB)。MDB是可以异步处理消息的EJB。换句话说，MDB会将JMS目标中的消息作为事件来响应。这与同步消息接收者在消息可用前进行阻塞正好相反。MDB是EJB的一个两点。在EJB3的规范中，MDB被简化了，使其更像POJO。不再需要实现MessageDrivenBean接口，只需要实现常规的java.jms.MessageListener接口并用@MessageDriven注释MDB。Spring2.0通过自己的消息驱动Bean形式来满足消息的异步消费需求。

• 创建消息监听器：MarketingMdp不必实现MessageDrivenBean接口的世界是多么简单，见PPT12。MarketingMdp本身并不做些什么。它有一个实际处理消息的onMessage()方法。不过要先在Spring中配置一下：

  <bean id="rantzMdp" class="com.roadrantz.marketing.MarketingMdp"  />

  EJB3.0MDB会使用@MessageDriven注释通知容器这是一个MDB。但是，在Spring中，我们会通过将其注入到一个消息监听容器来指示这个Bean是一个MDP。

  包含消息监听器：消息监听器容器是一个用于查看JMS目标，等待消息到达的特殊Bean。一旦消息到达，它就可以获取到消息，并通过onMessage()方法将消息传递给一个MessageListener的实现。因为MarketingMdp类实现了MessageListener接口，所以消息监听器容器就准备完毕了。见PPT13. 顾名思义，SimpleMessageListenerContainer是最简单的消息监听器容器，可以按下面的方法在Spring中进行配置：

  <bean class="org.springframework.jms.listener.SimpleMessageListenerContainer">

       <property name="connectionFactory" ref="connectionFactory" />

       <property name="destination" ref="rantzDestination" />

       <property name="messageListener" ref="rantzMdp" />

  </bean> 

  对于messageListener属性，我们为其置入了对MDP实现的引用，这样，onMessage()方法将可以被用来接收消息。

  使用事务性的MDP:如果收到的一个消息在事务中，则应该使用DefaultMessageListenerContainer：

   <bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">

       <property name="connectionFactory" ref="connectionFactory" />

       <property name="destination" ref="rantzDestination" />

       <property name="messageListener" ref="rantzMdp" />

       <property name="transactionManager" ref="jmsTransactionManager" />

  </bean>  如果事务性需求比较简单，JmsTransactionManager将按如下方法配置：

   <bean id="jmsTransactionManager" class="org.springframework.jms.connection.JmsTransactionManager">

       <property name="connectionFactory" ref="connectionFactory" />

  </bean>  需要提醒的是，tansactionManger属性是可选的。如果不注入事务管理器，MDP就不是事务性的。

  编写纯POJO MDP：如果消息监听器容器的messageListener属性被注入了MessageListener的实现，它就能够知道在消息到达时应该调用onMessage()方法。幸运的是，Spring提供了一个替代的MessageListenerAdapter。它是一个MessageListener，可以委派Bean和你选择的方法，见PPT14. 如果不将自己的MessageListener的实现注入到消息监听器容器中，你可以置入到MessageListenerAdapter中：

  <bean class="org.springframework.jms.listener.SimpleMessageListenerContainer">

       <property name="connectionFactory" ref="connectionFactory" />

       <property name="destination" ref="rantzDestination" />

       <property name="messageListener" ref ="purePojoMdp" />

  </bean> 因为配置了purePojoMdp Bean，所以它是一个MessageListenerAdapter:

   <bean id="purePojoMdp" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">

      <property name="delegate" ref="rantzMdp" />

      <property name="defaultListenerMethod"  value="processMotoristInfo" />

  </bean> 默认情况下，MessageListenerAdapter在消息到达时会调用handleMessage()方法。但是，我们希望MarketingMdp Bean可以通过 processMotoristInfo()方法处理消息，因此将defaultListenerMethod设置为processMotoristInfo.    因为选择了一个特定的被调用方法，所以不需要实现MessageListener或onMessage()方法。因此 MarketingMdp现在将被简化为PPT15。尽管它是一个POJO，对MapMessage的依赖造成了MarketingMdp与JMS的不必要耦合，另外，MapMessage的getString方法还会抛出必须被处理的JMSException。理想情况下，MarketingMdp不应该依赖任何特定框架的类型。 当MessageListenerAdapter接收消息时，它会考虑消息的类型和defaultListenerMethod的值，并且尝试着查找用来调用的监听器方法符号。PPT16描述了MessageListenerAdapter是如何将JMS消息映射到监听器方法参数的。

  转换MDP消息：在最新版中，processMotoristInfo()带有的是Map，并且在处理前需要将Map转换为SpammedMotorist。如果在消息到达时，能够直接给processMotoristInfo()方法传递可以处理的SpammedMotorist对象岂不是更好么？Spring消息转换器可以执行消息和特定域Java类型之间的相互转换工作。在PPT10中，已经有一个消息转换器。我们需要做的就是让MessageListenerAdapter能够感知这个消息转换器。MessageListenerAdapter的messageConverter属性可以完成这项工作：

  <bean id="purePojoMdp" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">

      <property name="delegate" ref="rantzMdp" />

      <property name="defaultListenerMethod"  value="processMotoristInfo" />

      <propert name="messageConverter" ref="motoristConverter" />

  </bean> 现在，可以编写最终版的MarketingMdp了。

使用基于消息的RPC：RPC编程模型可以使与远程服务的交互就如同在调用本地对象的方法。是否有某种方法既具有RPC编程模型的简单性，又可以利用异步消息传递的优点呢？

• 引入Lingo： 它是一种基于Spring的远程调用方法，它在RPC和异步消息传递之间架起了一座桥梁。与使用其他的Spring远程调用方法相同，Lingo提供了一个服务输出器，可以将Bean的功能输出为Lingo服务和客户端代理。 Lingo远程调用会通过JMS队列或主题来承载信息。 尽管Lingo是基于Spring远程调用的，但是它并不是Spring框架的一部分。你可以从Lingo的主页下载Lingo(http://lingo.codehaus.org/Download).

  输出服务：在服务端，Lingo提供了一个服务输出器JmsServiceExporter。被Lingo输出的服务是通过JMS来提供服务的，而不是用于直接的RPC访问，见PPT17。下面的XML配置了一个JmsServiceExporter，能够将rantzMdp Bean输出为RPC-over-JMS服务：

  <bean id="server" class="org.logicblaze.lingo.jms.JmsServiceExporter">

       <property name="connectionFactory" ref="connectionFactory" />

       <property name="destination" ref="destination" />

       <property  name="service" ref="rantzMdp" />

       <property name="serviceInterface" value="com.roadrantz.marketing.MarketingService"  />

  </bean>

    service属性被置入了对rantzMdp Bean的引用，即MarketingMdp。最后，应该将定义了服务的接口的类名配置到serviceInterface属性中。我们声明的被输出服务带有MarketingService接口，定义如下：

    public interface MarketingService {

      void processMotoristInfo (SpammedMotorist motorist );

  }    因为我们定义的服务带有MarketingService接口，这就意味着我们应该对MarketingMdp类进行一些小的修改，以便它可以实现MarketingService接口：

    public class MarketingMdp implements MarketingService {

       public void processMotoristInfo(SpammedMotorist motorist) {

           ...

      }

  }

  这就是使用Lingo输出服务的全过程。一旦应用程序启动，JmsServiceExporter将会起作用，就可以开始使用它了。现在，让我们再到客户端看看RoadRantz应用程序是如何调用这个被输出的市场服务的。

  代理JMS：在RoadRantz应用程序中，每次用户注册并选择愿意接收特定提供商信息时都需要调用processMotoristInfo()方法，因此，我们必须以某种方法将Lingo输出服务的引用置入到RoadRantz应用程序中。

  • 置入JmsProxyFactoryBean:lingo提供了JmsProxyFactoryBean，这是一个代理工厂Bean，可以生成远程Lingo输出服务的代理。如PPT18所示，通过JmsProxyFactoryBean代理的服务是通过JMS目标(队列或主题)访问的，而不是通过TCP/IP。下面声明配置了一个JmsProxyFactoryBean：

    <bean id = "marketing" class="org.logicblaze.lingo.jms.JmsProxyFactoryBean">

         <property name="connectionFactory" ref="connectionFactory" />

         <property name="destination" ref="destination" />

         <property name="serviceInterface" value="com.roadrantz.marketing.MarketingService" />

    </bean> serviceInterface属性指定了代理需要实现的Java接口。通过这个接口，RoadRantz可以调用processMotoristInfo()方法。 对于配置JmsProxyFactoryBean，最需要注意的事情是不用配置服务的位置信息。这是因为服务的位置并不重要，只需要知道服务在哪里接收"邮件"。事实上，我们还可以使用远程服务的多个实例。如果想建立一个高可靠性的市场服务，可以启动两个或多个实例，让它们都监听相同的目标。每一个实例都能够处理一个请求。其间，客户端并不知道有一个服务池在等待请求进行响应。

    进行调用：在JmsProxyFactoryBean被置入后，就可以开始调用远程服务了。我们需要做的是将其置入到RantServiceImpl:

    <bean id ="rantService" class="com.roadrantz.service.RantServiceImpl">

       <property name="rantDao" ref="rantDao" />

       <property name="marketingService" ref="marketing" />

    </bean>  接着，我们可以使用它在addMotorist()方法中向市场服务发送SpammedMotorist对象。PPT19展示了为了调用远程市场服务对RantServiceImpl进行的相关修改。 正如你看到的，调用Lingo输出的服务与调用RMI服务、Web服务或在同一个进程中调用其他Bean上的方法是相同的。PPT19中没有任何关于JMS的内容。唯一不同的地方在Spring的配置。通过这种方法，只需要简单的更改Spring的配置就能够在JMS和其他通信机制直接进行切换。

• 请求生命中的第一天：请求从离开浏览器开始知道获得一个响应，期间会有几次停留，每一次都留下一些信息并得到更多的信息。（见PPT1）

  • 配置DispatcherServlet:Spring MVC的核心是DispatcherServlet，这个servlet的功能是作为Spring MVC的前端控制器。和任何Servlet一样，必须在Web应用系统的web.xml文件中配置。

    <servlet>

        <servlet-name>roadrantz</servlet-name>

        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <load-on-startup>1</load-on-startup>

    </servlet>

    当DispatcherServlet载入后，它将从XML中载入Spring的应用上下文，这个XML的名字取决于Servlet的名字。在本例中，因为Servlet的名字叫做roadrantz，所以DispatcherServlet将试图从一个叫做roadrantz-servlet.xml的文件中载入应用上下文。接下来指定哪些URL需要由DispatcherServlet来处理。

    <servlet-mapping>

          <servlet-name>roadrantz</servlet-name>

          <url-pattern>*.htm</url-pattern>

    </servlet-mapping>  我们可以为DispatcherServlet选择任意URL样式。我们选择"*.htm"样式的主要原因是因为这种样式是大多数生成HTML内容的Spring MVC应用系统的惯例用法。另一个原因是生成的内容是HTML，因此URL应该反映这一点。

    • 分解应用上下文：正如前面提到的，DispatcherServlet从以<servlet-name>命名的XML文件中载入应用上下文。但这不是说你不能将你的应用上下文切到多个XML文件中。事实上，我们建议你将应用上下文分散到应用系统的各个层中。（见PPT2）由于DispatcherServlet的配置文件是roadrantz-servlet.xml，所以在这个文件中应该包含用于控制器和其他Spring MVC组件的<bean>定义信息。对于业务层和数据层的Bean，我们倾向于将他们分别放到roadrantz-service.xml和roadrantz-data.xml中。

      配置上下文载入器：为了保证所有的配置文件都被载入，需要在web.xml中配置一个上下文载入器。上下文载入器载入除DispatcherServlet载入的配置文件之外的其他上下文配置文件。最常用的上下文载入器是一个Servlet监听器，其名称为ContextLoaderListener，你需要在web.xml文件中像下面这样配置它：

      <listener>

          <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

      </listener>    使用ContextLoaderListener配置时，你需要告诉它Spring配置文件的位置。如果没有指定，上下文载入器会在/WEB-INF/applicationContext.xml中找Spring配置文件。但是这样无法将应用上下文分散到应用系统的各个层中，所以你需要取代这种默认方式。 你可以通过Servlet上下文中设置contextConfigLocation参数来为上下文载入器指定一个或多个Spring配置文件：

      <context-param>

           <param-name>contextConfigLocation</param-name>

           <param-value>

                /WEB-INF/roadrantz-service.xml,

                /WEB-INF/roadrantz-data.xml,

                /WEB-INF/roadrantz-security.xml

           </param-value>

      </context-param>

      Spring MVC概述：每一个Web应用程序都有一个主页。这是应用程序的一个起始点。用户可以从主页中启动应用程序，也可以在失去方向时回到主页。否则，用户会不停的点击链接，感到很困扰，甚至可能离开，进入到其他网站中。第一步是建立一个处理主页请求的控制器对象。因此让我们来编写第一个Spring MVC控制器。

      • 创建控制器：在Spring MVC中，控制器是一个与应用程序功能的接口类。（见PPT3）控制器接收请求，将请求发送给服务类进行处理，最后又收集需要返回给用户Web浏览器的结果。

        public class HomePageController extends AbstractController {

            protect ModelAndView handleRequestInternal(HttpServletRequest request,HttpServletResponse response)throws Exception {

             List recentRants = rantService.getRecentRants( );

            return new ModelAndView("home","rants",recentRants);

            }

           private RantService rantService;

           public void setRantService(RantService rantService) {

              this.rantService = rantService;

            }

          }

        } Spring控制器和Servlet或Struts Action的不同之处在于它被配置成Spring应用上下文的一个普通JavaBean。这意味着，使用控制器和使用其他Bean一样，可以充分利用依赖注入和Spring AOP。在HomePageController中，依赖注入用在了注入一个RantService.HomePageController

        引入ModelAndView：控制器执行方法都必须返回一个ModelAndView。因此需要理解这个重要的类是如何工作的。正如它的名字表述的，ModelAndView保存了视图以及视图显示的模型数据.在HomePageController里，ModelAndView对象应按照下面的方式构建： new ModeAndView("home","rants",recentRants); 构造器的第一个参数是视图组件(用于显示空气器的输出)的逻辑名称。这里，视图的逻辑名称是home。视图解析器会使用这个名称查找实际的View对象  。 后两个参数分别表示传递给视图的模型对象。这个两个参数是一个名字值对。第二个参数就是第三个参数所表示的模型对象名称。

        配置控制器Bean:现在HomePageController已经写好了，你必须将其配置到DispatcherServlet的上下文配置文件中(对于RaodRantz应用程序就是roadrantz-servlet.xml文件)。下面这段XML代码定义了HomePageController:

        <bean name="/home.htm" class="com.roadrantz.mvc.HomePageController">

           <property name="rantService" ref="rantService" />

        </bean>  有件事让你感到奇怪，不是为HomePageController Bean设置id属性，而是设置name属性。并且更奇怪的是设定的不是一个真实名字，而是给它设置一个URL"/home.htm"。这里name属性承担了两个责任，即定义Bean的名字也定义需要使用这个控制器处理的URL样式。由于URL样式含有XMLid属性中的非法字符--特别是斜杠(/)，所以使用name属性，而不使用id。只要进入DispatcherServlet的请求是以"/home.htm"结尾的，DispatcherServlet就会分给HomePageController来处理，注意这个Bean的name属性使用的是URL样式的唯一原因是我们还没有配置处理映射Bean。DispatcherServlet使用的默认处理器映射是BeanNameUrlHandlerMapping，它使用URL样式的名字。

        声明一个视图解析器：返回给ModelAndView对象的其中一个值是逻辑视图名称。然而这个逻辑视图名称并不是直接引用特定的JSP的，而是用于间接的表达使用哪一个JSP。为了帮助Spring MVC了解使用哪一个JSP，你需要在roadrantz-servlet.xml中声明另一个Bean：一个视图解析器。简单来看，视图解析器的工作就是将视图的名称返回到ModelAndView中并将其映射到一个视图上。在HomePageController中，我们需要一个视图解析器将"home"解析成一个JSP文件来呈现主页。Spring MVC带来了很多可供选择的视图解析器。对于使用JSP渲染视图来说，再也没有比InteralResourceViewResolver更简单的了:

          <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">

               <property name="prefix">

                  <value>/WEB-INF/jsp/</value>

               </property>

               <property name="suffix">

                  <value>.jsp</value>

               </property>

           </bean>由于HomePageController返回的ModelAndView中的视图名是home,InternalResourceViewResolver将在/WEB-INF/jsp/home.jsp处查找视图。

  将请求映射到控制器：当请求到达DispatcherServlet时，需要一些目录来指明请求应该如何分配。处理器映射可以帮助DispatcherServlet了解请求应该被发送给哪个控制器。我们依赖DispatcherServlet默认使用的BeanNameUrlHandMapping。BeanNameUrlHandMapping很容易上手，但是 它无法满足所有情况。所幸，Spring MVC提供了几种可以选择的处理器映射实现。Spring MVC中所有的处理器映射都实现了接口org.springframework.web.servlet.HandlerMapping  （见PPT4）

  • 使用SimpleUrlHandlerMapping：它可能是最直接的Spring处理器映射。它允许你将URL样式直接映射到控制器，而且不需要以待定的方式命名你的Bean。例如：

       <bean id="simpleUrlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">

         <property name="mappings">

            <props>

               <prop key="/home.htm">homePageController</prop>

               <prop key="/rantsForVehicle.htm">rantsForVehicleControllerRss</prop>

               <prop key="/rantsForVehicle.rss">rantsForVehicleControllerRss</prop>

            </props>

         </property>

       </bean>

    <props>元素的key属性是URL样式。和BeanNameUrlHandlerMapping一样，所有的URL样式和DispatcherServlet的<servlet-mapping>一一对应。<prop>的值是处理这个URL的控制器Bean的名字。

    使用ControllerClassNameHandlerMapping:很多时候，你会发现控制器映射的URL样式都与控制器类名很相似。例如，在RoadRantz应用程序中，我们将rantForVehicle.htm映射到rantForVehicleController，将rantsForDay.htm映射到RantsForDayController。在这些例子中，URL样式与控制器的类名相同，只不过去掉了Controller部分，加上了.htm部分。这种样式就好像对映射设置了特定的默认值，而不需要明确地进行映射。这大概就是ControllerClassNameHandlerMapping所做的工作：

    <bean id="urlMapping" class="org.springframework.web.servlet.mvc.ControllerClassNameHandlerMapping" />

    这样就可以通知Spring的DispatcherServlet将URL样式按照简单的约定映射到控制器。Spring不必明确的为每个控制器映射URL样式，而是可以根据控制器的类名自动的将控制器映射到URL样式上。 为了简单起见，要想生成URL样式，控制器类名中的Controller部分会被去掉(如果这部分存在)，剩下的文本会变成小写字母，并且在最前面加上一个反斜杠/，在最后加上".htm"。

    使用CommonsPathMapHandlerMapping元数据映射控制器：它是根据控制器源代码中的元数据决定如何进行URL映射。这个元数据特定是一个org.springframework.web.servlet.handler.commonsattributes.PathMap属性，是用Jakarta Commons Attributes编译器编译到控制器中。 要使用它，只要像下面这样简单地在上下文控制文件中定义一个Bean就可以了：

    <bean id="urlMapping" class="org.springframework.web.servlet.handler.metadata.CommonsPathMapHandlerMapping" />

    控制器源代码注释标签中的PathMap属性声明了这个控制处理的URL样式。例如，为了将HomePageController映射到"/home.htm"，HomePageController的标签是这样的：

    /**

     * @@org.springframework.web.servlet.handler.commonsattributes.PathMap("/home.htm")

    */

    public class HomePageController extends AbstractController {

     ......

    }  最后，编译的时候需要将Commons Attributes编译器放进来，这样标签PathMap 才能被编译到应用代码中。要详细了解如何在Ant 或Maven中设置Commons Attributes编译器，请参考Commons Attributes 主页(http://jakarta.apache.org/commons/attributes)。

    使用多映射处理器：所有的处理器映射类都实现了Spring的Ordered接口。这意味着你可以在应用系统中声明多个处理器映射，并且设置哪个相对另一个有优先权。例如，假设想在一个应用系统中并排使用BeanNameUrlHandlerMapping和SimpleUrlHandlerMapping。你需要像下面这样声明处理器映射Bean:

    <bean id="beanNameUrlMapping" class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping">

      <property name="order">

        <value>1</value>

      </property>

    </bean>

    <bean id="simpleUrlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">

      <property name="order"><value>0</value> </property> 

      <property name="mappings">

       ...

      </property>

    </bean>

    注意，order属性的值越小，优先级越高。

  用控制器处理请求：如果DispatcherServlet是Spring MVC的心脏，那么控制器就是它的大脑。Spring控制器与Struts/web work action相比有一个重要的区别。这就是，相比Struts或Web Work比较平坦的Action层次，Spring提供了丰富的控制器层（见PPT5）在控制器层次的最上面是接口Controller，任何实现这个接口的类都可以用来处理Spring MVC框架传递过来的请求。要创建自己的控制器，你必须要做的就是实现这个接口。Spring让你选择最适合自己需要的控制器（见PPT6）Spring控制器可以归为6种类型，沿着表格向下，功能越来越多，除了ThrowawayController，顺着控制器类层次向下，每个控制器都是建立在它上面的控制器基础之上的。

  • 处理命令：当控制器需要根据参数执行工作时，应该继承命令控制器，如AbstractCommandController（见PPT7）这个控制器会自动将参数绑定到命令对象中，并且提供了插入验证器的钩子，确保参数合法性。下面显示了RantsForVehicleController，一个用于显示特定车辆已有投诉列表的命令控制器。

    public class RantsForVehicleController  extends AbstractCommandController{

    public RantsForVehicleController() {

    setcommandClass(Vehicle.class);

    setCommandName("vehicle");

    }

    protected ModelAndView handle(HttpServletRequest request,HttpServletResponse,Object command,

    BindException errors) throws Exception {

           Vehicle vehicle = (Vehicle) command;

           List vehicleRants = rantService.getRantsForVehicle(vehicle);

           Map model =errors.getModel();

           model.put("rants", rantService.getRantsForVehicle(vehicle));

           model.put("vehicle", vehicle);

            return new ModelAndView("vehicleRants",model);

     }

    private RantService rantService;

    public void setRantService(RantService rantService) {

    this.rantService = rantService;

     }

    }

    一个命令对象是一个为了简化对请求参数访问而设计的Bean。一个Spring命令对象是一个POJO，它不需要实现任何Spring的特定类。你需要在roadrantz-servlet.xml文件中注册RantsForVehicleController

    <bean id="rantsForVehicleController" class="com.roadrantz.mvc.RantsForVehicleController">

       <property name="rantService" ref="rantService"/>

    </bean>

    处理表单提交：表单控制器比命令控制器前进了一步，（见PPT8）它在接收到HTTP GET请求的时候显示一个表单，接收到一个HTTP POST请求的时候处理这个表单。另外，在处理过程中如果发生错误的话，这个控制器会知道重新显示这个表单，这样用户就可以修改错误，重新提交。为了显示表单控制器是如何工作的，考虑以下程序中的AddRantFormController。

    public class AddRantFormController extends SimpleFormController {

    private static final String[] ALL_STATES = {"AL","AK","AZ"};

       public AddRantFormController() {

       setCommandClass(Rant.class);

       setCommandName("rant");

       }

       protected Object formBackingObject(HttpServletRequest request) throws Exception {

       Rant rantForm = (Rant)super.formBackingObject(request);

       rantForm.setVehicle(new Vehicle());

       }

       protected Map referenceDate(HttpServletRequest request) throws Exception{

       Map referenceData = new HashMap();

       referenceDate.put("states",ALL_STATES);

       return referenceData;

       }

       protected ModelAndView onSumbit(Object command,BindException bindException)throws Exception{

       Rant rant = (Rant)command;

       rantService.addRant(rant);

       return new ModelAndView(getSuccessView());

       }

       private RantService rantService;

    public void setRantService(RantService rantService) {

    this.rantService = rantService;

    }

    }虽然referenceData()方法是可选的，但是如果需要为 显示表单提供其他附加的信息，则可以使用这个方法。在正常的情况下，返回表单的命令对象一般是一个简单的命令类实例。不过对于AddRantFormController,Rant实例不会完成这项工作。表单会使用内嵌的Vehicle属性作为表单返回对象的一部分。因此，需要覆盖fromBackingObject()方法，以便设置vehicle属性。否则，在控制器视图绑定state和plateNumber属性时，会抛出NullPointerException异常。

         那么控制器是如何知道显示投诉输入表单的。如果投诉输入成功，用户将到什么页面也不是很清楚。唯一的线索是对getSuccessView(）的调用结果会提交给ModelAndView。但是，提交成功的视图又从哪里来呢？SimpleFormController被设计成尽量将视图详细信息放在控制器代码之外。不是将ModelAndView对象硬编码进来，而是像下面这样在上下文配置文件中配置控制器：

    <bean id="addRantController" class="com.roadrantz.mvc.AddRantFormController">

         <property name="formView"  value="addRant" />

         <property name="successView" value="rantAdded" />

         <property name="rantService" ref="rantService" />

    </bean> formView属性是控制器接收到HTTP GET请求或有任何错误发生时需要显示的视图的逻辑名。同样，successView是提交的表单成功处理后要显示的视图的逻辑名。

    验证表单输入：org.springframework.validation.Validator接口为Spring MVC提供了验证功能，定义如下：

    public interface Validator {

        void validate(Object obj  , Errors errors);

        boolean supports(Class clazz);

    }这个接口的实现必须验证传递给validate()方法的对象的字段，用Errors对象驳回任何非法数据。supports()方法用于帮助Spring判断该验证器是否可以用于指定类。 以下是一个用于验证Rant对象的Validator实现。

    public class RantValidator implements Validator {

      public boolean supports(Class clazz){

      return clazz.equals(Rant.class);

      }

      public void validate(Object command, Errors errors) {

      Rant rant = (Rant) command;

      ValidationUtils.rejectIfEmpty(errors,"vehicle.state","required.state","State is required");

      ValidationUtils.rejectIfEmptyOrWhitespace(errors, "rantText", "required.rantText","You must enter some rant text.");

          validatePlateNumber(rant.getVehicle().getPlateNumber(),errors);

      }

      private static final String PLATE_REGEXP = "/[a-z0-9]{2,6}/i";

      private void validatePlateNumber(String plateNumber,Errors errors) {

      Per15Util per15Util = new Per15Util();

      if(!per15Util.match(PLATE_REGEXP,plateNumber)){

      errors.reject("invalid.plateNumber","Invalid license plate number.");

      }

      }

    }还有一件事情要做，就是让AddRantFormController使用RantValidator。你可以将一个RantValidator Bean装配到AddRantFormController Bean中：

    <bean id="addRantController" class="com.roadrantz.mvc.AddRantFormController">

      <property name="formView" value="addRant"/>

      <property name="successView" value="rantAdded"/>

      <property name="rantService"  ref="rantService"/>

      <property name="validator">

         <bean class="com.roadrantz.mvc.RantValidator"></bean>

      </property>

    </bean>通过实现Validation接口，可以通过程序完全控制应用程序命令对象的验证。如果需要复杂的验证和特殊的逻辑，利用这项功能将会十分方便。对于简单的情况，例如保证填入需要的字段并按照基本格式，编写自己的Validator接口就有点麻烦了。声明性验证是一个不错的选择。

    利用命令验证器进行验证：在我们深入研究用于实现声明性Validator的Spring JavaDoc之前，需要知道Spring并不提供这样的验证器。Spring没有提供任何Validator接口的实现，而是将这个任务留给了程序员。 不过Spring Modules项目(http://springmodules.dev.java.net)是Spring的一个姊妹项目，提供了几个对Spring的扩展。其中一个是使用Jakarta Commons Validator(http://jakarta.apache.org/commons/validator)提供的声明性验证的验证模块。

         要使用验证模块，首先需要添加springmodules-validator,jar  如果使用Ant建立应用程序，需要下载Spring Modules发行包，找到spring-modules-0.6.jar文件，将这个JAR添加到<war>任务的<lib>中。如果使用Maven2建立应用程序，需要在pom.xml中添加下面的<dependency>:

    <dependency>

       <groupId>org.springmodules</groupId>

       <artifactId>springmodules-validation</artifactId>

       <version>0.6</version>

       <scope>compile</scope>

    </dependency>

     另外，还需要将Jakarta Commons Validator JAR添加到应用程序的classpath中，在Maven中，按如下所示：

    <dependency>

       <groupId>commons-validator</groupId>

       <artifactId>commons-validator</artifactId>

       <version>1.1.4</version>

       <scope>compile</scope>

    </dependency>

    Spring Module提供的Validator实现的名称为DefaultBeanValidator。DefaultBeanValidator需要按下面的方式配置在roadrantz-servlet.xml中：

    <bean id="beanValidator" class="org.springmodules.commons.validator.DefaultBeanValidator">

        <property name="validatorFactory" ref="validatorFactory"></property>

    </bean>

    DefaultBeanValidator并不做任何实际的验证工作，而是委派Commons Validator来验证字段的值。validatorFactory Bean需要使用下面的XML进行声明：

      <bean id="validatorFactory" class="org.springmodules.commons.validator.DefaultValidatorFactory">

        <property name="validationConfigLocations">

           <list>

              <value>WEB-INF/validator-rules.xml</value>

              <value>WEB-INF/validator.xml</value>

           </list>

        </property>

    </bean> validator-rules.xml文件包含了一组预定义的验证规则，可以应用于一般的验证需求。这个文件被包含在Commons Validator发行包中，因此，你不需要自己编写--值需要简单的将其添加到应用程序的WEB-INF目录中。（PPT9）中列出了validator-rules.xml中的所有验证规则。另一个文件validation.xml定义了应用程序制定的验证规则，可有直接应用于RoadRantz应用程序。下面展示了应用到RoadRantz的validation.xml

    <?xml version="1.0" encoding="UTF-8"?>

    <!DOCTYPE form-validation PUBLIC"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1

       //EN" "http://jakarta.apache.org/commons/dtds/validator_1_1.dtd" >

    <form-validation>

        <formet>

            <form>

               <field property="rantText" depends="required">

                  <arg0 key="required.rantText"/>

               </field>

               <field property="vehicle.plateNumber" depends="required,mask">

                 <arg0 key="invalid.plateNumber"/>

                 <var>

                    <var-name>mask</var-name>

                    <var-value>^[0-9A-Za-z]{2,6}$</var-value>

                 </var>

               </field>

            </form>

        </formet>

    </form-validation>

    最后一件要做的事情是改变控制器的声明，注入新的声明性Validate实现：

    <bean id="addRantController" class="com.roadrantz.mvc.AddRantFormController">

       <property name="formView" value="addRant" />

       <property name="successView" value="rantAdded" />

       <property name="rantService" value="rantService" />

       <property name="validator" value="beanValidator" />

    </bean>

      使用SimpleFormController的一个基本的原因是表单只有一页。

    用向导处理复杂表单：AbstractWizardFormController是Spring提供的功能最强大的控制器（见PPT10）它是一种特殊类型的表单控制器，它将多个页面中的表单数据聚集到一个用于处理的命令对象中。

    • 创建一个基本的向导控制器：构建一个向导控制器，它必须继承AbstractWizardFormController类，如下：

      public class MotoristRegistrationController extends AbstractWizardFormController {

        public MotoristRegistrationController() {

         setCommandClass(Motorist.class);

         setCommandName("motorist");

        }

        protected Object formBackingObject(HttpServletRequest request) throws Exception{

      Motorist formMotorist = new Motorist();

      List<Vehicle> vehicles = new ArrayList<Vehicle>();

      vehicles.add(new Vehicle());

      formMotorist.setVehicles(vehicles);

      return formMotorist;

        }

        protected Map referenceData(HttpServletRequest request,Object command,Errors errors,int page)

         throws Exception{

      Motorist motorist = (motorist) command;

      Map refData = new HashMap();

          if(page==1 && request.getParameter("_target1")!= null){

           refData.put("nextVehicle", motorist.getVehicles().size()-1);

          }

          return refData;

         }

        protected void postProcessPage(HttpServletRequest request,Object command,Errors errors,int page)throws Exception {

      Motorist motorist = (Motorist)command;

      if(page==1 && request.getParameter("_target1")!= null){

          motorist.getVehicles().add(new Vehicle());

         }

        }

        protected ModelAndView  processFinish(HttpServletRequest request,HttpServletResponse response,

        Object command,BindException errors)throws Exception {

      Motorist motorist = (motorist) command;

      // the last Vehicle is always blank...remove it

      motorist.getVehicles().remove(motorist.getVehicles().size()-1);

      rantService.addMotorist(motorist);

      return new ModelAndView(getSuccessView(),"motorist",motorist);

        }

        //inject

        private RantService rantService;

        public void setRantService(RantService rantService) {

      this.rantService = rantService;

        }

        //returns the last page as the success view

        private String getSuccessView() {

        return getPages()[getPages().length-1];

        }

      }

      AbstractWizardFormController的唯一一个必须实现的方法是processFinish()。在用户完成表单后(一般是点击完成按钮),这个方法被调用，完成整个表单。 但是AbstractWizardFormController是如何知道哪些页面构成了整个表单呢？

      <bean id="registerMotoristController" class="com.roadrantz.mvc.MotoristRegistrationController">

         <property name="rantService" ref="rantService" />

         <property name="pages">

            <list>

              <value>motoristDetailForm</value>

              <value>motoristVehicleForm</value>

              <value>motoristConfirmation</value>

              <value>redirect:home.htm</value>

            </list>

         </property>

      </bean>这样向导就知道了哪些页面构成了表单，一个视图逻辑名列表设置给了pages属性。这些名字最终被视图解析器解析成了一个个视图对象。但现在，只要假设这些名字会被解析成JSP文件名就可以了。

      分步显示表单页面：任何向导控制器显示的第一个页面都是pages属性中列表的第一个页面。AbstractWizardFormController询问它的getTargetPage()方法。这个方法返回一个整数，它是pages属性中设置的页面列表的索引值(以0为基数)。getTargetPage()方法的默认实现是根据请求中的一个参数来决定下一步是哪个页面，这个参数以"_target"开头，以数字结尾。知道了getTargetPage()的工作原理有助于你知道如何在向导HTML页面中构造下一步和上一步按钮。例如，假设用户在"motoristVehicleForm"页面上(索引=1)。要在这个页面上创建下一步和上一步按钮，你要做就是创建提交按钮，它的名字是以"_target"开头：

      <form>

      ...

        <input type="submit" value="Back" name="_target0">

        <input type="submit" value="Next" name="_target2">

      </form>getTargetPage()方法的默认实现对于大多数项目已经够用了。然后，如果你喜欢为你的向导定义自己的工作流程的话，你可以覆写这个方法。

      完成向导：还有一个特殊请求的参数"_finish"，和"_targetX"参数一样，它可以被用于在页面上创建一个结束按钮：

      <form method="POST" action="feedback.htm">

      ...

        <input type="submit" value="Finish" name="_finish">

      </form>

      当AbstractWizardFormController看到请求中的"_finish"参数时，它会将控制权交给processFinish()方法，让它对表单做最后的处理。与其他表单控制器不同，AbstractWizardFormController不提供用于设置成功视图页面的内容。因此，我们在MotoristRegisttrationController中添加了一个getSuccessView()方法返回页面列表中的最后一个页面。所以，当表单已完成的方式提交时，processFinish()方法会返回一个带有视图的ModelAndView,这个视图就是页面列表中的最后一个视图。

      取消向导：如何用户完成了部分注册，决定不再继续完成，除了选择直接关闭浏览器外，还有另一种选择，你可以在表单上添加一个取消按钮。

      <form method="POST" action="feedback.htm">

      ...

         <input type="submit" value="Cancel" name="_cancel">

      </form>

      取消按钮以"_cancel"作为它的名字，当用户按下取消按钮，浏览器将一个叫做"_cancel"的参数放到请求中。AbstractWizardFormController接收到这个参数，将控制权交给processCancel()方法。 默认情况下此方法会抛出异常，表示取消操作是不被支持的，我们要覆写这个方法，将用户带到你想让他们点击取消时看到的页面。下面processCancel()方法的实现将用户带领到成功视图。

      protected ModelAndView processCancel(HttpServletRequest   request,   HttpServletResponse   response, Object command,  BindException  bindException)  throws Exception {

           return new ModelAndView(getSucessView()) ;

      }

      每次验证一个向导表单：使用其他类型的命令控制器，命令对象只装载一个次。但使用向导控制器，用户每完成向导页面中的一步，都会有一个命令对象设置进来。使用向导，只做一次验证是不可行的，太早的话，找到的验证问题可能是由于用户没有完成向导而导致的。太晚的话，在完成按钮被按下后再做检查就太迟了，因为发现的问题可能越过了多个页面(用户该回到哪个页面呢？)   向导控制器在每个页面验证一次命令对象，不是只验证一次。这是通过每次页面跳转时调用validatePage()方法实现的。validatePage()方法的默认实现是空的（也就是没有验证），但是你可以覆写这个方法，做出自己的判断。 假设在motoristDetailForm页面，询问用户的邮件地址，这个字段是可选的，但是如果输入了值，必须输入一个合法的E-mail地址。下面的validatePage(）方法展示了用户从motoristDetailForm页面跳转出来的时候如何验证E-mail地址。

      protected void validatePage(Object  command,  Errors  errors, int page ) {

          Motorist  motorist =  (Motorist)  command;

          Motorist Validator  validator  = (MotoristValidator) getValidator();

          if(page == 0){

           validator.validateEmail(motorist.getEmail() , errors );

        }

      }  这里可以直接在validatePage()方法中检查E-mail。然后，向导一般有好几项字段需要验证。如果这样的话，validatePage(）方法会变得很笨拙。我们建议你将验证任务委托给控制器的验证器对象的字段级验证方法，就像我们在这里调用MotoristValidator的validateEmail()方法一样。  这意味着当你配置控制器的时候，你要设置validator属性：

      <bean id="registerMotoristController" class="com.roadrantz.mvc.MotoristRegistrationController">

         <property name="rantService" ref="rantService" />

         <property name="pages">

            <list>

              <value>motoristDetailForm</value>

              <value>motoristVehicleForm</value>

              <value>motoristConfirmation</value>

              <value>redirect:home.htm</value>

            </list>

         </property>

         <property name="validator">

            <bean class="com.roadrantz.mvc.MotoristValidator" />

         </property>

      </bean>

      一个需要注意的重要事项是，不像其他命令控制器，向导控制器从不调用它们的验证器对象的标准validate()方法。这是因为validate()方法验证整个命令对象，然而在向导中命令对象将在每个页面验证一次。

    使用一次性控制器：一次性控制器比其他控制器简单很多，ThrowawayController接口可以证明：

    public interface  ThrowawayController {

          ModelAndView execute() throws Exception ;

    }

    ThrowawayController接口和Controller接口不在同一个体系里。一次性控制器自己作为自己作为自己的命令对象，而不是通过一个HttpServletRequest或一个命令对象获得参数。与WebWork Action相似，都是以同样的方式工作。我们将RantsForController实现为ThrowawayController：

    public class RantsForDayController implements ThrowawayController{

       private Day day;

       public ModelAndView execute() throws Exception {

          List<Rant>  dayRants = rantService.getRantsForDay(day);

          return new ModelAndView("dayRants","rants",dayRants);

       }

       public void setDay(Date day){

       this.day = day;

       }

       private RantService rantSrvice;

    public void setRantSrvice(RantService rantSrvice) {

    this.rantSrvice = rantSrvice;

      }

    } 你必须在DispatcherServlet的上下文配置文件中声明一次性控制器。只有一点很小的不同：

    <bean id="rantsForDayController" class="com.roadrantz.mvc.RantsForDayController" scope="prototype">

          <property name="rantService" ref="rantService">

    </bean> scope属性已经被设置为prototype。这就是一次性控制器获取它们名字的地方。默认情况下，所有的Bean都是Singleton。 但是因为ThrowawayContoller和Controller不处于同一继承层次，DispatcherServlet不知道如何通知ThrowawayController。所以你必须告诉DispathcerServlet使用一种不同的 处理适配器。确切的说，你必须像下面这样配置ThrowawayControllerHandlerAdapter:

      <bean id="throwawayHandler" class="org.springframework.web.servlet.mvc.throwaway.ThrowawayControllerHandlerAdapter" />

    如果应用程序既使用了常规控制器又使用了一次性控制器，你还应该按如下方式声明SimpleControllerHandleAdapter:

     <bean id="simpleHandler"  class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" />

    声明两处理器适配器使你可以在用一个应用程序中混合使用两种类型的控制器。

  处理异常：当异常从控制器中跑出来时，SimpleMappingExceptionResolver负责营救。

  <bean id="exceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">

     <property name="exceptionMappings">

         <props>

             <prop key="java.lang.Exception">friendlyError</prop>

         </props>

     </property> 

  </bean>

     exceptionMappings属性取得一个java.util.Properties，它映射了异常类名和逻辑视图名。在本例中，基础异常类被映射到逻辑名为friendlyError的视图上，这样如果有任何异常抛出的话，用户不会在浏览器中看到一串晦涩的堆栈跟踪信息。

在persistence.xml中加上<property name="hibernate.hbm2ddl.auto" value="update" />或设置在Spring配置中，在Spring 的sessionFactory中设置，当运行Spring时会自动生成Table

<!--applicationContext.xml-->

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd"
    xmlns:tx="http://www.springframework.org/schema/tx">


    <bean id="entityManagerFactory"
        class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
        <property name="persistenceUnitName" value="onlinephotoPU" />
    </bean>
    <bean id="transactionManager"
        class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory"
            ref="entityManagerFactory" />
    </bean>

    <bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://127.0.0.1:3306/photo" />
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="annotatedClasses">
            <list>
                <value>com.tst.Person</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">
                    org.hibernate.dialect.MySQLInnoDBDialect
                </prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">create-drop</prop>
            </props>
        </property>
    </bean>
    <tx:annotation-driven transaction-manager="transactionManager" />
    <bean id="PersonDAO" class="com.tst.PersonDAO">
        <property name="entityManagerFactory"
            ref="entityManagerFactory" />
    </bean>
</beans>

<!--persistence.xml-->
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
    http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0">
   
    <persistence-unit name="onlinephotoPU"
        transaction-type="RESOURCE_LOCAL">
        <provider>org.hibernate.ejb.HibernatePersistence</provider>
        <class>com.tst.Person</class>
        <properties>
            <property name="hibernate.connection.driver_class"
                value="com.mysql.jdbc.Driver" />
            <property name="hibernate.connection.url"
                value="jdbc:mysql://127.0.0.1:3306/photo" />
            <property name="hibernate.connection.username" value="root" />
            <property name="hibernate.connection.password" value="root" />
            <property name="hibernate.hbm2ddl.auto" value="update" />
        </properties>
    </persistence-unit>
</persistence>

Log4J 是如何进行工作的？

这是在 Log4J 项目中对 Log4J 的介绍中的一段话

With log4j it is possible to enable logging at runtime without modifying the application binary. The log4j package is designed so that these statements can remain in shipped code without incurring a heavy performance cost. Logging behavior can be controlled by editing a configuration file, without touching the application binary.

对于 Log4J 的具体如何进行工作的原理，在 javaeye 上 buaawhl 给出了一个解释：

http://buaawhl.javaeye.com/blog/6450

总结一下就是利用 JDK 提供的 new Throwable().getStackTrace() 方法返回当前运行栈的结构层次，然后对返回的调用栈的信息进行分析，找到调用该类的类的名称。（也就是Log4J自己说的Runtime期间实现Log）

由于在 Log4J 中只存在一个根 Logger ，并且 Logger 之间存在继承的关系，并且我们可以在配置文件（ log4J.proerties 或者 XML ）中进行配置，可以初始化指定的 Logger ，并且对指定的 Logger 进行一些相关的配置，如设置如何进行输出，以及如何将输出进行布局。并且由于 Logger 之间会存在继承的关系（会找一个最近的 Logger 进行继承，如果没有就以根 Logger 作为父类，共享父类的配置信息），以及父子类之间初始化没有先后的顺序，所以我们可以在配置文件中，对各个程序以及不同的包中使用到 Log4j 的 Log 纪录方式进行配置。

如果在同一个 APPLICATION 对相同名称的 Logger 进行调用，那么只会返回一个 Logger 实例。

Log4J 会不会对系统的性能造成大的影响？

这是对 Log4J 性能的一些描述，看来还是不错的，呵呵，在调整一下 Log 的等级就可以了。

On an AMD Duron clocked at 800Mhz running JDK 1.3.1, it costs about 5 nanoseconds to determine if a logging statement should be logged or not. Actual logging is also quite fast, ranging from 21 microseconds using the SimpleLayout, 37 microseconds using the TTCCLayout. The performance of the PatternLayout is almost as good as the dedicated layouts, except that it is much more flexible.

注：对于 Common Logging 和 Log4J 的关系可以参见 （其实 JCL 是一个规范，对一些 Log 工具进行了包装，我们常会使用到的具体实现还是 Log4j ，当然也可以使用其他的实现）

http://hedong.3322.org/archives/000316.html

参考资料：

http://www-128.ibm.com/developerworks/cn/java/l-log4j/index.html 使用 Log4J 进行日志操作

http://zooo.51.net/heavyz_cs/notebook/log4j.html Log4J 学习笔记（推荐）

http://www.dingl.com/view.shtml?xh=485 log4j 配置

http://hedong.3322.org/archives/000193.html 竹笋炒肉的 Log4J 学习笔记

http://forum.springside.org.cn/redirect.php?fid=3&tid=382&goto=nextoldset SpringSide 对 Log4j 的使用要点

一、spring+hibernate时使用hibernate的延迟加载功能时存在的问题：

spring是一个设计层面的框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring的orm框架用来集成其他持久层框架，比如hibernate，spring-orm框架对hibernate的session进行了封装，我们可以很方便的通过继承这个封装类HibernateDAOSupport并注入hibernate的sessionFactory完成初始化，并调用其内置对象HibernateTemplate的封装方法来调用session的API而不用考虑到session的初始化和关闭以及事务处理等系统操作，这也是AOP思想的一种体现。Hibernate的延迟加载功能是指获取某个实体对象时并不从数据库中加载他的关联对象，而在实际获取关联对象的时候才从数据库中加载，这样做很好的节省了数据库资源但是前提是必须保持session处于打开状态，在所有操作完成后再关闭。Spring封装了session操作后很自然的要做到在方法调用的前后打开和关闭session，这样我们在通过HibernateTemplate的方法来获取实体对象以后session就已经关闭了，而这时候在调用获取关联对象的方法的时候就会抛出异常：

二、如何解决

 1、openSessionInViewInterceptor

通过spring的控制层框架spring-mvc来处理控制层并通过拦截器openSessionInViewInterceptor改变spring调用session的流程。这里介绍最简单的spring-mvc的使用方法，首先和struts一样要定义一个HttpServlet来总体控制请求的处理类以及容器的初始化，struts是ActionServlet，Spring是DispatcherServlet，如图：

如同struts的控制器都继承于Action类一样，spring的控制器都要实现controller接口

我们通过注入的方式传入usersDAO进行数据操作（通常这个操作应该是放到Service层，这里为了方便讲解没有加入Service层），这个DAO是myeclipse自动生成的原封不动，这里不再贴出来了。

几句话的意思很清楚，调用findByID方法把ID为1000的用户实体查出来，这个时候按道理session已经关闭了，下面调用user.getNewses方法获取这个用户发布的新闻信息的一个set集合，打印条数，系统显示：

没有报session 已经关闭的错误，原因是spring-config中作了配置，在配置之前我们要对spring-mvc做一些初步的了解。

配合DispatcherServlet我们也要定义相关的映射，能够将请求跳转到对应的控制器，先看看usersDAO

然后是我们的控制器LoginSpring，这里没有对跳转作处理，因为我们的重点不是mvc而是解决延迟加载。

最后是我们的映射和针对这些控制器所配置的拦截器opensessioninviewinterceptor

这样配置了以后管理session的就不是我们的hibernatetemplate了而是我们配置的拦截器，他会保持session直到我们的控制器做完了所有的事情才关闭，也就是我们调用user.getNewses方法的时候是打开的，因此能得到满意的结果。

2、openSessionInViewFilter

当我们的系统的控制层要使用struts的时候，我们就不能使用spring的拦截器了，因个这个拦截器是基于DispatcherServlet的，我们只有在web.xml中配置过滤器来改变session的流程。首先简要介绍一下struts+spring集成，看看struts的配置文件：

每个Action的type都设定为org.springframework.web.struts.DelegatingActionProxy，并在最下面配置spring的配置文件的路径，当我们要使用过滤器的时候这个配置文件必须只存放Action的实际映射，下面是spring-action.xml，里面只有一个action：

这里不需要指定id，只需要指定别名，这个别名会自动匹配struts配置文件中对应的path, DelegatingActionProxy会自动从插件所配置的spring配置文件中寻找匹配的bean并实例化，当然也会完成注入的过程。知道怎么将两个框架正和使用以后，我们来配置过滤器，见web.xml：

这里使用过滤器的时候一定要附上所有spring配置文件并在web容器(tomcat)启动时加载和初始化。这里spring-action.xml存放的Struts的Action的映射，spring-config.xml中存放其他的bean。

最后再看看这个Action，和上面的一样的代码。

这样的话当我们使用延迟加载的时候调用的就是HibernateTamplate的代理类，能够让Spring在请求开始的时候打开Session，响应结束前关闭Session，这样就不会存在Session关闭的错误了。但是当我们增删改的时候，又会出现下面的问题：

为什么会有这样的问题呢，因为Hibernate有自己的事务策略，我们在Spring的OpenSessionInView中打开Session是以只读的方式来管理事务，这样进行增删改的时候就会出现错误。如何解决，先看看Spring的事务处理。

三、声明式事务处理

声明式事务处理是springAOP思想的一个扩展，事务处理是一个典型的系统功能，因此通过将事务处理封装在一个切面中进行处理以分离具体业务操作和系统功能的方式是最好的设计层面的选择。

首先我们要配置一个PlatformTransactionManager接口的一个实现用来控制事务流程（commit和rollback），如果我们是spring+hibernate，框架集成的话，我们就要配置hibernate专用的PlatformTransactionManager实现:

我们模拟一个实例就是两个银行之间的转账，MsBankDAO民生银行DAO；ZsBankDAO招商银行DAO。这两个DAO都是用myeclipse生成，这里不作介绍，我们的业务逻辑对象BankBO的transferMoney方法来完成这个转账操作：

其中if语句中的两个操作就是一个典型的粗粒度事务，我们使用声明的方式来进行事务处理就无需在这里面加入任何关于事务的代码。

既然是使用AOP代理BO，我们就得有一个BankBOImpl的代理类：

然后我们模拟一个事故：

将民生银行的修改方法抛出一个错误

我们要传入被代理类的接口以及实现，建一个主函数来测试一下：

注意这里要通过代理类boProxy来返回BankBO的一个临时实现，运行结果：

在查看数据库中的数据并没有改变。

四、解决ReadOnly事务策略问题

继续第二节我们的问题，Hibernate的事务策略是需要配置的，Spring为了能以AOP的方式来管理事务，就必须提供Hibernate事务策略和事务操作的封装，也就是我们上面提供的PlatFormTransactionManager接口的Hibernate持久层实现HibernateTransactionManager，

Spring在处理事务的时候会将这个底层的封装体传到TransactionTemplate进行初始化事务处理流程和参数，我们在看HibernateTeamplat是我们所熟知的Hibernate的Session的API的封装，他的父类HibernateAccessor中已经定义好了5种Hibernate的事务策略，其中就有Flush_NEVER策略和FLUSH_AUTO等策略，如果我们平时增删改的时候没有用到HibernateTamplate就会在操作的时候由Hibernate来管理事务，但这个时候由于Opensessioninview的缘故为了防止在延迟加载的时候改动持久层刷新策略已经被设定为Flush_Never，也就是说增删改的时候也会以只读的刷新模式来处理，这当然会报错，按照异常所说的要把前者换成后者就行了，但这样就没办法保证延迟加载的时候的安全性，因为很有可能这个PO对象会被传到View层被随意改动，如果能够在读的时候只读，在写的时候由能够及时刷新就能解决问题了，如果是编程式事务处理的话，我们就必须分别在查询和增删改的时候更换刷新模式，这将会很麻烦，还好Spring提供了声明式事务处理，提供了一种扩展性很高的解决方案。解决的方法很简单，让Spring来全权管理事务，在省事的同时也更好的划分了层次的关系，避免了Service层涉及事务策略这类的系统功能，将AOP思想体现的淋漓尽致。看看配置：

Find开头的方法被设定为只读，其他方法设定为auto（默认），让所有Service结尾的类的方法都处在事务中（包括不需要事务的方法），虽然消耗了一定的系统资源，但却让我们不必再为事务的问题操心，把精力集中到业务逻辑中。

1、 把上面的type换成type=”org.springframework.web.struts.DelegatingActionProxy”

 2、 并且在struts-config.xml中加入：  

<plug-in

              className="org.springframework.web.struts.ContextLoaderPlugIn">

              <set-property property="contextConfigLocation"

                     value="/WEB-INF/classes/applicationContext.xml" />

       </plug-in>

 作用是方便spring来管理

3、在applicationContext中加入：

  <bean name="/person" class="org.lxh.struts.action.PersonAction">

            <property name="persondao">

                   <ref bean="persondao"/>

            </property>

     </bean>

第二种实现：

 不用改变Action中的type

 在struts-config.xml中加入

<controller

              processorClass="org.springframework.web.struts.DelegatingRequestProcessor">

</controller>

àapplicationContext:

<beans>

       <bean id="dataSource"

              class="org.springframework.jdbc.datasource.DriverManagerDataSource">

              <property name="driverClassName">

                     <value>org.gjt.mm.mysql.Driver</value>

              </property>

              <property name="url">

                     <value>jdbc:mysql://localhost:3306/mldn</value>

              </property>

              <property name="username">

                     <value>root</value>

              </property>

              <property name="password">

                     <value>mysqladmin</value>

              </property>

       </bean>

       <bean id="def" class="cn.mldn.lxh.demo11.DefaultTemplate">

              <property name="jt">

                     <ref bean="template"/>

              </property>

       </bean>

       <bean id='template'

              class="org.springframework.jdbc.core.JdbcTemplate">

              <property name="dataSource">

                     <ref bean="dataSource"/>

              </property>

       </bean>

</beans>

à DefaultTemplate

public class DefaultTemplate {

       private JdbcTemplate jt;

       public void insert(Person person) {

              String sql = "INSERT INTO person(name,password) VALUES (?,?)";

              // 全部的值应该变为对象数组

              Object params[] = new Object[] { person.getName(), person.getPassword() };

              int type[] = new int[] { Types.VARCHAR, Types.VARCHAR };

              jt.update(sql, params, type);

       }

       public void update(Person person) {

              String sql = "UPDATE person SET name=?,password=? WHERE id=?";

              Object params[] = new Object[] { person.getName(),

                            person.getPassword(), new Integer(person.getId()) };

              int type[] = new int[] { Types.VARCHAR, Types.VARCHAR, Types.INTEGER };

              jt.update(sql, params, type);

       }

       public Person getPerson(int id) {

              final Person per = new Person();

              String sql = "SELECT id,name,password FROM person WHERE id=?";

              Object[] params = new Object[] { new Integer(id) };

              jt.query(sql, params, new RowCallbackHandler() {

                     public void processRow(ResultSet rs) throws SQLException {

                            per.setId(rs.getInt(1));

                            per.setName(rs.getString(2));

                            per.setPassword(rs.getString(3));

                     }

              });

              return per;

       }

       public int getCount() {

              final Person per = new Person() ;

              String sql = "SELECT COUNT(id) FROM person";

              Object[] params = new Object[] {};

              jt.query(sql, params, new RowCallbackHandler() {

                     public void processRow(ResultSet rs) throws SQLException {

                            per.setCount(rs.getInt(1)) ;

                     }

              });

              return per.getCount();

       }

       public List queryAll() {

              final List<Person> all = new ArrayList<Person>();

              String sql = "SELECT id,name,password FROM person";

              Object[] params = new Object[] {};

              jt.query(sql, params, new RowCallbackHandler() {

                     public void processRow(ResultSet rs) throws SQLException {

                            Person per = new Person();

                            per.setId(rs.getInt(1));

                            per.setName(rs.getString(2));

                            per.setPassword(rs.getString(3));

                            all.add(per);

                     }

              });

              return all;

       }

       public List<Person> queryAll(int currentPage, int lineSize) {

              final List<Person> all = new ArrayList<Person>();

              String sql = "SELECT id,name,password FROM person LIMIT "

                            + (currentPage - 1) * lineSize + "," + lineSize;

              Object[] params = new Object[] {};

              jt.query(sql, params, new RowCallbackHandler() {

                     public void processRow(ResultSet rs) throws SQLException {

                            Person per = new Person();

                            per.setId(rs.getInt(1));

                            per.setName(rs.getString(2));

                            per.setPassword(rs.getString(3));

                            all.add(per);

                     }

              });

              return all;

       }

       public void delete(int id) {

              String sql = "DELETE FROM person WHERE id=?";

              Object params[] = new Object[] { new Integer(id) };

              int type[] = new int[] { Types.INTEGER };

              jt.update(sql, params, type);

       }

       public JdbcTemplate getJt() {

              return jt;

       }

       public void setJt(JdbcTemplate jt) {

              this.jt = jt;

       }

}

àOpenSessionInViewFilter

* 这是为了避免Hibernate的懒加载异常而创建的解决方案

* 它是一个过滤器，能够让Session在请求解释完成之后再关闭（所以才能够避免懒加载异常）

* 配置方式是，在web.xml中定义过滤器即可：

   <filter>

      <filter-name>hibernateFilter</filter-name>

<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>

   </filter>

   <filter-mapping>

      <filter-name>hibernateFilter</filter-name> 

      <url-pattern>/*</url-pattern>

   </filter-mapping>

àCharacterEncodingFilter

* 如何提交中文字符？

* 配置web.xml了，Spring提供了专门的针对Encoding的过滤器

* 配置方法如下：

   <filter>

       <filter-name>Spring character encoding filter</filter-name>

       <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

       <init-param>

             <param-name>encoding</param-name>

             <param-value>GBK</param-value>

       </init-param>

   </filter>   

   <filter-mapping>

       <filter-name>Spring character encoding filter</filter-name>

       <url-pattern>/*</url-pattern>

   </filter-mapping>

缺陷：依赖了UserManager

原理：在Action中取得BeanFactory对象，然后通过BeanFactory获取业务逻辑对象

1、spring和struts依赖库配置

   * 配置struts

      --拷贝struts类库和jstl类库

      --修改web.xml文件来配置ActionServlet

      --提供struts-config.xml文件

      --提供国际化资源文件

   * 配置spring

      --拷贝spring类库

      --提供spring配置文件

2、在struts的Action中调用如下代码取得BeanFatory

BeanFactoryfactory=WebApplicationContextUtils.getRequiredWebApplicationContext(request.getSession.getServletContext())

3、通过BeanFactory取得业务对象，调用业务逻辑方法

在web.xml中做如下配置

<context-param>

    <param-name>contextConfigLocation</param-name>

<param-value>classpath*:applicationContext-*.xml,/WEB-INF/applicationContext-*.xml</param-value>  变色部分如果已经在CLASSPATH中配置了可省略

 </context-param>

 <listener>   <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

  </listener>

servletConetext的一个助手类，可以读取它àWebApplicationContextUtils

Spring &Hibernate集成方案2

原理：将业务逻辑对象通过spring注入到Action中，从而避免了在Action类中的直接代码查询。

1、spring和struts依赖库配置

   * 配置struts

      --拷贝struts类库和jstl类库

      --修改web.xml文件来配置ActionServlet

      --提供struts-config.xml文件

      --提供国际化资源文件

   * 配置spring

      --拷贝spring类库

      --提供spring配置文件

2、因为Action需要调用业务逻辑方法，所以需要在Action中提供setter方法，让spring将业务逻辑注入过来

3、在struts-config.xml文件中配置action

* <action>标签中的type属性需要修改为org.springframework.web.struts.DelegatingActionProxy是一个Action,主要作用是取得BeanFactory,然后根据<action>中的path属性值到IOC容器中取得本次请求对应的Action

4、在spring配置文件中需要定义struts的Action，如：

   <bean name=”/login” class=”com.bjsxt.usermgr.actions.LoginAction” scope=”prototype”>

      <property name=”userManager” ref=”userManager”/>

   </bean>

l       必须使用name属性，name属性值必须和struts-config.xml文件中<action>标签的path属性值一致

l       必须注入业务逻辑对象

l       建议scope设置为prototype,这样就避免了struts Action的线程安全问题

在struts中应该修改为：

 <action path=”/login”

         Type=”org.springframework.web.struts.DelegatingActionProxy”

         Name=”loginForm”

         Scope=”request”

> 

</action>

在ApplicationContext中需要做如下修改：

   不能有id属性 而是改成name属性(路径应该和struts中的配置的action的path相同)

<bean name=”/login” class=”com.bjsxt.usermgr.action.LoginAction” scope=”prototype”>

 <property name=”userManager” ref=”userManagr”/> //变色部分代表从单实例变成多实例

</bean>

采用编程式事务

1、 getCurrentSession()与openSession()的区别？

* 采用getCurrentSession()创建的session会绑定到当前线程中，而采用openSession()创建的session则不会

* 采用getCurrentSession()创建的session在commit或rollback时会自动关闭，而采用openSession创建的session必须手动关闭

2、使用getCurrentSession()需要在hibernate.cfg.xml文件中加入如下配置：

* 如果使用的是本地事务（jdbc事务）

<property name=”hibernate.current_session_context_class”>thread</property>

* 如果使用的是全局事务（jta事务）

<property name=”hibernate.current_session_context_class”>jta</property>

采用声明式事务

声明式事务配置

     * 配置SessionFactory

     * 配置事务管理器

     * 事务的传播特性

     * 那些类哪些方法使用事务

2、编写业务逻辑方法

     * 继承HibernateDaoSupport类，使用HibernateTemplate类持久化，HibernateTemplate

       是Hibernate session的封装

* 默认的回滚是RuntimeException（包括继承RuntimeException的子类），普通异常不回滚

 * 在编写业务逻辑方法时，最好将异常一直往上抛出，在呈现层处理（struts）

 * spring的事务需要设置到业务方法上（事务边界定义到Facade类上），不要添加到Dao上

3、了解事务的集中传播忒性

     1、PROPAGATION_REQUIRED:如果存在一个事务，则支持当前事务。如果没有事务则开启。

     2、PROPAGATION_SUPPORTS:如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。

     3、PROPAGATION_MANDATORY:如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。

     4、PROPAGATION_REQUIRES_NEW:总是开启一个新的事务。如果一个事务存在，则将这个存在的事务挂起。

     5、PROPAGATION_NOT_SUPPORTED:总是非事务地执行，并挂起任何存在的事务。

     6、PROPAGATION_NEVER:总是非事务地执行，如果存在一个活动事务，则抛出异常。

     7、 PROPAGATION_NESTED:如果一个活动的事务存在，则运行在一个嵌套的事务中，如果没有活动事务，则按TransactionDefinition.PROPAGATION_REQUIRED属性执行

4、Spring事务的隔离级别

     1、 ISOLATION_DEFAULT: 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别。

     2、ISOLATION_READ_UNCOMMITTED:这是事务最低的隔离级别，它允许另外一个事务可以看到这个事务未提交的数据。

     3、ISOLATION_READ_COMMITTED：保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。

     4、ISOLATION_REPEATALBE_READ: 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻想读。它除了保证一个事务不能读取另外一个事务未提交的数据外，还保证了避免下面的情况产生（不可重复读）。

     5、ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不课重复读外，还避免了幻想读。

à

<!-- 配置sessionFactory -- >

<bean id=”sessionFacory”class=”org.springframework.orm.hibernate3.LocalSessionFactoryBean”>

<property name=”configLocation”>

    <value>classpath:hibernate.cfg.xml</value>

</property>

</bean>

<!-- 配置事务管理器-- >

<beanid=”transactionManager”class=”org.springframework.orm.hibernate3.HibernateTransactionManager”>

   <property name=”sessionFactory”>

    <ref bean=”sessionFactory”/>

</property>

</bean>

<!-- 配置事务的传播特性-- >

<tx:advice id=”txAdvice” transaction-manager=”transactionManager”>

     <tx:attributes>

         <tx:method name=”add*” propagation=”REQUIRED”/>

         <tx:method name=”del*” propagation=”REQUIRED”/>

         <tx:method name=”modify*” propagation=”REQUIRED”/>

         <tx:method name=” *” read-only=”true”/> //只读提高了性能         

</tx:attributes>

</tx:advice>

<!-- 哪些类的哪些方法参与事务-- >

<aop:config>

   <aop:pointcut id=”allManagerMethod” expression=”execution(* com.bjsxt.usermgr.manager.*.*(..))”/>

   <aop:advisor pointcut-ref=”allManagerMethod” advice-ref=”txAdvice”/>

</aop:config>

Aware相关接口，表示在Spring实例化Bean之前进行相关的调用

例如：准备工作-->打扫工作

BeanNameAware表示在Spring实例化Bean之前进行调用

ApplicationContextAware： 在Bean类被初始化之后，将会被注入ApplicationContext实例

//ApplicationContext实例由系统自动添加上去

   public void setApplicationContext (ApplicationContext arg0) throws BeansException {

}    

消息支持

ApplicationContext继承了MessageSource接口，用户可以直接使用

事件监听：

容器关闭

容器初始化

在Web中请求处理的时候

CGLIB

spring对AOP的支持

Asepect默认情况下不用实现接口，但对于目标对象（UserManagerImpl.java）,在默认情况下必须实现接口，如果没有实现接口必须引入CGLIB库

我们可以通过Advice中添加一个JoinPoint参数，这个值会由spring自动传入，从JoinPoint中可以取得参数值、方法名等等。

1、 如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP

2、 如果目标对象实现了接口，可以强制使用CGLIB实现AOP

3、 如果目标对象没有实现接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

à如何强制使用CGLIB实现AOP？

   *添加CGLIB库，SPRING_HOME/cglib/*.jar

   *在 spring配置文件中加入<aop:aspect-autoproxy proxy-target-class=”true”/>

JDK动态代理和CGLIB字节码生成的区别？

 *JDK动态代理只能对实现了接口的类生成代理，而不能针对类

 *CGLIB是针对实现代理，主要是对指定的类生成一个子类，覆盖其中的方法

因为是继承，所以该类或方法最好不要声明成final

AOP：面向切面编程

代理模式讲解AOP技术

   操作接口

代理实现 à真实实现

因为此代理类只能为一个接口的对象进行代理 à静态代理

能不能有一种方法可以为所有的类进行代理 à动态代理

Spring提供的一系列Advices接口

   |- BeforeAdvice

   |- AfterAdvice

主要操作是在配置上：applicationContext.xml 文件上

了解其作用：只关注于业务本身，而与其他业务无关

à尚学堂代码实例（spring-avi-152-014）：

public class SecurityHandler implements InvacationHandler {

   private Object targetObject;

   public Object newProxy(Object targetObject) {

   this.targetObject = targetObject;

   return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),

targetObject.getClass.getInterfaces(),

this);

}

Public Object invoke(Object proxy,Method method,Object[] args)throws Throwable {

   checkSecuity();

   Object ret = null;

 Try {

   ret = method.invoke(this.targetObject , args);

}catch(Exception e) {

   e.printStackTrace();

   throw new java.lang.RuntimeException(e);

}

 return ret;

}

 private void checkSecurtiy() {

   System.out.println(“------------checkSecurity()-----------”);

}

}

àSpring对 AOP的支持（采用Annotation的方式）

1、spring依赖库

* SPRING_HOME/dist/spring.jar

* SPRING_HOME/lib/Jakarta-commons/commons-logging.jar

* SPRING_HOME/lib/log4j-1.2.14.jar

*SPRING_HOME/lib/aspectj/*.jar

2、 采用Aspect定义切面

1、 在Aspect定义Pointcut和Advice

2、 启用AspectJ对Annotation的支持并且将Aspect类和目标对象配置到LOC容器中

注意：在这种方法定义中，切入点的方法是不是被执行的，它存在的目的仅仅是为了重用切入点即Advice中通过方法名引用这个切入点

AOP：

l       Cross cutting concern

l       Aspect

l       Advice（横切关注点的具体实现）

l       Pointcut（圈定了一个范围 ）

l       Joinpoint spring只支持方法级的Joinpoint

l       Weave

l       Target Object

l       Proxy

l       Introduction

à实例（spring-avi-152-016）：

/**

*定义Pointcut，Pointcut的名称就是allAddMethod,此方法不能有返回值和参数,只是一个标

*识

*

*Pointcut的内容是一个表达式，描述哪些对象的哪些方法（订阅Joinpoint）

*/

@Aspect

Public class SecurityHandle {

   @Pointcut(“execution(* add*(..)) || execution(*del*(..))”)    //第一个*表示返回值，第二个表示以add开头的所//有方法, ..表示所有参数

Private void allAddMethod() {}； //不会被调用，只是一个标识

/**

*定义Advice,标识在哪个切入点何处织入此方法

*

*/

@Before(“allAddMethod()”)

Private void checkSecurity() {

   System.out.println(“---------------------------checkSecurity()----------------------------”);

}

}

需要在applicationContext中加入：<aop:aspectj-autoproxy/> 启用对Annotation的支持

spring-avi-152-017

à静态文件配置方式

 <aop:config>

     <aop:aspect id=”” ref=””>

           <aop:pointcut id=”allAddMethod” expression=”execution(* com.bjsxt.spring.UserManager.add*(..))”/>

          <aop:before method=”” pointcut-ref=””/>

     </aop:apect>

 </aop:config>

àspring的JoinPoint只针对方法

public class SecurityHandler {

 private void args = joinPoint.getArgs();

   Object[] args = joinPoint.getArgs(); //取得方法的参数

 For (int i=0;i<args.length;i++) {

       System.out.println(args[i]);

}

System.out.println(joinPoint.getSignature().getName()); //得到方法签名

}

one-to-one 主键关联

数据库脚本：

-- 删除表

DROP TABLE idcard ;

DROP TABLE person ;

-- 创建表

CREATE TABLE person

(

       id VARCHAR(32) NOT NULL PRIMARY KEY ,

       name VARCHAR(20) NOT NULL ,

       age int

) ;

CREATE TABLE idcard

(

       id VARCHAR(32) ,

       serial VARCHAR(18) NOT NULL ,

       expiry int ,

       FOREIGN KEY(id) REFERENCES person(id) ON DELETE CASCADE

) ;

Person表的hbm配置：

<hibernate-mapping>

       <class name="org.lxh.hibernate.demo04.pojo.Person" table="person">

              <id name="id" type="java.lang.String">

                     <column name="id" length="32" />

                     <generator class="uuid.hex"></generator>

              </id>

              <property name="name" type="java.lang.String">

                     <column name="name" length="20" not-null="true" />

              </property>

              <property name="age" type="java.lang.Integer">

                     <column name="age" />

              </property>

              <one-to-one name="idCard"

                     class="org.lxh.hibernate.demo04.pojo.IDCard" cascade="all"

                     outer-join="true">

              </one-to-one>

       </class>

</hibernate-mapping>

IDCard表的hbm配置:

<hibernate-mapping>

       <class name="org.lxh.hibernate.demo04.pojo.IDCard" table="idcard">

              <id name="id" column="id" type="java.lang.String">

                     <generator class="foreign">

                            <param name="property">person</param>

                     </generator>

              </id>

              <one-to-one name="person"

                     class="org.lxh.hibernate.demo04.pojo.Person" constrained="true">

              </one-to-one>

              <property name="serial" type="java.lang.String">

                     <column name="serial" length="18" not-null="true" />

              </property>

              <property name="expiry" type="java.lang.Integer">

                     <column name="expiry" not-null="true" />

              </property>

       </class>

</hibernate-mapping>

à唯一外键关联

此例子为mang–to-one

-- 删除表

DROP TABLE person ;

DROP TABLE tgroup ;

-- 创建表

CREATE TABLE person

(

       id VARCHAR(32) PRIMARY KEY NOT NULL ,

       name VARCHAR(20) NOT NULL ,

       age INT ,

       gid VARCHAR(32)

) ;

CREATE TABLE TGROUP

(

       gid VARCHAR(32) PRIMARY KEY NOT NULL,

       name VARCHAR(20)

) ;

commit ;

àPerson.hbm.xml

<hibernate-mapping>

       <class name="org.lxh.hibernate.demo05.pojo.Person" table="person">

              <id name="id" type="java.lang.String">

                     <column name="id" length="32" />

                     <generator class="uuid.hex"></generator>

              </id>

              <property name="name" type="java.lang.String">

                     <column name="name" length="20" not-null="true" />

              </property>

              <property name="age" type="java.lang.Integer">

                     <column name="age" />

              </property>

              <many-to-one name="tgroup"

                     class="org.lxh.hibernate.demo05.pojo.TGroup" column="gid"

                     unique="true">

              </many-to-one>

       </class>

</hibernate-mapping>

àTGroup.hbm.xml

<hibernate-mapping>

       <class name="org.lxh.hibernate.demo05.pojo.TGroup" table="tgroup">

              <id name="gid" type="java.lang.String">

                     <column name="gid" length="32" />

                     <generator class="uuid.hex"></generator>

              </id>

              <property name="name" type="java.lang.String">

                     <column name="name" length="20" not-null="true" />

              </property>

              <one-to-one name="person"

                     class="org.lxh.hibernate.demo05.pojo.Person" property-ref="tgroup">

              </one-to-one>

       </class>

</hibernate-mapping>

àone-to-many

àPerson.hbm.xml

<hibernate-mapping>

       <class name="org.lxh.hibernate.demo06.pojo.Person" table="person"

              catalog="mldn">

              <id name="pid" type="java.lang.String">

                     <column name="pid" length="32" />

                     <generator class="uuid.hex"></generator>

              </id>

              <property name="name" type="java.lang.String">

                     <column name="name" length="20" not-null="true" />

              </property>

              <property name="age" type="java.lang.Integer">

                     <column name="age" />

              </property>

              <set name="address" table="address" cascade="all"

                     inverse="true">

                     <key>

                            <column name="pid" length="32" />

                     </key>

                     <one-to-many class="org.lxh.hibernate.demo06.pojo.Address" />

              </set>

       </class>

</hibernate-mapping>

àAddress.hbm.xml

<hibernate-mapping>

    <class name="org.lxh.hibernate.demo06.pojo.Address" table="address" catalog="mldn">

        <id name="aid" type="java.lang.String">

            <column name="aid" length="32" />

            <generator class="uuid.hex"></generator>

        </id>

        <many-to-one name="person" class="org.lxh.hibernate.demo06.pojo.Person">

            <column name="pid" length="32" />

        </many-to-one>

        <property name="name" type="java.lang.String">

            <column name="name" length="50" not-null="true" />

        </property>

        <property name="zipcode" type="java.lang.String">

            <column name="zipcode" length="10" not-null="true" />

        </property>

    </class>

</hibernate-mapping>

在Hibernate 3中实际上有一种机制叫做延迟加载

 所谓的延迟加载就是指当程序用到数据的时候才进行加载

Hibernate中提供的delete方法最大的缺点就是必须先把数据查询出来之后 ，在进行删除，这样才能一起删除掉，最好的做法是将数据按ID进行删除àHQL

举例（各种容器的hbm文件的写法）：

Set：

 <hibernate-mapping>

       <class name="org.lxh.hibernate.demo01.pojo.Person" table="person">

              <id name="id" type="java.lang.Integer">

                     <column name="id" />

                     <generator class="native"></generator>

              </id>

              <property name="name" type="java.lang.String">

                     <column name="name" length="20" />

              </property>

              <set name="emails" table="emails" lazy="false">

                     <key column="id"></key>

                     <element type="java.lang.String" column="address"></element>

              </set>

       </class>

</hibernate-mapping>

List:

<hibernate-mapping>

       <class name="org.lxh.hibernate.demo02.pojo.Person" table="person">

              <id name="id" type="java.lang.Integer">

                     <column name="id" />

                     <generator class="native"></generator>

              </id>

              <property name="name" type="java.lang.String">

                     <column name="name" length="20" />

              </property>

              <list name="books" table="books">

                     <key column="id"></key>

                     <index column="posit"></index>

                     <element type="java.lang.String" column="title"></element>

              </list>

       </class>

</hibernate-mapping>

Map:

<hibernate-mapping>

       <class name="org.lxh.hibernate.demo03.pojo.Person" table="person">

              <id name="id" type="java.lang.Integer">

                     <column name="id" />

                     <generator class="native"></generator>

              </id>

              <property name="name" type="java.lang.String">

                     <column name="name" length="20" />

              </property>

              <map name="phone" table="phone">

                     <key column="id"></key>

                     <index type="java.lang.String" column="name"></index>

                     <element type="java.lang.String" column="numbers"></element>

              </map>

       </class>

</hibernate-mapping>

à实体层映射：

     hibernate-mapping package="org.lxh.hibernate">

       <class name="Person" table="PERSON">

              <id name="id" column="ID" type="int">

                     <generator class="assigned" />

              </id>

              <component name="name" class="org.lxh.hibernate.Name">

                     <property name="firstname" column="FIRSTNAME" type="string" not-null="true" />

                     <property name="lastname" column="LASTNAME" type="string" not-null="true" />

              </component>

              <component name="contact" class="org.lxh.hibernate.Contact">

                     <property name="address" column="ADDRESS" type="string" not-null="true" />

                     <property name="zipcode" column="ZIPCODE" type="string" not-null="true" />

                     <property name="tel" column="TEL" type="string" />

              </component>

       </class>

</hibernate-mapping>

à实体层设计：2个HBM文件的例子

|-- <hibernate-mapping package="org.lxh.hibernate04">

<class name="TItem" table="TITEM">

<id name="id" column="ID" type="string">

<generator class="assigned" />

</id>

<property name="name" column="NAME" type="string" not-null="true" />

<property name="manufacturer" column="MANUFACTURER" type="string" />

<joined-subclass name="org.lxh.hibernate04.TBook" table="TBook">

<key column="ID"></key>

<property name="pageCount" type="java.lang.Integer" column="pagecount"></property>

</joined-subclass>

<joined-subclass name="org.lxh.hibernate04.TDVD" table="TDvd">

<key column="ID"></key>

<property name="regionCode" type="java.lang.String" column="regioncode"></property>

</joined-subclass>

</class>

</hibernate-mapping>

|--  <hibernate-mapping package="org.lxh.hibernate05">

<class name="TItem" table="TITEM">

       <id name="id" column="ID" type="string">

       <generator class="assigned" />

       </id>

       <discriminator column="category" type="java.lang.String"></discriminator>

<property name="name" column="NAME" type="string" not-null="true" />

       <property name="manufacturer" column="MANUFACTURER" type="string" not-null="true" />

<subclass name="org.lxh.hibernate05.TBook" discriminator-value="1">

       <property name="pageCount" column="PAGECOUNT" type="int" />

       </subclass>

       <subclass name="org.lxh.hibernate05.TDVD" discriminator-value="2">

       <property name="regionCode" column="REGIONCODE" type="string" />

       </subclass>

       </class>

</hibernate-mapping>

这是Hibernate官方所推荐的查询语言，接近SQL的语法，并提供更多的特性与封装。

à从Person表查询出年龄（distinct去掉重复的）

String hql = "SELECT distinct p.sex FROM Person AS p" ;

              Query q = session.createQuery(hql) ;

              List all = q.list();

              Iterator iter = all.iterator();

àString hql = "SELECT COUNT(p.id) FROM Person AS p" ;

              Query q = session.createQuery(hql) ;

              List all = q.list();

à按字段查询

String hql = "FROM Person AS p WHERE p.name=?" ;

              Query q = session.createQuery(hql) ;

              q.setString(0, "张三") ;

              List all = q.list();

à更新操作

       String hql = "UPDATE Person SET sex=? WHERE id=?" ;

              Query q = session.createQuery(hql) ;

              q.setString(0, "Ů") ;

              q.setInteger(1, 1) ;

              q.executeUpdate() ;

              session.beginTransaction().commit() ;

à分页

String hql = "FROM Person AS p" ;

              Query q = session.createQuery(hql) ;

              q.setFirstResult(2) ; //从第几行取出

              q.setMaxResults(2); //取多少条

              List all = q.list();

              Iterator iter = all.iterator();

Session session = new Configuration().configure().buildSessionFactory().openSession();

à简单实例说明:

àEqual:

public class HibernateDemo01 {

       /**

        * @param args

        */

       public static void main(String[] args) {

              Session session = new Configuration().configure().buildSessionFactory()

                            .openSession();

              Criteria cri = session.createCriteria(Person.class);

              cri.add(Expression.eq("name", "张三"));

              List all = cri.list();

              if (all.size() > 0) {

                     Person per = (Person) all.get(0);

                     System.out.println(per.getName() + " --> " + per.getSex());

              }

       }

}

à大于

Criteria cri = session.createCriteria(Person.class);

cri.add(Expression.gt("age", 25));

List all = cri.list();

Iterator iter = all.iterator();

while (iter.hasNext()) {

Person per = (Person) iter.next() ;

        System.out.println(per.getName() + " --> " + per.getSex() + " --> "+ per.getAge());

       }

à小于

Criteria cri = session.createCriteria(Person.class);

cri.add(Expression.lt("age", 25));

àbetween：

Criteria cri = session.createCriteria(Person.class);

cri.add(Expression.between("age", 25, 35));

à模糊查询：

Criteria cri = session.createCriteria(Person.class);

              cri.add(Expression.like("name","%三%"));

àin

Criteria cri = session.createCriteria(Person.class);

              Set<Integer> conds = new TreeSet<Integer>();

              conds.add(new Integer(1));

              conds.add(new Integer(2));

              cri.add(Expression.in("id", conds));

àand

 Criteria cri = session.createCriteria(Person.class);

cri.add(Expression.and(Expression.eq("name", "张三"), Expression.eq("sex", "男")));

àExample类查询条件跟已知对象的条件相同

  Person person = new Person() ;

              person.setName("张三") ;

              person.setSex("男") ;

              person.setAge(20) ;

              cri.add(Example.create(person));

<html:form action="demo.do" method="post">

              性别：

                     <html:radio property="sex" value="男"/>男

                     <html:radio property="sex" value="女"/>女

                     <br>

                     <html:submit value="提交"/>

                     <html:reset value="重置"/>

       </html:form>

à

<html:form action="demo.do" method="post">

              选择所喜欢的城市：

                     <html:select property="city">

                            <html:option value="BJ">北京</html:option>

                            <html:option value="TJ">天津</html:option>

                            <html:option value="NJ">南京</html:option>

                            <html:option value="GD">广东</html:option>

                            <html:option value="DB">东北</html:option>

                     </html:select>

                     <br>

                     <html:submit value="提交"/>

                     <html:reset value="重置"/>

       </html:form>

à

 <body>

 <%

       Collection col = new ArrayList() ;

       col.add(new org.apache.struts.util.LabelValueBean("北京","BJ")) ;

       col.add(new org.apache.struts.util.LabelValueBean("天津","TJ")) ;

       col.add(new org.apache.struts.util.LabelValueBean("南京","NJ")) ;

       col.add(new org.apache.struts.util.LabelValueBean("东北","DB")) ;

       col.add(new org.apache.struts.util.LabelValueBean("广东","GD")) ;

       // 将全部的集合放在一个属性范围之中

       pageContext.setAttribute("ht",col) ;

 %>

    <html:form action="demo.do" method="post">

              选择所喜欢的城市：

                     <html:select property="city">

                            <html:optionsCollection name="ht"/>

                     </html:select>

                     <br>

                     <html:submit value="提交"/>

                     <html:reset value="重置"/>

       </html:form>

 </body>

à

<body>

    <html:form action="demo.do" method="post">

              选择所爱吃的水果：

                     <html:checkbox property="fruit" value="orange"/>橘子

                     <html:checkbox property="fruit" value="banana"/>香蕉

                     <html:checkbox property="fruit" value="apple"/>苹果

                     <html:checkbox property="fruit" value="watermelon"/>西瓜

                     <html:checkbox property="fruit" value="cherry"/>樱桃

                     <br>

                     <html:submit value="提交"/>

                     <html:reset value="重置"/>

       </html:form>

 </body>

à

<body>

    <html:form action="demo.do" method="post">

              选择所爱吃的水果：

                     <logic:iterate id="fru" name="demoForm" property="fruit">

                            <html:multibox property="select">${fru}</html:multibox>${fru}

                     </logic:iterate>

                     <br>

                     <html:submit value="提交"/>

                     <html:reset value="重置"/>

       </html:form>

 </body>

à

<body>

    <html:form action="demo.do" method="post">

              个人介绍：

                     <html:textarea property="sex" rows="6" cols="30"/>

                     <br>

                     <html:submit value="提交"/>

                     <html:reset value="重置"/>

       </html:form>

 </body>