写完部署什么都没问题，可当我写了测试类进行测试时发现主键的初始值竟然是50，其步长亦是50，在同事的帮助下发现原来是Hibernate在做鬼，@SequenceGenerator中添加两个参数（allocationSize = 1, initialValue = 1）就OK。通过查找Hibernate的资料发现原来是因为allocationSize的默认值是50.具体请参考http://www.oracle.com/technology/global/cn/products/ias/toplink/jpa/resources/toplink-jpa-annotations.html#SequenceGenerator

只需要增加allocationSize = 1就可以

hibernate.dialect   一个Hibernate Dialect类名允许Hibernate针对特定的关系数据库生成优化的SQL. 取值full.classname.of.Dialect

hibernate.show_sql   输出所有SQL语句到控制台. 有一个另外的选择是把org.hibernate.SQL这个log category设为debug。 eg.true | false

hibernate.format_sql   在log和console中打印出更漂亮的SQL。 取值true | false

hibernate.default_schema   在生成的SQL中, 将给定的schema/tablespace附加于非全限定名的表名上. 取值SCHEMA_NAME

hibernate.default_catalog   在生成的SQL中, 将给定的catalog附加于非全限定名的表名上. 取值CATALOG_NAME

hibernate.session_factory_name   SessionFactory 创建后，将自动使用这个名字绑定到JNDI中. 取值jndi/composite/name

hibernate.max_fetch_depth   为单向关联(一对一, 多对一)的外连接抓取（outer join fetch）树设置最大深度. 值为0意味着将关闭默认的外连接抓取. 取值 建议在0到3之间取值  

hibernate.default_batch_fetch_size   为Hibernate关联的批量抓取设置默认数量. 取值 建议的取值为4, 8, 和16

hibernate.default_entity_mode   为由这个SessionFactory打开的所有Session指定默认的实体表现模式. 取值dynamic-map, dom4j, pojo

hibernate.order_updates   强制Hibernate按照被更新数据的主键，为SQL更新排序。这么做将减少在高并发系统中事务的死锁。 取值true | false

hibernate.generate_statistics   如果开启, Hibernate将收集有助于性能调节的统计数据. 取值true | false

hibernate.use_identifer_rollback   如果开启, 在对象被删除时生成的标识属性将被重设为默认值. 取值true | false

hibernate.use_sql_comments   如果开启, Hibernate将在SQL中生成有助于调试的注释信息, 默认值为false. 取值true | false

表 3.4.   Hibernate JDBC和连接(connection)属性

属性名   用途  

hibernate.jdbc.fetch_size   非零值，指定JDBC抓取数量的大小 (调用Statement.setFetchSize()).  

hibernate.jdbc.batch_size   非零值，允许Hibernate使用JDBC2的批量更新. 取值 建议取5到30之间的值  

hibernate.jdbc.batch_versioned_data   如果你想让你的JDBC驱动从executeBatch()返回正确的行计数 , 那么将此属性设为true(开启这个选项通常是安全的). 同时，Hibernate将为自动版本化的数据使用批量DML. 默认值为false. eg.true | false

hibernate.jdbc.factory_class   选择一个自定义的Batcher. 多数应用程序不需要这个配置属性. eg.classname.of.Batcher

hibernate.jdbc.use_scrollable_resultset   允许Hibernate使用JDBC2的可滚动结果集. 只有在使用用户提供的JDBC连接时，这个选项才是必要的, 否则Hibernate会使用连接的元数据. 取值true | false

hibernate.jdbc.use_streams_for_binary   在JDBC读写binary (二进制)或serializable (可序列化) 的类型时使用流(stream)(系统级属性). 取值true | false

hibernate.jdbc.use_get_generated_keys   在数据插入数据库之后，允许使用JDBC3 PreparedStatement.getGeneratedKeys() 来获取数据库生成的key(键)。需要JDBC3+驱动和JRE1.4+, 如果你的数据库驱动在使用Hibernate的标 识生成器时遇到问题，请将此值设为false. 默认情况下将使用连接的元数据来判定驱动的能力. 取值true|false

hibernate.connection.provider_class   自定义ConnectionProvider的类名, 此类用来向Hibernate提供JDBC连接. 取值classname.of.ConnectionProvider

hibernate.connection.isolation   设置JDBC事务隔离级别. 查看java.sql.Connection来了解各个值的具体意义, 但请注意多数数据库都不支持所有的隔离级别. 取值1, 2, 4, 8

hibernate.connection.autocommit   允许被缓存的JDBC连接开启自动提交(autocommit) (不建议). 取值true | false

hibernate.connection.release_mode   指定Hibernate在何时释放JDBC连接. 默认情况下,直到Session被显式关闭或被断开连接时,才会释放JDBC连接. 对于应用程序服务器的JTA数据源, 你应当使用after_statement, 这样在每次JDBC调用后，都会主动的释放连接. 对于非JTA的连接, 使用after_transaction在每个事务结束时释放连接是合理的. auto将为JTA和CMT事务策略选择after_statement, 为JDBC事务策略选择after_transaction. 取值on_close | after_transaction | after_statement | auto

hibernate.connection.<propertyName>   将JDBC属性propertyName传递到DriverManager.getConnection()中去.  

hibernate.jndi.<propertyName>   将属性propertyName传递到JNDI InitialContextFactory中去.  

表 3.5.   Hibernate缓存属性

属性名   用途  

hibernate.cache.provider_class   自定义的CacheProvider的类名. 取值classname.of.CacheProvider

hibernate.cache.use_minimal_puts   以频繁的读操作为代价, 优化二级缓存来最小化写操作. 在Hibernate3中，这个设置对的集群缓存非常有用, 对集群缓存的实现而言，默认是开启的. 取值true|false

hibernate.cache.use_query_cache   允许查询缓存, 个别查询仍然需要被设置为可缓存的. 取值true|false

hibernate.cache.use_second_level_cache   能用来完全禁止使用二级缓存. 对那些在类的映射定义中指定<cache>的类，会默认开启二级缓存. 取值true|false

hibernate.cache.query_cache_factory   自定义实现QueryCache接口的类名, 默认为内建的StandardQueryCache. 取值classname.of.QueryCache

hibernate.cache.region_prefix   二级缓存区域名的前缀. 取值prefix

hibernate.cache.use_structured_entries   强制Hibernate以更人性化的格式将数据存入二级缓存. 取值true|false

表 3.6.   Hibernate事务属性

属性名   用途  

hibernate.transaction.factory_class   一个TransactionFactory的类名, 用于Hibernate Transaction API (默认为JDBCTransactionFactory). 取值classname.of.TransactionFactory

jta.UserTransaction   一个JNDI名字，被JTATransactionFactory用来从应用服务器获取JTA UserTransaction. 取值jndi/composite/name

