Html 模板代码：

<h1> PopopLink组件： </h1><p>

作用：弹出一个自定义的窗口，相当于一个 Script语名：

<br> window.open(URL, windowName, windowFeatures) <br>

1.必须在Body组件内使用。 <br>

2.注意href参数它会产生一个地址“/context/href参数值”

<p> <span jwcid = "@contrib:PopupLink" href = "/WEB-INF/Home.html" features = 'ognl:"resizable,scrollbars,top=100,left=100,height=400,width=300"' > PopupLink到主页 </span>

二、 GenericLinkLink 组件

Html 模板代码：

1.GenericLink：一般作用是用来链接跳转到应用程序范围以外的链接。注意OGNL用法： <br>

<a jwcid = "@GenericLink" href = "ognl:'http://'+url" >

<span jwcid = "@Image" image = "ognl:assets.ms" /> 163主页 </a><p>

url参数：

private String url="http://www.blogjava.net/happydavy/";

ms参数：

<context-asset name="ms" path="//MS.JPG"/>

作用：点击后就会到 163页面。

三、 .ExternalLink 组件

Html 模板代码：

<span jwcid = "@ExternalLink" page = "LinkResult" parameters = 'ognl:new java.lang.Object[]{new java.lang.Integer("5"),new java.lang.String("rjzjh")}' >

ExternalLink使用 </span><p>

ExternalLink ：这组件比 GenericLink 组件复杂，使用 Tapestry 的 9 种 Service 的 “external service” ，它的用法关注 LinkResult 页。

链接传递参数 parameters ，多个参数用逗号隔开。链接的页面 “LinkResult” 必须实现 IExternalPage 接口，必须重写 activateExternalPage 方法
在这个方法中我们可以把传递过来的参数取出来实现我们的逻辑。参数因为单引号内有双引号，所以不能用双引号，也可以调回来用了，链接页的地址为： http://localhost:8080/context/app?service=external/LinkResult&sp=5&sp=Srjzjh

接收参数的页面要：

?  实现 IexternalPage 接口。

?  覆盖 public void activateExternalPage(Object[] parameters, IRequestCycle cycle) 方法。

如下 Java 文件为：

public void activateExternalPage(Object[] parameters, IRequestCycle cycle) {

this.setPar1((Integer)parameters[0]);

if(parameters.length==2){

this.setPar2((String)parameters[1]);

}

}

三、 DirectLink 组件

Html 模板为：

<p><span jwcid = "@DirectLink" listener = "ognl:listeners.directlistener" parameters = 'ognl:new java.lang.Object[]{new java.lang.Integer("8"),new java.lang.String("zjh")}' >

这是一个DirectLink链接

</span><br>

<span jwcid = "@DirectLink" listener = "ognl:listeners.DirectResult" parameters = 'ognl:new java.lang.Object[]{new java.lang.Integer("8"),new java.lang.String("zjh")}' >

第二个DirectLink，跳转到LinkResult页面

</span>

<br> DirectLink要传的参数是：

<span jwcid = "@Insert" value = "ognl:Directpar1" /> 和 <span jwcid = "@Insert" value = "ognl:Directpar2" /><p>

第一个组件接收参数方法（监听事件）：

public void directlistener(IRequestCycle cycle){

Object[] par=cycle.getServiceParameters();

this.setDirectpar1((Integer)par[0]);

this.setDirectpar2((String)par[1]);

}

第二个组件接收参数方法（在跳转的页面中写监听事件）：

1 ．先跳转到另一个页面：

public void DirectResult(IRequestCycle cycle){

IPage result=cycle.getPage("LinkResult");

cycle.activate(result);

}

2 ．这时参数也会随 Session 传到 LinkResult 页面，在 LinkResult 页面中写监听事件。

public void getpar(IRequestCycle cycle) {

Object[] par=cycle.getServiceParameters();

this.setDirectpar2((String)par[1]);

this.setDirectpar1((Integer)par[0]);

}

你只需要构造这listrner方法，而不是整个servlet。Tapestry会在正确的时候和正确的条件下调用listener的方法。你不需要考虑如何构造URL，以及通过URL传递什么数据，或者如何结合到你的应用程序中去。这些工作框架都替你做好了。

页面和组件

Tapestry把一个应用程序分成一系列的页面。每一个页面由Tapestry的组件组成。组件本身也许是由组件构成。这里没有人为的深度。
tapestry页面本身就是组件，只是有些特殊用处的组件。
所有的tapestry的组件可以成为其他组件的容器。Tapestry页面，和许多用户定义的组件一样，有一个模板，由一个特殊的html定义了一些静态的和动态的组件位置，同时有标签表明那些内嵌的组件是活跃的。组件不需要有标签。Tapestry组件参数也许是双向的，一个组件可以读取一个参数来获得一个值，或者写一个参数来设置一个值。

其他的组件。如form和form控制组件（TextField, PropertySelection, Checkbox等等）使得html中的form的实现变得容易。当这样的组件被显示的时候，他们从程序对象中读取属性值来提供默认值。当form被提交的时候，form中的组件读取http的查询参数，转换数值为合适的类型并且更新程序对象的属性。

引擎，服务和
随着时间的过去，Tapestry已经发展了它自己的方言。
Tapestry的引擎是一个一对象为中心的，它的作用和Httpsession在Servlet API的作用。 引擎的最终职责是存储应用程序的持久状态（从一个请求到下一个请求时存在的属性），这个任务已经通过把引擎存贮在httpsession的方式被完成了。本文档将主要讨论默认的实现，同时标注如何在适当的时候扩展，重写这些实现。

对Tapestry的高度评价是"对象，方法和属性"，也就是说，不仅仅使开发者关注Servlet的API：requests, responses, sessions, attributes, parameters, URLs等等，Tapestry使得开发者更关注于对象（包括Tapestry的页面和组件，而且包括程序的对象），对象的方法以及那些对象的javaBean的属性。也就是说，在一个tapestry的程序中，用户的动作（点击链接，提交表单）会导致对象的属性的变化，这些属性和用户支持的方法（包括程序逻辑）组合在一起。

在Tapestry中，你不需要写servlet，你只要写一些Listener方法，你同样不需要为servlet建立URL，你可以利用一个存在的组件（例如DirectLink）并配置他的listener的参数来调用方法。那么Listener的方法到底做了什么呢？它和后台系统进行交互（通常是无状态的session EJB）或者是做一些其他的和request相关的记录，同时提供给用户一个新的页面。基本上是这个servlet的核心代码。在tapestry中，你不需要写那些重复的，机械的代码（例如建立url，分发请求，管理服务器段的状态等等），因为那些都被tapestry这个框架完成了。

但是这并不表示Servlet API是不可访问的，它仅仅是不跟一个典型的tapestry用户相关。

本文档描述了很多tapestry的一些内在的情况。本文不是教程（教程是另外一个单独的文档）。事实上，本文档是给一些tapestry的用户的指南，目的是给那些想使用tapestry的开发者。

tapestry目前的版本是 4.0，在过去的十几年里已经过了长足的发展。Tapestry始终关注于生成动态的html代码，尽管有大量的软件支持XHTML XML 和 WML。

几乎所有的Tapestry的API都是一接口的形式出现，同时有默认的实现。只要用新的对象取代现有的接口，框架的行为可以被很容易的取代。最平常的例子就是重载一个存贮的页面和它的组件（也许存贮在数据库中）。

最后，Tapestry有值得自豪的完整的JavaDoc的文档。本文档是用来支持那份文档的，来填补那分文档的一些不明显的不足。当然JavaDoc是最好的文档。

也许理解Tapestry最难的部分就是它是一个以基于组件的，而不是以基于操作的。大多数的技术（Struts，servlets, PHP等等）都是基于操作的。当你建立一个servlet以后，当用户点击一个链接或者提交一个form的时候机会调用它。你必须选定一个适当的链接，和要传递参数的名字和类型，这样你才能在URL中传递你所需要的信息。

对于那些操作（点击链接或提交表单），你同样必须负责去连接你的外部页面（不管他们是JSP，servlets, PHP,或者其他形式的模板技术）。这需要你建立URL并且把他们放到一个<a>的标签中，或者是放在一个<form>标签的action属性中。