hibernate.transaction.manager_lookup_class   一个TransactionManagerLookup的类名 - 当使用JVM级缓存，或在JTA环境中使用hilo生成器的时候需要该类. 取值classname.of.TransactionManagerLookup

hibernate.transaction.flush_before_completion   如果开启, session在事务完成后将被自动清洗(flush)。 现在更好的方法是使用自动session上下文管理。取值true | false

hibernate.transaction.auto_close_session   如果开启, session在事务完成后将被自动关闭。 现在更好的方法是使用自动session上下文管理。取值true | false

表 3.7.   其他属性

属性名   用途  

hibernate.current_session_context_class   为"当前" Session指定一个(自定义的)策略。eg.jta | thread | custom.Class

hibernate.query.factory_class   选择HQL解析器的实现. 取值org.hibernate.hql.ast.ASTQueryTranslatorFactory or org.hibernate.hql.classic.ClassicQueryTranslatorFactory

hibernate.query.substitutions   将Hibernate查询中的符号映射到SQL查询中的符号 (符号可能是函数名或常量名字). 取值hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC

hibernate.hbm2ddl.auto   在SessionFactory创建时，自动检查数据库结构，或者将数据库schema的DDL导出到数据库. 使用 create-drop时,在显式关闭SessionFactory时，将drop掉数据库schema. 取值validate | update | create | create-drop

hibernate.cglib.use_reflection_optimizer   开启CGLIB来替代运行时反射机制(系统级属性). 反射机制有时在除错时比较有用. 注意即使关闭这个优化, Hibernate还是需要CGLIB. 你不能在hibernate.cfg.xml中设置此属性. 取值true | false

3.4.1.   SQL方言 你应当总是为你的数据库将hibernate.dialect属性设置成正确的 org.hibernate.dialect.Dialect子类. 如果你指定一种方言, Hibernate将为上面列出的一些属性使用合理的默认值, 为你省去了手工指定它们的功夫.

表 3.8.   Hibernate SQL方言 (hibernate.dialect)

RDBMS 方言  

DB2 org.hibernate.dialect.DB2Dialect  

DB2 AS/400 org.hibernate.dialect.DB2400Dialect  

DB2 OS390 org.hibernate.dialect.DB2390Dialect  

PostgreSQL org.hibernate.dialect.PostgreSQLDialect  

MySQL org.hibernate.dialect.MySQLDialect  

MySQL with InnoDB org.hibernate.dialect.MySQLInnoDBDialect  

MySQL with MyISAM org.hibernate.dialect.MySQLMyISAMDialect  

Oracle (any version) org.hibernate.dialect.OracleDialect  

Oracle 9i/10g org.hibernate.dialect.Oracle9Dialect  

Sybase org.hibernate.dialect.SybaseDialect  

Sybase Anywhere org.hibernate.dialect.SybaseAnywhereDialect  

Microsoft SQL Server org.hibernate.dialect.SQLServerDialect  

SAP DB org.hibernate.dialect.SAPDBDialect  

Informix org.hibernate.dialect.InformixDialect  

HypersonicSQL org.hibernate.dialect.HSQLDialect  

Ingres org.hibernate.dialect.IngresDialect  

Progress org.hibernate.dialect.ProgressDialect  

Mckoi SQL org.hibernate.dialect.MckoiDialect  

Interbase org.hibernate.dialect.InterbaseDialect  

Pointbase org.hibernate.dialect.PointbaseDialect  

FrontBase org.hibernate.dialect.FrontbaseDialect  

Firebird org.hibernate.dialect.FirebirdDialect  

表 3.9.   Hibernate日志类别

类别   功能  

org.hibernate.SQL   在所有SQL DML语句被执行时为它们记录日志  

org.hibernate.type   为所有JDBC参数记录日志  

org.hibernate.tool.hbm2ddl   在所有SQL DDL语句执行时为它们记录日志  

org.hibernate.pretty   在session清洗(flush)时，为所有与其关联的实体(最多20个)的状态记录日志  

org.hibernate.cache   为所有二级缓存的活动记录日志  

org.hibernate.transaction   为事务相关的活动记录日志  

org.hibernate.jdbc   为所有JDBC资源的获取记录日志  

org.hibernate.hql.AST   在解析查询的时候,记录HQL和SQL的AST分析日志  

org.hibernate.secure   为JAAS认证请求做日志  

org.hibernate   为任何Hibernate相关信息做日志 (信息量较大, 但对查错非常有帮助)  

表 3.10. JTA TransactionManagers

Transaction工厂类   应用程序服务器  

org.hibernate.transaction.JBossTransactionManagerLookup   JBoss

org.hibernate.transaction.WeblogicTransactionManagerLookup   Weblogic

org.hibernate.transaction.WebSphereTransactionManagerLookup   WebSphere

org.hibernate.transaction.WebSphereExtendedJTATransactionLookup   WebSphere 6

org.hibernate.transaction.OrionTransactionManagerLookup   Orion

org.hibernate.transaction.ResinTransactionManagerLookup   Resin

org.hibernate.transaction.JOTMTransactionManagerLookup   JOTM

org.hibernate.transaction.JOnASTransactionManagerLookup   JOnAS

org.hibernate.transaction.JRun4TransactionManagerLookup   JRun4

org.hibernate.transaction.BESTransactionManagerLookup   Borland ES

A、Lifecycle与Validatable

 在Hibernate中Lifecycle接口定义如下：

public interface Lifecycle{

 /**

   在实体对象执行save/insert操作之前触发

 **/

 public boolean onSave(Session session) throws CallbackException;

 /**

   在session.update()执行之前触发

 **/

 public boolean onUpdate(Session session) throws CallbackException;

 /**

 在实体对象执行delete操作之前触发

**/

public boolean onDelete(Session session) throws CallbackException;

/**

 在实体对象加载之后触发

**/

public void onLoad(Session session) throws CallbackException;

}

实体对象可以实现Lifecycle接口，来获得在持久化阶段捕获CURD事件，并执行相应动作的能如下所示：

public class User implements Serializable,Lifecycle{

 public boolean onSave(Session s) throws CallbackException{

……

return false;

……

 }

 public boolean onUpdate(Session s) throws CallbackException{

……

return true;

……

 }

 public boolean onDelete(Session s) throws CallbackException{

……

return false;

……

 }

 public boolean onLoad(Session s) throws CallbackException{

……

 }

}

对于onSave,onUpdate,onDelete方法，如果返回true则意味着需要终止执行对应的操作过程。如果在运行时抛出CallbackException，对应的操作也会被终止。

注意在接口中对应的方法中，不要去通过方法的Session参数执行持久化操作，在这些方法中Session无法正常使用，如果必须要执行一些持久化操作，那么需要进行特殊的处理，我们将在Interceptor部分详细讲解。

Hibernate中还定义了Validatable接口，该接口定义如下：

public interface Validatable{

 public void validate() throws ValidationFailure;

}

Validatable接口是用来实现数据验证的，实体类实现Validatable接口，并在接口的validate方法中实现数据验证逻辑，以保证数据输入的合法性。validate方法将会在实体对象持久化前得到调用进行数据验证，与Lifecycle接口中的方法不同，Validatable.validate()方法在实体生命周期中可能被多次调用，因此此方法应该仅限于数据合法性的验证，而不应该实现业务逻辑的验证。

B、Interceptor:

以上是Hibernate提供的Lifecycle接口和Validatable接口，以及使用方法，这两个方法定义了一种自然的回调机制，但是如我们所见，如果想实现对实体的回调拦截，那么相应的实体对象必须实现这两个Hibernate原生接口，这就使代码的可移植性大大下降，因为此时实体类已经不再是一个POJO了，Hibernate的那些天才的设计者们也已经意识到了这个问题，所以又提供了Interceptor接口，为持久化事件的捕获和处理提供了一个非入侵性的解决方案，Interceptor接口通过设置注入来实现持久化事件的捕获和处理，这是典型的IOC（控制反转）设计思想。下面我们就讲解Interceptor接口的技术细节和使用方法。

Hibernate中的Interceptor接口定义如下：

public interface Interceptor{

 //对象初始化之前调用，这时实体对象刚刚被创建，各个属性还都为null,如果在这个方法中修改了实体对象的数据，那么返回true，否则返回null.

 public boolean onLoad(Object entity,Serializable id,Object[] state,

String[] propertyNames,Type[] types) throws CallbackException;

      //Session.flush()在进行脏数据检查时，如果发现实体对象数据已脏，就调用此方法

 public boolean onFlushDirty(Object entity,Serializable id,Object[] state,

String[] propertyNames,Type[] types) throws CallbackException;

 //实体对象被保存前调用，如果在这个方法中修改了实体对象的数据，那么返回true，否则返回null.

 public boolean onSave(Object entity,Serializable id,Object[] state,

String[] propertyNames,Type[] types) throws CallbackException;

     //通过Session删除一个实体对象前调用

 public boolean onDelete(Object entity,Serializable id,Object[] state,

String[] propertyNames,Type[] types) throws CallbackException;

     //Session执行flush()之前调用

public boolean preFlush(Iterator entities) throws CallbackException;

     //Session执行flush()之后，所有的SQL语句都执行完毕后调用

public boolean postFlush(Iterator entities) throws CallbackException;

     //当执行saveOrUpdate方法时调用，判断实体对象是否已经保存

     public Boolean isUnsaved(Object entity);

     //执行Session.flush()方法时，调用此方法判断该对象是否为脏对象，这提供了脏数据检查的另一个回调拦截机制

public int[] findDirty(Object entity,Serializable id,Object[] state,

String[] propertyNames,Type[] types) throws CallbackException;

     //当Session构造实体类实例前调用，如果返回null,Hibernate会按照默认方式构造实体类对象实例

public Object findDirty(Class clazz,Serializable id) throws CallbackException;

}

Intercepter不需要实体对象来实现，而是通过开发人员定义一个实现Interceptor接口的类，然后在创建Hibernate Session时，通过将Interceptor对象设置进所创建的Session，这样通过这个Session来操作的实体对象，就都会具有对持久化动作的回调拦截能力。在Hibernate中Interceptor对象共有两种用法，如下所述：

1、                SessionFactory.openSession(Interceptor)：为每个Session实例分配一个拦截Interceptor，这个拦截接口对象，存放在Session范围内，为每个Session实例所专用。

2、                Configuration.setInterceptor(Interceptor):为SessionFactory实例分配一个Interceptor实例，这个Interceptor实例存放在SessionFactory范围内，被每个Session实例所共享。

A、Interceptor的典型应用：

下面我实现一个利用Interceptor接口实现日志数据稽核的功能，所谓日志数据稽核就是针对一些关键操作进行记录，以便作为业务跟踪的基础依据。

首先定义用于记录操作的实体：

public class AudiLog implements Serializable{

 private String id;

 private String user;

 private String action;

 private String entityName;

 private String comment;

 private Long logtime;

 …getter/setter…

}

接下来定义Interceptor接口的实现类和用于持久化操作的AuditDAO类：

package com.lbs.apps.unemployment.subsidy.beforeinfoimport.util;

import net.sf.hibernate.Session;

import net.sf.hibernate.Interceptor;

import Java.io.Serializable;

import net.sf.hibernate.type.Type;

import net.sf.hibernate.HibernateException;

import Java.util.Iterator;

import Java.util.Set;

import Java.util.HashSet;

import com.neusoft.entity.User;

public class MyInterceptor implements Interceptor{

 private Set insertset=new HashSet();

 private Set updateset=new HashSet();

 private Session session;

 private String userID;

 public void setSession(Session session){

    this.session=session

　｝

　public void setUserID(String id){

   this.userID=id;

 }

 public boolean onLoad(Object object, Serializable serializable,

                        Object[] objectArray, String[] stringArray,

                        Type[] typeArray) {

    return false;

 }

 public boolean onFlushDirty(Object object, Serializable serializable,

                              Object[] objectArray, Object[] objectArray3,

                              String[] stringArray, Type[] typeArray) {

    if(object instanceof User){

      insertset.add(object);

    }

    return false;

 }

 public boolean onSave(Object object, Serializable serializable,

                        Object[] objectArray, String[] stringArray,

                        Type[] typeArray) {

    if(object instanceof User){

      updateset.add(object);

    }

    return false;

 }

 public void onDelete(Object object, Serializable serializable,

                       Object[] objectArray, String[] stringArray,

                       Type[] typeArray) {

 }

 public void preFlush(Iterator iterator) {

 }

 public void postFlush(Iterator iterator) {

try{

 if(insertset.size()>0){

   AuditDAO.dolog(“insert”,userID,inserset,session.connection);

 }

 if(updateset.size()>0){

   AuditDAO.dolog(“update”,userID,updateset,session.connection);

 }

}catch(HibernateException he){

 he.printStackTrace();

}

 }

 public Boolean isUnsaved(Object object) {

    return null;

 }

 public int[] findDirty(Object object, Serializable serializable,

                         Object[] objectArray, Object[] objectArray3,

                         String[] stringArray, Type[] typeArray) {

    return null;

 }

 public Object instantiate(Class class0, Serializable serializable) {

    return "";

 }

}

public class AuditDAO{