tapestry中所有的东西都是不同的。Tapestry程序由页面组成，页面是由小的组件构成，组件本身也有可能由其他组件构成。每一个页面都由一个唯一的名字，页面中的每个组件都有它唯一的ID...这就是组件模型。同时，每一个组件都有一个地址，可以快速的和URL进行绑定。

事实上，在“向购物车添加物品”的操作中，你不需要写servlet，甚至也不用写组件。你只需要拿一个已有的组件，例如（DirectLink）,然后配置它。当这个组件被显示的时候，它会建立一个回调的链接，当你点击这个链接的时候，这个回调链接（包括了页面名称和页面内的组件的ID）将会调用组件上的方法，然后这个方法就会调用你的程序制定的Listener方法

Tapestry是一个使用Java语言编写的开源框架，用于创建动态的、健壮的、高灵活性的web应用程序。Tapestry框架构筑在标准的Java Servlet API之上，因此它能够很好地兼容任何servlet容器或者应用服务。

Tapestry将一个web应用程序分离为一组页面，而每个页面又由多个组件组成。这就提供了一个协调一致的结构，使得Tapestry框架能够专注于任何一个关键细节，例如：URL解析和派遣、持久化状态储存在客户端还是储存在服务器端、用户输入效验、本地化或国际化、和异常报告。对 Tapestry应用程序的开发包括：使用普通的HTML标签创建HTML模板，然后使用XML描述文件（可选）将这些模板与少量的java代码结合在一起。在Tapestry中，创建你的应用程序是通过使用对象、方法以及对象的属性－－－而并非由URLs和查询参数。Tapestry带来了真正的 Java Web应用程序OOP编程。

Tapestry能够非常容易地创建新组件，就如同以常规的步骤来构建应用程序一样。而官方提供了超过五十种组件，这些组件包括各种各样简单的输出组件，以及非常复杂的表格组件和树型目录组件。

Tapestry能够构建，从小型的应用程序到各种大型团队开发的几百个独立页面的大型应用程序。Tapestry能够非常容易地与各种底层框架结合，包括J2EE、Hivemind和Spring。

Tapestry发布于Apache Software Licence 2.0。

Tapestry的哲理

Tapestry由以下四种关键原则组成：

• 简单 － 应用程序并非像火箭科学那么复杂。
• 一致性 － 怎样操作页面，怎样操作组件。在小应用程序中怎样操作，那么在大型应用程序中就怎样操作。不同的开发者会在相识问题上找到相似的解决方案。
• 效率 － 应用程序是可以被升级的。
• 良好的反馈信息 － 当发生错误或者异常的时候，Tapestry框架本身的运作并不会发生异常；实际上，Tapestry框架会提供非常有用的错误诊断信息。

这四种原则共同组成了一个宗旨：最简单的选择，就是最正确的选择。越早选择Tapestry框架，那么就越早避免许多麻烦。

我们发现面向组件式web开发是实现这些原则的最好途径。围绕着组件来组织框架和你的应用程序，让框架来替你实现那些令人厌烦的底层代码。你只需要写少量的代码，写一些简单的代码，有时候你甚至不需要写代码。Tapestry让你轻松。

Tapestry 4.0

Tapestry4.0增加了许多新特性以便提高你的工作效率：

•  4.0中新的DTDs配置更加简化。
• 在HTML中与在XML配置文件中绑定参数的方式被协调一致，都使用相同的绑定前缀。
• "Friendly"URLs（就是说，URLs中携带更多路径信息和更少的查询参数信息）已经被集成。这使得你可以将应用程序分别放在多个文件夹中而减少混乱，并且可以通过这种方式提高J2EE项目发布的安全性。
• 监听方法更加简单和灵活；URL中的监听参数会自动映射到监听方法的参数，并且监听方法可以返回页面名称或者页面实例来激活页面。
• 组件参数不必在担心"direction"设置。
• 除了每个页面和每个组件的消息策略之外，应用程序现在拥有一个全局的消息策略。消息不再从组件消息策略中寻找，而是从应用程序策略中查询。
• 完全支持对JSR-168 Portlets的开发。
• Tapestry 4.0比Tapestry3.0减少了对反射和OGNL的使用；一部分原因是使用了许多新绑定前缀，大部分原因是改变了参数的实现方式。
• Hivemind的services和Spring的beans能够直接被页面和组件类注入。
• Tapestry 4.0提供了对JDK 1.5 annotation的支持（但是Tapestry本身是运作于JDK 1.3）。
• Tapestry 4.0引进了一个全新的更健壮的用户输入效验子系统。感谢Paul！
• 现在能够在错误报告里面，用横线精确地标明文件中发生错误的代码行。
• Forms现在能够被取消，避过客户端效验逻辑，并触发指定的服务器端监听方法。
• 你不再局限于Global对象和Visit对象；只要你愿意，可以使用任意多的application状态对象。
• 由于Hivemind构筑与Tapestry底层，意味着你可以容易地按照自己的需要修改Tapestry的实现。
• 页面属性现在能够被持久化于客户端中，就如同在session中一样。
• 组件和组件参数现在可以被标识为"deprecated"。组件参数可以拥有别名（当重新命名一个参数时使用）。

可以列举出无数Tapestry 4.0的变化。总之，所有的变化都是令人震撼的，减少了开发者的java代码，减少了模板的复杂性，简化（或者除去）了XML文件。

现状

Tapestry 4.0的开发工作仍在全力进行中。文档从以前旧的DocBook形式转变到新的Forrest形式，剔除了许多临时性间隔。指南中新的Quick Start章节已经被撰写。

Tapestry 4.0已经接近最终的beta周期；新特性将会被延续到Tapestry 4.1，并会继续逐步完善文档和修正bug。最终版本的Tapestry 4.0预计（不保证）会在2005年十月推出。

从4.0-beta-12升级

作为TAPESTRY-620修正的一部分：将当前的IRquestCycle作为可注入的service，简化Tapestry中的一些接口，取消IRequestCycle参数。这可能要求对一些地方的代码实现作适当调整。

从4.0-beta-10升级

在beta-10和之后的版本中，对于asset service，friendly URLs的配置改变了。在你的hivemind.xml中，将<asset-encoder id="asset" path="/assets/"/> 改为<asset-encoder id="asset" path="/assets"/>（注意斜杠已经被去掉）。

从Tapestry 3.0升级

Tapestry 4.0具有很多新特性，考虑到向后兼容性，有些地方做了限制。具体细节以后会发布，但是至少：

• Tapestry3.0 页面和组件规范仍然保留。
• 页面和组件的模板没有改变。

升级的时候，你将遇到下列问题：

• 引擎service的定义已经完全改变，可以参看IEngineService API。
• BaseEngine的子类通过override来操作异常的方式已经改变。现在可以通过新的Hivemind services来重构默认的配置。
• direction参数的"custom"已经不再使用。定义一个参数总是会生成对应的property。
• 参数都不会再通过parameterName绑定property，取而代之的是你必须使用getBinding()方法。
• page loader和specification delegate的关系已经改变，现在delegate提供的specifications会被loader缓存（在3.0中，由delegate来负责缓存）。
• Tapestry不再需要Jakarta commons-lang library支持，这意味着不能再使用EnumPropertySelectionModel类（然而，你可以很容易地从Tapestry 3.0中拷贝到源代码）。

2  数据库中有以下数据
 ID(pri)(Auto) name pass
 1  aaa 111
 2  bbb 222
 3  ccc 333
请用一条SQL语句将现有的三条记录复制一下，达到以下的效果
 ID(pri) (Auto) name pass
 1  aaa 111
 2  bbb 222
 3  ccc 333
 4  aaa 111
 5  bbb 222
 6  ccc 333
再用一条sql删除重复记录
这个要hotman_x这个sqlA来回答了，呵呵

3  在服务器端，从一个jsp页面中跳到另外一个jsp页面中有几种方法？

4  数据库中表结构如下，
 ID（Pri）  int
 no    int
 name    varchar
 birthDay   Date
 用java写一个函数,返回所有符合条件 no = int a  & name = str $ birthdavy = date 的结果集合