 public static void doLog(String action,String userID,Set modifySet,Connection connection){

     Session tempsession=HibernateUtil.getSessionFactory().openSession(connection);

     try{

       Iterator it=modifyset.iterator();

       while(it.hasNext()){

         User user=(User)it.next();

         AudiLog log=new AudiLog();

         log.setUserID(userID);

         log.setAction(action);

         log.setComment(user.toString());

         log.setLogTime(new Long(Calendar.getInstance().getTime().getTime()));

         tempsession.save(log);

       }

     }catch(Exception e){

       throw new CallbackException(e);

     }finally{

       try{

         tempsesson.close();

       }catch(HibernateException he){

         throw new CallbackException(he);

       }

     }

 }

}

最后看一下业务逻辑主程序：

SessionFactory sessionfactory=config.buildSessionFactory();

MyInterceptor it=new MyInterceptor();

session=sessionfactory().openSession(it);

it.setUserID(“currentUser”);

it.setSession(session);

User user=new User();

user.setName(“zx”);

Transaction tx=session.beginTransaction();

session.save(user);

tx.commit();

session.close();

这个类主要在使用的时候当作获得数据源的标志使用。
二、建立一个获得和设置上下文的类：

此时在遍历list时就可以(Tree)list.get[i];将每一行的内容变换为一个对象了。

另还可以返回一个Map对象，也就是说在在list里包含多个Map，代码如下
Query query = session.createSQLQuery("select id,name from Tree t where pid in (select id from Tree) ").setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP); //返回一个map,KEY:为DB中名称一致（大小写一致）遍历list时就可以

Map map = (Map)list.get[i];

map.get("id");map.get("name");来取值。按你的SQL语句select后的字段名来作为map的Key，但这个key必须与数据库中的字段名一模一样。

还可以用作函数方面的。如
Query query = session.createSQLQuery("select sum(id) SUMID from Tree t where pid in (select id from Tree)
.addScalar("SUMID",Hibernate.INTEGER)  //转换类型，按DB中的type转
.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP); //返回一个map,KEY:为DB中名称一致（大小写一致）

直接就map.get("SUMID")可以取值了

还有一点就是这个方法在Hibernate3.2版本上才能正常运行。

   


注解：

   











CLOB类型，类型声明为String即可：

   


注解：

SecondaryTables
当一个entity class映射到一个主表和多个从表时，用SecondaryTables来定义各个从表的属性。
元数据属性说明：
· value： 定义一个SecondaryTable数组，指定每个从表的属性。
        
@Table(name = "CUSTOMER")
@SecondaryTables( value = {
@SecondaryTable(name = "CUST_NAME", pkJoin = { @PrimaryKeyJoinColumn(name = "STMO_ID", referencedColumnName = "id") }),
@SecondaryTable(name = "CUST_ADDRESS", pkJoin = { @PrimaryKeyJoinColumn(name = "STMO_ID", referencedColumnName = "id") }) })
public class Customer {}

UniqueConstraint
UniqueConstraint定义在Table或SecondaryTable元数据里，用来指定建表时需要建唯一约束的列。
元数据属性说明：
· columnNames:定义一个字符串数组，指定要建唯一约束的列名。
        
@Entity
@Table(name="EMPLOYEE",
uniqueConstraints={@UniqueConstraint(columnNames={"EMP_ID", "EMP_NAME"})}
)
public class Employee { ... }

Column
Column元数据定义了映射到数据库的列的所有属性：列名，是否唯一，是否允许为空，是否允许更新等。
元数据属性说明：
· name:列名。
· unique: 是否唯一
· nullable: 是否允许为空
· insertable: 是否允许插入
· updatable: 是否允许更新
· columnDefinition: 定义建表时创建此列的DDL
· secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字。
        
public class Person {
@Column(name = "PERSONNAME", unique = true, nullable = false, updatable = true)
private String name;
@Column(name = "PHOTO", columnDefinition = "BLOB NOT NULL", secondaryTable="PER_PHOTO")
private byte[] picture;

JoinColumn
如果在entity class的field上定义了关系（one2one或one2many等），我们通过JoinColumn来定义关系的属性。JoinColumn的大部分属性和Column类似。
元数据属性说明：
· name:列名。
· referencedColumnName:该列指向列的列名（建表时该列作为外键列指向关系另一端的指定列）
· unique: 是否唯一
· nullable: 是否允许为空
· insertable: 是否允许插入
· updatable: 是否允许更新
· columnDefinition: 定义建表时创建此列的DDL
· secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字。
下面的代码说明Custom和Order是一对一关系。在Order对应的映射表建一个名为CUST_ID的列，该列作为外键指向Custom对应表中名为ID的列。
        
public class Custom {
@OneToOne
@JoinColumn(
name="CUST_ID", referencedColumnName="ID", unique=true, nullable=true, updatable=true)
public Order getOrder() {
return order;
}

JoinColumns
如果在entity class的field上定义了关系（one2one或one2many等），并且关系存在多个JoinColumn，用JoinColumns定义多个JoinColumn的属性。
元数据属性说明：
· value: 定义JoinColumn数组，指定每个JoinColumn的属性。
下面的代码说明Custom和Order是一对一关系。在Order对应的映射表建两列，一列名为CUST_ID，该列作为外键指向Custom对应表中名为ID的列,另一列名为CUST_NAME，该列作为外键指向Custom对应表中名为NAME的列。
        
public class Custom {
@OneToOne
@JoinColumns({
@JoinColumn(name="CUST_ID", referencedColumnName="ID"),
@JoinColumn(name="CUST_NAME", referencedColumnName="NAME")
})
public Order getOrder() {
return order;
}

Id
声明当前field为映射表中的主键列。id值的获取方式有五种：TABLE, SEQUENCE, IDENTITY, AUTO, NONE。Oracle和DB2支持SEQUENCE，SQL Server和Sybase支持IDENTITY,mysql支持AUTO。所有的数据库都可以指定为AUTO，我们会根据不同数据库做转换。NONE (默认)需要用户自己指定Id的值。元数据属性说明：
· generate():主键值的获取类型
· generator():TableGenerator的名字（当generate=GeneratorType.TABLE才需要指定该属性）
下面的代码声明Task的主键列id是自动增长的。(Oracle和DB2从默认的SEQUENCE取值，SQL Server和Sybase该列建成IDENTITY，mysql该列建成auto increment。)
        
@Entity
@Table(name = "OTASK")
public class Task {
@Id(generate = GeneratorType.AUTO)
public Integer getId() {
return id;
}
}

IdClass
当entity class使用复合主键时，需要定义一个类作为id class。id class必须符合以下要求:类必须声明为public，并提供一个声明为public的空构造函数。必须实现Serializable接，覆写 equals()和hashCode（）方法。entity class的所有id field在id class都要定义，且类型一样。
元数据属性说明：
· value: id class的类名
   public class EmployeePK implements Java.io.Serializable{
       String empName;
       Integer empAge;

       public EmployeePK(){}
       public boolean equals(Object obj){ ......}
       public int hashCode(){......}
    }

    @IdClass(value=com.acme.EmployeePK.class)
    @Entity(access=FIELD)
    public class Employee {
        @Id String empName;
        @Id Integer empAge;
    }
    
     
MapKey
在一对多，多对多关系中，我们可以用Map来保存集合对象。默认用主键值做key，如果使用复合主键，则用id class的实例做key，如果指定了name属性，就用指定的field的值做key。
元数据属性说明：
· name: 用来做key的field名字
下面的代码说明Person和Book之间是一对多关系。Person的books字段是Map类型，用Book的isbn字段的值作为Map的key。
        

@Table(name = "PERSON")
public class Person {
@OneToMany(targetEntity = Book.class, cascade = CascadeType.ALL, mappedBy = "person")
@MapKey(name = "isbn")
private Map books = new HashMap();
}

OrderBy
在一对多，多对多关系中，有时我们希望从数据库加载出来的集合对象是按一定方式排序的，这可以通过OrderBy来实现，默认是按对象的主键升序排列。
元数据属性说明：
· value: 字符串类型，指定排序方式。格式为"fieldName1 [ASC|DESC],fieldName2 [ASC|DESC],......",排序类型可以不指定，默认是ASC。
下面的代码说明Person和Book之间是一对多关系。集合books按照Book的isbn升序，name降序排列。
        

@Table(name = "MAPKEY_PERSON")
public class Person {
@OneToMany(targetEntity = Book.class, cascade = CascadeType.ALL, mappedBy = "person")
@OrderBy(name = "isbn ASC, name DESC")
private List books = new ArrayList();
}

PrimaryKeyJoinColumn
在三种情况下会用到PrimaryKeyJoinColumn。
· 继承。
· entity class映射到一个或多个从表。从表根据主表的主键列（列名为referencedColumnName值的列），建立一个类型一样的主键列，列名由name属性定义。
· one2one关系，关系维护端的主键作为外键指向关系被维护端的主键，不再新建一个外键列。
元数据属性说明：
· name:列名。
· referencedColumnName:该列引用列的列名
· columnDefinition: 定义建表时创建此列的DDL
下面的代码说明Customer映射到两个表，主表CUSTOMER,从表CUST_DETAIL，从表需要建立主键列CUST_ID，该列和主表的主键列id除了列名不同，其他定义一样。
          @Entity
@Table(name="CUSTOMER")
@SecondaryTable(name="CUST_DETAIL",pkJoin=@PrimaryKeyJoinColumn(name="CUST_ID"，referencedColumnName="id"))
public class Customer {
@Id(generate = GeneratorType.AUTO)
public Integer getId() {
return id;
}
}

下面的代码说明Employee和EmployeeInfo是一对一关系，Employee的主键列id作为外键指向EmployeeInfo的主键列INFO_ID。
        
@Table(name = "Employee")
public class Employee {
@OneToOne
@PrimaryKeyJoinColumn(name = "id", referencedColumnName="INFO_ID")
EmployeeInfo info;
}

PrimaryKeyJoinColumns
如果entity class使用了复合主键，指定单个PrimaryKeyJoinColumn不能满足要求时，可以用PrimaryKeyJoinColumns来定义多个PrimaryKeyJoinColumn。
元数据属性说明：
· value: 一个PrimaryKeyJoinColumn数组，包含所有PrimaryKeyJoinColumn。
下面的代码说明了Employee和EmployeeInfo是一对一关系。他们都使用复合主键，建表时需要在Employee表建立一个外键，从Employee的主键列id,name指向EmployeeInfo的主键列INFO_ID和INFO_NAME.
        
@Entity
@IdClass(EmpPK.class)
@Table(name = "EMPLOYEE")
public class Employee {
private int id;
private String name;
private String address;
@OneToOne(cascade = CascadeType.ALL)
@PrimaryKeyJoinColumns({
@PrimaryKeyJoinColumn(name="id", referencedColumnName="INFO_ID"),
@PrimaryKeyJoinColumn(name="name" , referencedColumnName="INFO_NAME")})
EmployeeInfo info;
}
@Entity
@IdClass(EmpPK.class)
@Table(name = "EMPLOYEE_INFO")
public class EmployeeInfo {
@Id
@Column(name = "INFO_ID")
private int id;
@Id
@Column(name = "INFO_NAME")
private String name;
}

Transient
Transient用来注释entity的属性，指定的这些属性不会被持久化，也不会为这些属性建表。
        
@Transient
private String name;

Version
Version指定实体类在乐观事务中的version属性。在实体类重新由EntityManager管理并且加入到乐观事务中时，保证完整性。每一个类只能有一个属性被指定为version，version属性应该映射到实体类的主表上。
下面的代码说明versionNum属性作为这个类的version，映射到数据库中主表的列名是OPTLOCK。
        
@Version
@Column("OPTLOCK")
protected int getVersionNum() { return versionNum; }

Lob
Lob指定一个属性作为数据库支持的大对象类型在数据库中存储。使用LobType这个枚举来定义Lob是二进制类型还是字符类型。
LobType枚举类型说明：
· BLOB 二进制大对象，Byte[]或者Serializable的类型可以指定为BLOB。
· CLOB 字符型大对象，char[]、Character[]或String类型可以指定为CLOB。
元数据属性说明：
· fetch： 定义这个字段是lazy loaded还是eagerly fetched。数据类型是FetchType枚举，默认为LAZY,即lazy loaded.
· type： 定义这个字段在数据库中的JDBC数据类型。数据类型是LobType枚举，默认为BLOB。
下面的代码定义了一个BLOB类型的属性和一个CLOB类型的属性。
        
@Lob
@Column(name="PHOTO" columnDefinition="BLOB NOT NULL")
protected JPEGImage picture;
@Lob(fetch=EAGER, type=CLOB)
@Column(name="REPORT")
protected String report;

JoinTable
JoinTable在many-to-many关系的所有者一边定义。如果没有定义JoinTable，使用JoinTable的默认值。
元数据属性说明：
· table:这个join table的Table定义。
· joinColumns:定义指向所有者主表的外键列，数据类型是JoinColumn数组。
· inverseJoinColumns:定义指向非所有者主表的外键列，数据类型是JoinColumn数组。
下面的代码定义了一个连接表CUST和PHONE的join table。join table的表名是CUST_PHONE，包含两个外键，一个外键是CUST_ID，指向表CUST的主键ID，另一个外键是PHONE_ID，指向表PHONE的主键ID。
        
@JoinTable(
table=@Table(name=CUST_PHONE),
joinColumns=@JoinColumn(name="CUST_ID", referencedColumnName="ID"),
inverseJoinColumns=@JoinColumn(name="PHONE_ID", referencedColumnName="ID")
)

TableGenerator
TableGenerator定义一个主键值生成器，在Id这个元数据的generate＝TABLE时，generator属性中可以使用生成器的名字。生成器可以在类、方法或者属性上定义。
生成器是为多个实体类提供连续的ID值的表，每一行为一个类提供ID值，ID值通常是整数。
元数据属性说明：
· name:生成器的唯一名字，可以被Id元数据使用。
· table:生成器用来存储id值的Table定义。
· pkColumnName:生成器表的主键名称。
· valueColumnName:生成器表的ID值的列名称。
· pkColumnValue:生成器表中的一行数据的主键值。
· initialValue:id值的初始值。
· allocationSize:id值的增量。
下面的代码定义了两个生成器empGen和addressGen，生成器的表是ID_GEN。
        
@Entity public class Employee {
...
@TableGenerator(name="empGen",
table=@Table(name="ID_GEN"),
pkColumnName="GEN_KEY",
valueColumnName="GEN_VALUE",
pkColumnValue="EMP_ID",
allocationSize=1)
@Id(generate=TABLE, generator="empGen")
public int id;
...
}
@Entity public class Address {
...
@TableGenerator(name="addressGen",
table=@Table(name="ID_GEN"),
pkColumnValue="ADDR_ID")
@Id(generate=TABLE, generator="addressGen")
public int id;
...
}

SequenceGenerator
SequenceGenerator定义一个主键值生成器，在Id这个元数据的generator属性中可以使用生成器的名字。生成器可以在类、方法或者属性上定义。生成器是数据库支持的sequence对象。
元数据属性说明：
· name:生成器的唯一名字，可以被Id元数据使用。
· sequenceName:数据库中，sequence对象的名称。如果不指定，会使用提供商指定的默认名称。
· initialValue:id值的初始值。
· allocationSize:id值的增量。
下面的代码定义了一个使用提供商默认名称的sequence生成器。
        
@SequenceGenerator(name="EMP_SEQ", allocationSize=25)

DiscriminatorColumn
DiscriminatorColumn定义在使用SINGLE_TABLE或JOINED继承策略的表中区别不继承层次的列。
元数据属性说明：
· name:column的名字。默认值为TYPE。
· columnDefinition:生成DDL的sql片断。
· length:String类型的column的长度，其他类型使用默认值10。
下面的代码定义了一个列名为DISC，长度为20的String类型的区别列。
        
@Entity
@Table(name="CUST")
@Inheritance(strategy=SINGLE_TABLE,
discriminatorType=STRING,
discriminatorValue="CUSTOMER")
@DiscriminatorColumn(name="DISC", length=20)
public class Customer { ... }

对需要解决的问题的描述：

把一个enum类型的字段持久化到数据库中，写入到数据库中的值为Integer类型，且有特定的含义：



我们知道，如果我们某一个pojo对象的某个属性为enum类型的话，在持久化的时候可能会出现如下两种情况:

1、数据库中enum_col的类型为(oracle:number或者sql server:numeric)