5 jsp和Servlet的区别和联系

6  设计一个权限管理模型，分为a＆b两组 a组的一般用户只能读取a的table，a组中的管理员可以对a的table进行CRUD
同样，b组的一般用户只能读取b的table，b组中的管理员可以对b的table进行CRUD
超级管理员可以对a＆b的table进行CRUD
写出部分实现代码

7 居然还有一家公司让我用30分钟的时间作了50道脑筋急转弯，我得了96分，呵呵

上面的题目除了那个sql的题目我没做出来，别的题目还是让公司比较满意的 呵呵

HelloTalker ht=(HelloTalker)context.getBean(“helloTalker”);
System.out.println(ht.greeting());
}catch(Exception e)
{
e.printStackTrace();
}
}
}
　这个程序就完成了，因为只有一个对象HelloTalker被注册到了spring中，所以不存在对象间的依赖，当然也就不涉及依赖注入。下面演示一个简单的依赖注入：
　第一步是修改HelloTalker，增加一个String name属性：
public String name;

　为该属性编写set方法，该方法必须严格遵守javabean的命名规则：
public void setName(String name)
{
　　this.name=name;
}
　　修改greeting方法：

public String greeting()
{
　　return "hello "+name;
}
　如你所见，name属性没有初试化，因为它的值将在运行过程中被spring动态注射入。
　第二步，修改springConfig.xml中唯一的这个bean配置：

<bean id=”helloTalker” class=” org.bromon.spring.test.HelloTalker”>
　<property name=”name”>
　　<value>bromon</value>
　</property>
</bean>

　修改完成。我们将一个名字”bromon”写死在springConfig.xml中，它会被动态的注入到HelloTalker的name属性中，greeting方法将会把它打印出来。重新运行刚才的junit类，可以看到结果。
　我们只演示了如何注入一个最简单的String，实际上我们可以注入任何值类型，也可以注入任何类的实例，也可以注入List、Map、Properties。配置文件管理了所有的对象和对象间的关系，而对象则只负责执行自己的功能，他们的职责越少，藕合度越低，系统就越容易测试，管理维护也更容易。
　<bean>标签还有很多属性，用于指定对象如何被实例化，它也有很多子标签用于配置对象的属性，请大家参考相关的DTD和文档，能够很快的掌握。本系列文章不是spring手册，spring的基础知识请参考spring in action，足够详细准确。后面的章节更多的讨论系统设计、开发的一些细节和高级特性。
三、spring中的hibernate开发
　spring中对hibernate的支持是非常强大的，从一个简单的例子就看得出来，从这个例子中我们还将对所谓的轻量级容器做一些讨论。
　首先需要配置数据源，通常我们有两种方式获得Connection，一是自己编写代码获得连接，二是从JNDI环境中得到DataSource，然后产生一个Connection。无论怎样，既然是spring下面的对象，就应该注册到配置文件中。假设我们需要一个连接mysql下面一个叫做examer的数据库，手动方式的配置是：

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
　　<property name="driverClassName">
　　　　<value>com.mysql.jdbc.Driver</value>
　　</property>
　　<property name="url">
　　　　<value>jdbc:mysql://localhost/examer</value>
　　</property>
　　<property name="username">
　　　　<value>root</value>
　　</property>
　　<property name="password">
　　　　<value></value>
　　</property>
</bean>