   @Column(name="enum_col")

   public MyEnum getCol(){

      return this.col;

   }

此种情况下，存到数据库中的数据时col.ordinal()所返回的int数值

2、数据库中enum_col的类型为(oracle:varchar2,或者sql server：varchar)

   @Column(name="enum_col")

   public MyEnum getCol(){

      return this.col;

   }

此种情况下，存储到数据库中的值为定义此enum是所使用的名字如：

   public enum MyEnum{

       DATA1,

       DATA2;

   }

则，如果this.col代表DATA1则写DATA1到数据库中去。

那么我们通过什么样的手段来改变这些呢？如果使用的是hibernate的话可以借助于UserType来实现：

首先、定义一个enum MyEnumData，(在持久化的时候把其code写到数据库中去)

package ec.snow.hib.pojos;

public enum MyEnumData{

   DATA1("data1",100),

   DATA2("data2",200),

   DATA3("data3",300);

   private String name;

   private int code;

   

   public int getCode(){

      return this.code;

   }

   public String getName(){

      return this.name;

   }

   MyEnumData(String name,int code){

      this.name = name;

      this.code = code;

   }

//辅助方法，主要在UserType的实现中通过相应的code得到MyEnumData



public static MyEnumData formCode(int code){



       for(MyEnumData u:MyEnumData.values()){

          if(u.getCode()==code)return u;

       }

       return null;

   }

}

//*******************************

接下来、定义相应的UserType的实现：

package com.snow.hib.pojos;

import Java.io.Serializable;

import Java.sql.PreparedStatement;

import Java.sql.ResultSet;

import Java.sql.SQLException;

import Java.sql.Types;

import org.hibernate.HibernateException;

import org.hibernate.usertype.UserType;

/**

 *@author anwxAn Weixiao

 *@version $Id$

 */

public class MyEnumDataType implements UserType {

   

    public int[] sqlTypes() {   

        int[] types = {Types.INTEGER};         

        return types;   

    }   

  

    public Class returnedClass(){

        return UserTitle.class;   

    }   

  

    public boolean equals(Object x, Object y) throws HibernateException {   

        return x == y;   

    }   

  

    public int hashCode(Object x) throws HibernateException {   

        return x.hashCode();   

    }   

  

    public Object nullSafeGet(ResultSet rs, String[] names, Object owner)

throws HibernateException, SQLException {   

        int code = rs.getInt(names[0]);   

        return rs.wasNull() ? null : MyEnumData.formCode(code);//notice code to use    

    }   

  

    public void nullSafeSet(PreparedStatement st, Object value, int index) 

throws HibernateException, SQLException {   

        if (value == null) {   

            st.setNull(index, Types.INTEGER);   

        } else {   

            st.setInt(index, ((MyEnumData) value).getCode());   

        }   

    }   

  

    public Object deepCopy(Object value) throws HibernateException {   

        return value;   

    }   

  

    public boolean isMutable() {   

        return false;   

    }   

  

    public Serializable disassemble(Object value) throws HibernateException {   

        return (Serializable) deepCopy(value);   

    }   

  

    public Object assemble(Serializable cached, Object owner) throws HibernateException {   

        return deepCopy(cached);   

    }   

  

    public Object replace(Object original, Object target, Object owner) 

throws HibernateException {   

        return deepCopy(original);   

    }     

} 

//**********************************

最后、通过自定义的UserType来实现对enum的有效持久化

package com.snow.hib.pojos;

import Java.io.Serializable;

import Javax.persistence.Column;

import Javax.persistence.Entity;

import Javax.persistence.Id;

import Javax.persistence.Table;

import org.hibernate.annotations.Type;

/**

 *@author anwxAn Weixiao

 *@version

 */

@Entity

@Table(name="my_def_type")

public class UseMyEnumData implements Serializable{   

   

    private static final long serialVersionUID = 6905822670746966787L;

    private String id;

    private String username;     