　很好读是不是？假如我们使用JNDI数据源，那么dataSource的声明就应该是：

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
　　<property name="jndiName">
　　　　<value>java:compenvjdbcspringExamer</value>
　　</property>
</bean>
　你需要在JNDI环境中绑定一个名为jdbc/springExamer的东西，这段代码才有实际意义。另外需要提醒的是，所有的bean声明，它的id必须是唯一的。
　在本系统中，数据库操作是被hibernate封装起来的，所以dataSource是不需要注入到具体的逻辑类中，它只会被注给hibernate的sessionFactory。
　按照常规思路，我们需要在spring中注册hibernate的sessionFactory，它应该是我们自己编写的一个类，获得dataSource，返回sessionFactory，其他的逻辑类通过这个sessionFactory获得session进行数据库操作。
　但是我们有另外一种选择，spring直接提供了对sessionFactory的封装，你只需要注册一个spring自己的类，给它提供必须的属性，它会返回一个org.springframework.orm.hibernate.HibernateTemplate，这个类封装了add、del等操作，它的封装程度相当高，通过它来编写hibernate应用非常简单。但是问题出来了，我们该如何选择？
　表面上看，使用spring自己的库无疑更加简单，但是请注意，spring是一个轻量级的框架，所谓轻量级，一个重要特征就是无侵入性，也就是你使用这套框架，不会被它绑定，被spring管理的类，应该不需要使用它的接口和抽象类，这样你的系统不会对spring产生依赖。但是如果你使用了spring封装的方式去操作hibernate，就必须继承org.springframework.orm.hibernate.support.HibernateDaoSupport类，这导致了绑定。所以做这样的选择是有点痛苦的，如果有一天spring框架不存在了，你的代码怎么升级维护？具体问题只能具体分析，在我们的应用中，完全使用了spring封装的HibernateTemplate，它太好用了，所以容易上瘾。
　假设我们有一张student表，结构很简单：
　　
id　　　　　　自动增长
　　name　　　　　varchar(40)
　　password　　　varchar(32)
　　grade 　　　　int(4)　　　　　　年级
　　sex　　　　　Boolean　　　　　　性别(true为男，false为女)
　设计一个Student类来映射这张表：

/*
* 创建日期 2005-3-17
*/
package net.bromon.spring.examer.pojo;
/**
* @author Bromon
*/
public class Student
{
private int id;
private String name;
private String password;
private int grade;//年级
private boolean sex;

getset方法……….
}
　编写Student.hbm.xml，让hibernate知道如何去关联student表和Student类，该文件和Student.java在同一目录：

<hibernate-mapping>
　　<class name="net.bromon.spring.examer.pojo.Student" table="student">
　　　　<id name="id" column="id">
　　　　　　<generator class="identity"/>
　　　　</id>

　　　　<property name="name" column="name" />
　　　　<property name="password" column="password" />
　　　　<property name="grade" column="grade" />
　　　　<property name="sex" column="sex" />
　　</class>
</hibernate-mapping>
　然后我们可以在spring中配置sessionFactory：

<bean id="sessionFactory"　class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
　　<property name="dataSource">
　　　　<ref bean="dataSource"/>
　　</property>

　　<property name="hibernateProperties">
　　　　<props>
　　　　　　<prop key="hibernate.dialect">net.sf.hibernate.dialect.MySQLDialect</prop>
　　　　</props>
　　</property>

　　<property name="mappingDirectoryLocations">
　　　　<list>
　　　　　　<value>classpath:/netbromonspringexamerpojo</value>
　　　　</list>
　　</property>
</bean>
　其中引用了我们之前注册过的dataSource，mappingDirectoryLocations属性指明了.hbm.xml文件在哪里路径，该文件夹下面的.hbm.xml文件会被全部加载。
　一切都准备就绪，现在我们要加入一个StudentManager类，来进行增删查改的操作：
/*
* 创建日期 2005-3-17
*/
package net.bromon.spring.examer.student;
import net.bromon.spring.examer.pojo.Student;
import org.springframework.orm.hibernate.HibernateTemplate;
import org.springframework.orm.hibernate.LocalSessionFactoryBean;
import org.springframework.orm.hibernate.support.HibernateDaoSupport;
/**
* @author Bromon
*/
public class StudentManager extends HibernateDaoSupport
{
private LocalSessionFactoryBean sessionFactory;
private HibernateTemplate ht;
public StudentManager()
{
this.ht=super.getHibernateTemplate();
}

public void add(Student s)
{
ht.save(s);//插入一条数据只需要这一行代码
}
}
　该类只演示了如何增加一个Student，HibernateTemplate还封装了很多有用的方法，请查阅spring文档。StudentManager中的sessionFactory是由spring注入的，但是StudentManager并没有对sessionFactory做任何的处理，这是因为所有的处理都被HibernateDaoSupport.getHibernateTemplate()封装。整个StudentManager中也看不到任何的异常处理，他们也都被基类封装了。
　最后一个步骤就是在spring中注册StudentManger，然后向它注入sessionFactory：

<bean id="studentManager" class="net.bromon.spring.examer.student.StudentManager">
　　<property name="sessionFactory">
　　　　<ref bean="sessionFactory"/>
　　</property>
</bean>

　所有的配置都完成了，下面做单元测试：

/*
* 创建日期 2005-3-17
*/
package net.bromon.spring.examer.student.test;
import java.io.FileInputStream;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import net.bromon.spring.examer.pojo.Student;
import net.bromon.spring.examer.student.StudentManager;
import junit.framework.TestCase;
/**
* @author Bromon
*/
public class TestStudentManager extends TestCase {
public void testAdd()
{
try
{
ApplicationContext context =new ClassPathXmlApplicationContext("springConfig.xml");

Student s=new Student();
s.setName("bromon");
s.setPassword("123");
s.setGrade(3);
s.setSex(true);

((StudentManager)context.getBean("studentManager")).add(s);
}catch(Exception e)
{
e.printStackTrace();
}
}
}
　Spring已经将hibernate的操作简化到了非常高的程度，最关键的是整个开发可以由设计来驱动，如果一个团队对spring有足够的熟悉，那么完全可以由设计师规划所有的类，整理清楚类之间的关系，写成配置文件，然后编写hibernate映射文件，将数据表与pojo关联，成员就可以完全在设计方案内工作，利用spring封装好的hibernate模版，开发起来速度非常快，调试也很容易。它能够解决如何在团队内贯彻设计方案的问题。
　由于本文不讲解hibernate的使用，所以相关内容请查阅hibernate文档。
四、Spring中的事务控制
　Spring和EJB一样，提供了两种事务管理方式：编程式和声明式。在考试系统中我们将使用声明式的事务管理，这是spring推荐的做法。使用这种方式可以体验到spring的强大便捷，而且我们无须在Dao类中编写任何特殊的代码，只需要通过配置文件就可以让普通的java类加载到事务管理中，这个意义是很重大的。
　Spring中进行事务管理的通常方式是利用AOP（面向切片编程）的方式，为普通java类封装事务控制，它是通过动态代理实现的，由于接口是延迟实例化的，spring在这段时间内通过拦截器，加载事务切片。原理就是这样，具体细节请参考jdk中有关动态代理的文档。本文主要讲解如何在spring中进行事务控制。
　动态代理的一个重要特征是，它是针对接口的，所以我们的dao要通过动态代理来让spring接管事务，就必须在dao前面抽象出一个接口，当然如果没有这样的接口，那么spring会使用CGLIB来解决问题，但这不是spring推荐的方式，我们也不做讨论。
　参照前面的例子，我们为StudentManager.java定义一个接口，它的内容如下：

/*
* 创建日期 2005-3-25
*/
package org.bromon.spring.examer.student;
import java.util.List;
import org.bromon.spring.examer.pojo.Student;
/**
* @author Bromon
*/
public interface StudentManagerInterface
{
public void add(Student s);
public void del(Student s);
public void update(Student s);

public List loadAll();
public Student loadById(int id);
}

　StudentManager也应该做出修改，实现该接口：

public class StudentManager extends HibernateDaoSupport implements StudentManagerInterface
　现在需要修改配置文件，用于定义Hibrenate适用的事务管理器，并且把sessionFactory注入进去，同时还需要通过注册一个DefaultTransactionAttribute对象，来指出事务策略。其中sessionFactory的定义已经在本文的第三章中说明。
　首先定义一个Hibernate的事务管理器，让它来管理sessionFactory：
<bean id="transactionManager" class="org.springframework.orm.hibernate.HibernateTransactionManager">
　<property name="sessionFactory">
　　<ref bean="sessionFactory"/>
　</property>
</bean>

　下面定义事务管理策略，我们希望把策略定义在方法这个级别上，提供最大的灵活性，本例中将add方法定义为：PROPAGATION_REQUIRES_NEW，这可以保证它将始终运行在一个事务中。