    private MyEnumData enumData;   

    

    @Column(updatable = true,nullable = true,name="MY_TITLE")

    @Type(type="com.snow.hib.pojos.MyEnumDataType")

    public MyEnumData getEnumData() {   

        return enumData;   

    }   

  

    public void setEnumData(MyEnumData data) {   

        this.enumData = data;   

    }

    

    @Column(updatable=true,nullable = true,name="USER_NAME")

    public String getUsername() {   

        return username;   

    }  

    public void setUsername(String username) {   

        this.username = username;   

    }

 /**

  * @return Returns the id.

  */

    @Id

 public String getId() {

  return id;

 }

 /**

  * @param id The id to set.

  */

 public void setId(String id) {

  this.id = id;

 }    

} 

下面是测试结果：

//***************************Test result

       UseMyEnumData data = new UseMyEnumData();

          data.setId("123456");

          data.setTitle(MyEnumData.DATA1);

          data.setUsername("chsi:manager");

          manager.saveUseMyEnumData(title);

则数据库中写入的数据为： [123456 100 chsi:manager] 





还有一点需要注意的是，如果系统中用来影射enum类型的数据可能有出现空值的时候hibernate在处理影射的时候会

把Enum类型影射为null,也就是没有对应的数据，这在处理旧有系统数据的时候会有用处哦…………

Lucene集成——作为强大高效的检索引擎，Lucene的美名早已久经考验了；
数据的自动插入和更新——当一个对象通过Hibernate添加或更新时，索引也会相应进行透明的更新；
支持众多复杂的搜索方式——可快速的使用通配符进行搜索，以及多关键词全文检索（multi-word text searches）和近似或同义词搜索（approximation/synonym searches），或根据相关性排列搜索结果；
搜索集群（Search Clustering）——Hibernate Search提供了内建搜索集群解决方案，其中包括一个基于JMS的异步查询和索引系统；
对Lucene API接口的直接调用——如果用户打算处理某些特别复杂的问题，可以在查询中直接使用Lucene提供的API接口；
对Lucene的自动管理——Hibernate Search可以管理并优化Lucene的索引，并且非常高效地使用Lucene的API接口。
项目的主要目标包含以下几个方面：

易用性——和Hibernate的ORM映射一样，Hibernate Search帮助用户实现了业务90%的工作，并且使用户专注于余下更为困难的业务实现部分；
和已有的Hibernate/JPA编程模型保持一致性——更轻松地集成Hibernate/JPA编程模型是“一开始就致力要实现的目标”。

scroll是用JDBC2.0的可滚动结果集实现；query.setMaxResults();query.setFirstResult()是数据库SQL语句实现。

在数据库进行分页是首选的方式。数据库分页实际上是利用数据库本身SQL扩展的功能进行分页，例如MySQL的 limit 0,50这样的SQL语句。不但速度快，而且非常节省内存。不过不是每种数据库的都有这种分页支持的SQL，例如SQL Server就不支持。

scroll是利用JDBC2.0的功能做分页的，那么就完全取决于特定数据库的JDBC Driver的实现了。事实上大部分JDBC Driver都是把所有的结果集都一次取到内存，然后再分页的。如果这个结果集非常大，例如几万条，不但程序执行速度会很慢，而且很容易导致out of memory。当然个别JDBC Driver使用了服务器端游标来实现，那么就不会导致这种问题，例如jTDS。

q      Object execute(HibernateCallback action)

q      List execute(HibernateCallback action)

这两个方法都需要一个HibernateCallback的实例，HibernateCallback实例可在任何有效的Hibernate数据访问中使用。程序开发者通过HibernateCallback，可以完全使用Hibernate灵活的方式来访问数据库，解决Spring封装Hibernate后灵活性不足的缺陷。HibernateCallback是一个接口，该接口只有一个方法doInHibernate(org.hibernate.Session session)，该方法只有一个参数Session。

通常，程序中采用实现HibernateCallback的匿名内部类来获取HibernateCallback的实例，方法doInHibernate的方法体就是Spring执行的持久化操作。具体代码如下：

public class PersonDaoImpl implements PersonDao

{
 // 私有实例变量保存SessionFactory
 private SessionFactory sessionFactory;
 // 依赖注入必须的setter方法
 public void setSessionFactory(SessionFactory sessionFactory){
  this.sessionFactory = sessionFactory;
 }
 /**
  *
  * 通过人名查找所有匹配该名的Person实例
  *
  * @param name
  *            匹配的人名
  *
  * @return 匹配该任命的全部Person集合
  *
  */
 public List findPersonsByName(final String name){
  // 创建HibernateTemplate实例
  HibernateTemplate hibernateTemplate =new HibernateTemplate(this.sessionFactory);
        // 返回HibernateTemplate的execute的结果
  return (List) hibernateTemplate.execute(
    // 创建匿名内部类
    new HibernateCallback(){
     public Object doInHibernate(Session session) throws HibernateException{
      // 使用条件查询的方法返回
      List result = session.createCriteria(Person.class)
       .add(Restrictions.like("name", name+"%").list();
      return result;
                     }
    });
    }
}

q      void delete(Object entity)：删除指定持久化实例

q      deleteAll(Collection entities)：删除集合内全部持久化类实例

q      find(String queryString)：根据HQL查询字符串来返回实例集合

q      findByNamedQuery(String queryName)：根据命名查询返回实例集合

q      get(Class entityClass, Serializable id)：根据主键加载特定持久化类的实例

q      save(Object entity)：保存新的实例

q      saveOrUpdate(Object entity)：根据实例状态，选择保存或者更新

q      update(Object entity)：更新实例的状态，要求entity是持久状态

q      setMaxResults(int maxResults)：设置分页的大小

不过这里面也有些陷阱:如果你的测试还是会把数据写入了数据库的话,可能是由于你加载的spring配置文件里有多个事务管理器或session工厂,从而导致AbstractTransactionalDataSourceSpringContextTests没有获得正确的TransactionManager或SessionFactory,所以就没能回滚不过这种错误也不太容易犯,因为AbstractTransactionalDataSourceSpringContextTests默认按类型组装,如果她发现有多个TransactionManager类型的bean是要报错的,此时你需要调用setAutowireMode(this.AUTOWIRE_BY_NAME);使其按名称组装。

另外值得注意的是，使用MYSQL时候表的类型选择。例如

CREATE TABLE `myisam` (
  `id` int(11) NOT NULL auto_increment,
  `name` varchar(100) default NULL,
  `content` text,
  PRIMARY KEY  (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=gbk;
这时候应该把类型改为InnoDB。

MySQL存储引擎包括处理事务安全表的引擎和处理非事务安全表的引擎：· MyISAM管理非事务表。它提供高速存储和检索，以及全文搜索能力。MyISAM在所有MySQL配置里被支持，它是默认的存储引擎，除非你配置 MySQL默认使用另外一个引擎。 ·MEMORY存储引擎提供“内存中”表。MERGE存储引擎允许集合将被处理同样的MyISAM表作为一个单独的表。就像MyISAM一样， MEMORY和MERGE存储引擎处理非事务表，这两个引擎也都被默认包含在MySQL中。 释：MEMORY存储引擎正式地被确定为HEAP引擎。· InnoDB和BDB存储引擎提供事务安全表。BDB被包含在为支持它的操作系统发布的MySQL-Max二进制分发版里。InnoDB也默认被包括在所 有MySQL 5.1二进制分发版里，你可以按照喜好通过配置MySQL来允许或禁止任一引擎。·EXAMPLE存储引擎是一个“存根”引擎，它不做什么。你可以用这个 引擎创建表，但没有数据被存储于其中或从其中检索。

<!--   <filter>
  <filter-name>Set Character Encoding</filter-name>
  <filter-class>com.founder.study.forum.helper.FilterChar</filter-class>
  <init-param>
   <param-name>encoding</param-name>
   <param-value>UTF-8</param-value>
  </init-param>
 </filter>-->
    <filter>
        <filter-name>webwork</filter-name>
        <filter-class>com.opensymphony.webwork.dispatcher.FilterDispatcher</filter-class>
    </filter>
<!--   <filter>
        <filter-name>sitemesh</filter-name>
        <filter-class>com.opensymphony.module.sitemesh.filter.PageFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>sitemesh</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
 <filter-mapping>
  <filter-name>Set Character Encoding</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>-->
    <filter-mapping>
        <filter-name>webwork</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

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

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>default.jsp</welcome-file>
        <welcome-file>index.html</welcome-file>
    </welcome-file-list>
    <!--
        This typically isn't required, as the taglib is included in webwork.jar.
        If you really need a taglib configuration within web.xml, copy webwork/src/java/META-INF/taglib.tld
        to the WEB-INF directory as webwork.tld.
     -->
    <taglib>
        <taglib-uri>webwork</taglib-uri>
        <taglib-location>/WEB-INF/lib/webwork-2.2.4.jar</taglib-location>
    </taglib>
    <!-- <taglib>
  <taglib-uri>sitemesh-decorator</taglib-uri>
  <taglib-location>/WEB-INF/sitemesh-decorator.tld</taglib-location>
 </taglib>
 <taglib>
  <taglib-uri>sitemesh-page</taglib-uri>
  <taglib-location>/WEB-INF/sitemesh-page.tld</taglib-location>
 </taglib>-->
</web-app>

xwork.xml
<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.1.1//EN" "http://www.opensymphony.com/xwork/xwork-1.1.1.dtd">

<xwork>
 <include file="webwork-default.xml" />
   
 <package name="default" extends="webwork-default">
    
     <interceptors>
         <interceptor-stack name="modelParamsStack">
           <interceptor-ref name="model-driven" />
            <interceptor-ref name="params" />
         </interceptor-stack>
     </interceptors>
    
  
 </package>
</xwork>

webwork.properties
webwork.objectFactory = spring
webwork.devMode = true
webwork.tag.altSyntax=true
webwork.locale=zh_CN
webwork.i18n.encoding=UTF-8
webwork.custom.i18n.resources=com.founder.study.forum.resource.ApplicationResources

jdbc.properties
# Properties file with JDBC-related settings.
# Applied by PropertyPlaceholderConfigurer from "applicationContext-*.xml".
# Targeted at system administrators, to avoid touching the context XML files.

jdbc.driverClassName=org.gjt.mm.mysql.Driver
jdbc.url=jdbc:mysql://localhost:3306/forum?useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.show_sql=true
hibernate.hbm2ddl.auto=update

applicationContext.xml

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

<beans default-autowire="byName">
<!-- JDBC Config /author Jerome_mao-->
 <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name="location" value="/WEB-INF/jdbc.properties" />
 </bean>
<!-- Config DateSource /author Jerome_mao-->
 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  <property name="driverClassName" value="${jdbc.driverClassName}" />
  <property name="url" value="${jdbc.url}" />
  <property name="username" value="${jdbc.username}" />
  <property name="password" value="${jdbc.password}" />
 </bean>

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" singleton="true">
 <property name="dataSource">
  <ref local="dataSource" />
 </property>
   <property name="mappingResources">
  <list>
   <value>com/founder/study/forum/model/Threadgroups.hbm.xml</value>
   <value>com/founder/study/forum/model/User.hbm.xml</value>
   <value>com/founder/study/forum/model/Userrole.hbm.xml</value>
  </list>
 </property>
<property name="hibernateProperties">
  <props>
   <prop key="hibernate.dialect">${hibernate.dialect}</prop>
   <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
<!--   <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>-->
  </props>
</property> 
</bean>
 
 <!-- Hibernate transaction processing /author Jerome_mao-->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
 <property name="sessionFactory">
  <ref local="sessionFactory" />
 </property>
</bean>

<!-- commerce logic service config -->
<!-- User Service  /author Jerome_mao-->
<bean id="userService" class="com.founder.study.forum.service.impl.UserServiceImpl">
 <property name="userDAO">
  <ref bean="userDAO"/>
 </property>
</bean>
<!-- Data persistent layer  -->
<!-- User login   /author Jerome_mao -->
<bean id="userDAO" class="com.founder.study.forum.dao.hibernate.UserDAOHibernate">
 <property name="sessionFactory">
  <ref local="sessionFactory" />
 </property>
</bean>
<bean id="forumService" class="com.founder.study.forum.service.impl.ForumServiceImpl">
  <property name="forumTypeDAO">
    <ref local="forumTypeDAO"/>
  </property>
</bean>
<bean id="forumTypeDAO" class="com.founder.study.forum.dao.hibernate.ForumTypeDAOHibernate">
  <property name="sessionFactory">
    <ref local="sessionFactory"/>
  </property>
</bean>
<bean id="messageService" class="com.founder.study.forum.service.impl.MessageServiceImpl">
  <property name="messageTypeDAO">
    <ref local="messageTypeDAO"/>
  </property>
</bean>
<bean id="messageTypeDAO" class="com.founder.study.forum.dao.hibernate.MessageTypeDAOHibernate">
   <property name="sessionFactory">
     <ref local="sessionFactory"/>
   </property>
</bean>
<bean id="adminService" class="com.founder.study.forum.service.impl.AdminServiceImpl">
  <property name="adminDAO">
    <ref local="adminDAO"/>
  </property>
</bean>
<bean id="adminDAO" class="com.founder.study.forum.dao.hibernate.AdminDAOHibernate">
   <property name="sessionFactory">
     <ref local="sessionFactory"/>
   </property>
</bean>
</beans>