<bean id="transactionAttributeSource" class="org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource">
　<property name="properties">
　　<props>
　　　<prop key="add">
　　　　PROPAGATION_REQUIRES_NEW
　　　</prop>
　　</props>
　</property>
</bean>

　我们不仅可以为add方法定义事务策略,还可以定义事务隔离程度和回滚策略,他们以逗号隔开,比如我们的add事务可以定义为:

<prop key="add">
PROPAGATION_REQUIRES_NEW,-ExamerException
</prop>

　这个事务策略表示add方法将会独占一个事务，当事务过程中产生ExamerException异常，事务会回滚。
　Add/update/del都是写入方法，对于select（读取）方法，我们可以指定较为复杂的事务策略，比如对于loadAll()方法：
　
<prop key=”loadAll”>
　PROPAGATION_SUPPORTS,ISOLATION_READ_COMMITED,readOnly
　</prop>

　该事务的含义为，loadAll方法支持事务，不会读取未提交的数据，它的数据为只读（可提高执行速度）。
　如你所见，我们的StudentManagerInterface接口中还有一个loadById(int id)方法，也许我们将来还会有很多的loadByXXXX的方法，难道要一一为他们指定事务策略？太烦人了，他们应该和loadAll()一样，所以我们可以使用通配符，定义所有的loadXXXX方法：

<prop key=”load*”>
PROPAGATION_SUPPORTS,ISOLATION_READ_COMMITED,readOnly
</prop>

　现在可以定义事务管理器：
<bean id="studentManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
　<property name="target">
　　<ref bean="studentManager"/>
　</property>
　<property name="transactionManager">
　　<ref bean="transactionManager"/>
　</property>
　<property name="transactionAttributeSource">
　　<ref bean="transactionAttributeSource"/>
　</property>
</bean>
　这个bean的外观是一个接口(StudentManagerInterface)，我们指出了它的具体实现(studentManager)，而且为它绑定了事务策略。在客户端使用的时候，获得对象是StudentManagerInterface，所有的操作都是针对这个接口的。测试代码并没有改变，我们虽然修改了很多地方，加入了事务控制，但是客户端并没有受到影响，这也体现了spring的一些优势。测试代码如下：
　　
public void testAdd()
{
ApplicationContext ctx=new ClassPathXmlApplicationContext("springConfig.xml");
StudentManager sm=(StudentManager)ctx.getBean("studentManager");

Student s=new Student();
s.setId(1);
s.setName("bromon");
s.setPassword("123");
s.setGrade(1);
s.setSex(0);

sm.add(s);
}
通过以上的代码可以看出，spring可以简单的把普通的java class纳入事务管理，声明性的事务操作起来也很容易。有了spring之后，声明性事务不再是EJB独有，我们不必为了获得声明性事务的功能而去忍受EJB带来的种种不便。
我所使用的mysql是不支持事务的，你可以更换使用PostgreSQL，有了spring+hibernate，更换db并不像以前那样恐怖了，步骤很简单：
1、 添加PostgreSQL的jdbc驱动
2、 修改dataSource配置，包括驱动名称、url、帐号、密码
3、 修改sessionFactory的数据库dailet为net.sf.hibernate.dialect.PostgreSQLDialect
4、 修改hbm.xml中的主键生成策略为increment
所有的修改都在配置文件中完成，业务代码不需要任何修改，我很满意，How about u?
附A　　pring中的所有事务策略
　　　　PROPAGATION_MANDATORY
　　　　PROPAGATION_NESTED
　　　　PROPAGATION_NEVER
　　　　PROPAGATION_NOT_SUPPORTED
　　　　PROPAGATION_REQUIRED
　　　　PROPAGATION_REQUIRED_NEW
　　　　PROPAGATION_SUPPORTS
附B　　Spring中所有的隔离策略：
　　　　ISOLATION_DEFAULT
　　　ISOLATION_READ_UNCOMMITED
　　　　ISOLATION_COMMITED
　　　　ISOLATION_REPEATABLE_READ
　　　　ISOLATION_SERIALIZABLE