一 ：悲观锁（Pessimistic Locking）
悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定 状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能 真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系 统不会修改数据）。 一个典型的倚赖数据库的悲观锁调用： select * from account where name=”Erica” for update 这条sql 语句锁定了account 表中所有符合检索条件（name=”Erica”）的记录。 本次事务提交之前（事务提交时会释放事务过程中的锁），外界无法修改这些记录。 Hibernate的悲观锁，也是基于数据库的锁机制实现。 下面的代码实现了对查询记录的加锁：

1 String hqlStr  =   " from TUser as user where user.name=’Erica’ " ; 
2 Query query  =  session.createQuery(hqlStr); 
3 query.setLockMode( " user " ,LockMode.UPGRADE);  // 加锁 
4 List userList  =  query.list(); // 执行查询，

获取数据 query.setLockMode 对查询语句中特定别名所对应的记录进行加锁（我们为 TUser类指定了一个别名“user”），这里也就是对返回的所有user记录进行加锁。 观察运行期Hibernate生成的SQL语句： 

1 select tuser0_.id as id, tuser0_.name as name, tuser0_.group_id as group_id, tuser0_.user_type as user_type, tuser0_.sex as sex from t_user tuser0_ where (tuser0_.name = ’Erica’ )  for  update

 这里Hibernate通过使用数据库的for update子句实现了悲观锁机制。 Hibernate的加锁模式有：
? LockMode.NONE ： 无锁机制。
? LockMode.WRITE ：Hibernate在Insert和Update记录的时候会自动 获取。
? LockMode.READ ： Hibernate在读取记录的时候会自动获取。

以上这三种锁机制一般由Hibernate内部使用，如Hibernate为了保证Update 过程中对象不会被外界修改，会在save方法实现中自动为目标对象加上WRITE锁。
 
? LockMode.UPGRADE ：利用数据库的for update子句加锁。
? LockMode. UPGRADE_NOWAIT ：Oracle的特定实现，利用Oracle的for update nowait子句实现加锁。

上面这两种锁机制是我们在应用层较为常用的，加锁一般通过以下方法实现：
Criteria.setLockMode
Query.setLockMode
Session.lock
注意，只有在查询开始之前（也就是Hiberate 生成SQL 之前）设定加锁，才会 真正通过数据库的锁机制进行加锁处理，否则，数据已经通过不包含for update 子句的Select SQL加载进来，所谓数据库加锁也就无从谈起。

二 ：乐观锁（Optimistic Locking）
相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依 靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库 性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。 如一个金融系统，当某个操作员读取用户的数据，并在读出的用户数据的基础上进 行修改时（如更改用户帐户余额），如果采用悲观锁机制，也就意味着整个操作过 程中（从操作员读出数据、开始修改直至提交修改结果的全过程，甚至还包括操作 员中途去煮咖啡的时间），数据库记录始终处于加锁状态，可以想见，如果面对几 百上千个并发，这样的情况将导致怎样的后果。 乐观锁机制在一定程度上解决了这个问题。乐观锁 大多是基于数据版本 （Version）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于 数据库表的版本解决方案中，一般是通过为数据库表增加一个“version”字段来 实现。 读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提 交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数据 版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。 对于上面修改用户帐户信息的例子而言，假设 ：

数据库中帐户信息表中有一个 version字段，当前值为1；而当前帐户余额字段（balance）为$100。
1 ：操作员A 此时将其读出（version=1），并从其帐户余额中扣除$50 （$100-$50）。
2 ： 在操作员A操作的过程中，操作员B也读入此用户信息（version=1），并 从其帐户余额中扣除$20（$100-$20）。
3： 操作员A完成了修改工作，将数据版本号加一（version=2），连同帐户扣 除后余额（balance=$50），提交至数据库更新，此时由于提交数据版本大 于数据库记录当前版本，数据被更新，数据库记录version更新为2。
4： 操作员B完成了操作，也将版本号加一（version=2）试图向数据库提交数 据（balance=$80），但此时比对数据库记录版本时发现，操作员B提交的 数据版本号为2，数据库记录当前版本也为2，不满足“提交版本必须大于记 录当前版本才能执行更新“的乐观锁策略，因此，操作员B 的提交被驳回。 这样，就避免了操作员B 用基于version=1 的旧数据修改的结果覆盖操作 员A的操作结果的可能。

从上面的例子可以看出，乐观锁机制避免了长事务中的数据库加锁开销（操作员A 和操作员B操作过程中，都没有对数据库数据加锁），大大提升了大并发量下的系 统整体性能表现。 需要注意的是，乐观锁机制往往基于系统中的数据存储逻辑，因此也具备一定的局 限性，如在上例中，由于乐观锁机制是在我们的系统中实现，来自外部系统的用户 余额更新操作不受我们系统的控制，因此可能会造成脏数据被更新到数据库中。在 系统设计阶段，我们应该充分考虑到这些情况出现的可能性，并进行相应调整（如 将乐观锁策略在数据库存储过程中实现，对外只开放基于此存储过程的数据更新途 径，而不是将数据库表直接对外公开）。 Hibernate 在其数据访问引擎中内置了乐观锁实现。如果不用考虑外部系统对数 据库的更新操作，利用Hibernate提供的透明化乐观锁实现，将大大提升我们的 生产力。 Hibernate中可以通过class描述符的optimistic-lock属性结合version 描述符指定。
现在，我们为之前示例中的TUser加上乐观锁机制。
 
1． 首先为TUser的class描述符添加optimistic-lock属性：

< hibernate - mapping >  
< class  
name = " org.hibernate.sample.TUser "  
table = " t_user "  
dynamic - update = " true "  
dynamic - insert = " true "  
optimistic - lock = " version "  
>  
…… 
</ class >  
</ hibernate - mapping >  

optimistic-lock属性有如下可选取值：
? none 无乐观锁
? version 通过版本机制实现乐观锁
? dirty 通过检查发生变动过的属性实现乐观锁
? all 通过检查所有属性实现乐观锁

其中通过version实现的乐观锁机制是Hibernate官方推荐的乐观锁实现，同时也 是Hibernate中，目前唯一在数据对象脱离Session发生修改的情况下依然有效的锁机 制。因此，一般情况下，我们都选择version方式作为Hibernate乐观锁实现机制。

2． 添加一个Version属性描述符
代码内容

 1 < hibernate - mapping >   
 2 < class   
 3 name = " org.hibernate.sample.TUser "   
 4 table = " t_user "   
 5 dynamic - update = " true "   
 6 dynamic - insert = " true "   
 7 optimistic - lock = " version "   
 8 >   
 9 < id  
10 name = " id "   
11 column = " id "   
12 type = " java.lang.Integer "   
13 >   
14 < generator  class = " native " >   
15 </ generator >   
16 </ id >   
17 < version  
18 column = " version "   
19 name = " version "   
20 type = " java.lang.Integer "   
21 />   
22 ……  
23 </ class >   
24 </ hibernate - mapping >   
25

注意version 节点必须出现在ID 节点之后。 这里我们声明了一个version属性，用于存放用户的版本信息，保存在TUser表的 version字段中。 此时如果我们尝试编写一段代码，更新TUser表中记录数据，如：
代码内容

1 Criteria criteria  =  session.createCriteria(TUser. class );  
2 criteria.add(Expression.eq( " name " , " Erica " ));  
3 List userList  =  criteria.list();  
4 TUser user  = (TUser)userList.get( 0 );  
5 Transaction tx  =  session.beginTransaction();  
6 user.setUserType( 1 );  // 更新UserType字段  
7 tx.commit();  
8

每次对TUser进行更新的时候，我们可以发现，数据库中的version都在递增。 而如果我们尝试在tx.commit 之前，启动另外一个Session，对名为Erica 的用 户进行操作，以模拟并发更新时的情形：
代码内容

 1 Session session =  getSession();  
 2 Criteria criteria  =  session.createCriteria(TUser. class );  
 3 criteria.add(Expression.eq( " name " , " Erica " ));  
 4 Session session2  =  getSession();  
 5 Criteria criteria2  =  session2.createCriteria(TUser. class );  
 6 criteria2.add(Expression.eq( " name " , " Erica " ));  
 7 List userList  =  criteria.list();  
 8 List userList2  =  criteria2.list();TUser user  = (TUser)userList.get( 0 );  
 9 TUser user2  = (TUser)userList2.get( 0 );  
10 Transaction tx  =  session.beginTransaction();  
11 Transaction tx2  =  session2.beginTransaction();  
12 user2.setUserType( 99 );  
13 tx2.commit();  
14 user.setUserType( 1 );  
15 tx.commit();  
16

执行以上代码，代码将在tx.commit()处抛出StaleObjectStateException异 常，并指出版本检查失败，当前事务正在试图提交一个过期数据。通过捕捉这个异常，我 们就可以在乐观锁校验失败时进行相应处理。

<property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
<property name="show_sql">true</property>
<property name="current_session_context_class">thread</property>
<!--Fetch Size 是设定JDBC的Statement读取数据的时候每次从数据库中取出的记录条数-->
<property name="jdbc.fetch_size">20</property>
<!--Batch Size是设定对数据库进行批量删除，批量更新和批量插入的时候的批次大小，有点相当于设置Buffer缓冲区大小的意思-->
<property name="jdbc.batch_size ">20</property>
<property name="connection.username">HNMC</property>
<property name="connection.password">sundy</property>
<property name="connection.url">jdbc:oracle:thin:@192.168.0.20:1521:ora9</property>
<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>

<!--  在这种情况下，没问题啊 -->
<property name="c3p0.timeout">60</property>
<property name="c3p0.idle_test_period">600</property>


<!--    

<!--<property name="c3p0.idle_test_period">120</property>-->
如改以下俩值，或他们差距很大：

<property name="c3p0.timeout">600</property>

<!--<property name="c3p0.idle_test_period">60</property>-->

当我启动tomcat，运行程序后，空闲600后出现下列异常,但程序还照常运行

-->

<!-- 

Hibernate里可以设置的属性不多：
#c3p0-native property name hibernate configuration key
#c3p0.acquireIncrement hibernate.c3p0.acquire_increment
#c3p0.idleConnectionTestPeriod hibernate.c3p0.idle_test_period
#c3p0.initialPoolSize not available -- uses minimum size
#c3p0.maxIdleTime hibernate.c3p0.timeout
#c3p0.maxPoolSize hibernate.c3p0.max_size
#c3p0.maxStatements hibernate.c3p0.max_statements
#c3p0.minPoolSize hibernate.c3p0.min_size
#c3p0.testConnectionsOnCheckout hibernate.c3p0.validate hibernate 2.x only!

另外的属性你需要配置c3p0.properties
比如：
c3p0.acquireRetryDelay=111
c3p0.acquireRetryAttempts=22
c3p0.breakAfterAcquireFailure=true

-->



<property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
<property name="hibernate.c3p0.max_size">2</property>
<property name="hibernate.c3p0.min_size">2</property>
<property name="hibernate.c3p0.timeout">50000</property>
<property name="hibernate.c3p0.max_statements">100</property>
<property name="hibernate.c3p0.idle_test_period">3000</property>
<property name="hibernate.c3p0.acquire_increment">2</property>

<!-- 另<property name="hibernate.c3p0.validate">false</property>确实在hibernate中不可设置  -->
<property name="hibernate.c3p0.validate">false</property>


<!--C3P0 setting-->

<property name="c3p0.max_size">20</property>
<property name="c3p0.min_size">5</property>
<!--获取连接的等待时间-->
<property name="c3p0.timeout">3600</property>
<property name="c3p0.max_statements">100</property>
<!--每隔3600毫秒测试连接是否可以正常使用-->
<property name="c3p0.idle_test_period">3600</property>
<property name="c3p0.acquire_increment">2</property>

<mapping resource="com/sundy/hnmc/beans/AccountBean.hbm.xml"/>
</session-factory>
</hibernate-configuration>



另一个设置
 <!-- 数据源配置 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
      <property name="driverClass">
        <value>org.gjt.mm.mysql.Driver</value>
      </property>
      <property name="jdbcUrl">
        <value>jdbc:mysql://localhost/tycho?useUnicode=true&amp;characterEncoding=utf-8</value>
      </property>
      <property name="properties">
        <props>
            <prop key="hibernate.hbm2ddl.auto">update</prop> 
            <prop key="c3p0.minPoolSize">1</prop> 
            <prop key="hc3p0.maxPoolSize">10</prop> 
            <prop key="hc3p0.timeout">60</prop> 
            <prop key="c3p0.max_statement">50</prop> 
            <prop key="c3p0.testConnectionOnCheckout">true</prop> 
            <prop key="hibernate.c3p0.testConnectionOnCheckout">false</prop>
            <prop key="user">root</prop> 
            <prop key="password">root</prop>
        </props>
      </property>
    </bean>



<property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
<property name="hibernate.c3p0.max_size">20</property>
<property name="hibernate.c3p0.min_size">5</property>
<property name="hibernate.c3p0.timeout">120</property>
<property name="hibernate.c3p0.max_statements">100</property>
<property name="hibernate.c3p0.idle_test_period">120</property>
<property name="hibernate.c3p0.acquire_increment">2</property>

hibernate中session.delete(sql),3.1与2.0的区别,导致的错误

今天使用session.delete(sql);报下面的错误:

 

org.hibernate.MappingException: Unknown entity: java.lang.String
 at org.hibernate.impl.SessionFactoryImpl.getEntityPersister(SessionFactoryImpl.java:569)
 at org.hibernate.impl.SessionImpl.getEntityPersister(SessionImpl.java:1086)
 at org.hibernate.event.def.DefaultDeleteEventListener.onDelete(DefaultDeleteEventListener.java:63)
 at org.hibernate.impl.SessionImpl.delete(SessionImpl.java:579)

 

查查终于知道原因:

 

    session.delete(sql)是2.0的接口,3.1中已经废弃,同时废弃的有:
    find()、iterate()、filter()和delete(String hqlSelectQuery),saveOrUpdateCopy()

 

  如果要使用的话,可以采用以下方式创建Session实例： 

      org.hibernate.classic.Session session=sessionFactory.openSession(); 

 

      org.hibernate.classic.Session保留了2.0的接口

 

下面是3.1的reference里面这样写的,我使用了,但是还是报错,郁闷:

 

1) Hibernate3.0执行批量删除的程序代码： 
Session session = sessionFactory.openSession(); 
Transaction tx = session.beginTransaction(); 
String hqlDelete = "delete Customer where name = :oldName"; 
int deletedEntities = s.createQuery( hqlDelete ) 
.setString( "oldName", oldName ) 
.executeUpdate(); 
tx.commit(); 
session.close();

 

2)Hibernate3.0执行批量更新的程序代码： 
Session session = sessionFactory.openSession(); 
Transaction tx = session.beginTransaction(); 
String hqlUpdate = "update Customer set name = :newName where name = :oldName"; 
int updatedEntities = s.createQuery( hqlUpdate ) 
.setString( "newName", newName ) 
.setString( "oldName", oldName ) 
.executeUpdate(); 
tx.commit(); 
session.close(); 

 

我按照上面的写法,运行后报错如下:

org.hibernate.QueryException: query must begin with SELECT or FROM: delete [delete Resource r where r.nodeId=:nodeId and r.devId is not null ]
 at org.hibernate.hql.classic.ClauseParser.token(ClauseParser.java:83)
 at org.hibernate.hql.classic.PreprocessingParser.token(PreprocessingParser.java:108)
 at org.hibernate.hql.classic.ParserHelper.parse(ParserHelper.java:28)
 at org.hibernate.hql.classic.QueryTranslatorImpl.compile(QueryTranslatorImpl.java:176)
 at org.hibernate.hql.classic.QueryTranslatorImpl.compile(QueryTranslatorImpl.java:152)
 at org.hibernate.impl.SessionFactoryImpl.getQuery(SessionFactoryImpl.java:427)
 at org.hibernate.impl.SessionImpl.getQueries(SessionImpl.java:884)
 at org.hibernate.impl.SessionImpl.executeUpdate(SessionImpl.java:865)
 at org.hibernate.impl.QueryImpl.executeUpdate(QueryImpl.java:89)

昨天的问题解决了

又把hibernate3的手册仔细的看了一遍,确认自己的写法是没错的,然后又上hibernate的论坛,几乎没有人有我的这个问题,这才想到是不是同事在hibernate.hbm.xml中设置了什么参数,使得我不能使用3.0的特性呢?

      看了,果真如此,郁闷哦~

     里面有一句:

     <property name="hibernate.query.factory_class">org.hibernate.hql.classic.ClassicQueryTranslatorFactory</property>

     这样就使用了2.0的接口.郁闷啊.

     把这句去掉就OK了.

 

     附:

      因为使用了中文拼装的hql后,中文会变成问号,大致如下:

 

      String hql="from user u where u.name like %"+userName+"%";

 

      3.0版本是:

      Query query = session.createQuery("from user u where u.name like :username").setString("username",userName);

现在要通过一个主键id去数据库中删除对应的一条记录，我该怎样做？如果是将参数delId传递进来的话，那该怎么处理？ 我这样做的，但是报了错 public void delfun(String delId) throws DatastoreException { Session session = HibernateUtil.getSession(); Transaction tx = null; try{ tx = session.beginTransaction(); Info info = (Info)session.load(Info.class,id); //出错行 session.delete(delId); tx.commit(); } catch(Exception ex) { HibernateUtil.rollbackTransaction(tx); throw DatastoreException.datastoreError(ex); } finally { HibernateUtil.closeSession(session); } } 错误信息为： com.framework.exceptions.DatastoreException.datastoreError(DatastoreException.java:28) com.service.NpisServiceImpl.delGyinfo(NpisServiceImpl.java:131)

	回复人：pdvv(我爱花猫)	2006-3-1 17:32:22	得分:0
?	你给出的异常应该属于你自己框架的信息吧，没有多少参考价值。 使用Session.load()要确保数据一定存在，还是用get()吧； 或者直接session.delete("from INFO where ID = 1");
Top

	回复人：yuanjian0211(元剑)	2006-3-1 17:46:04	得分:0
?	错误提示信息为： Hibernate: select gyinfo0_.id as id0_, info0_.userid as userid0_, info0_.tit le as title0_,info0_.descript as descript0_ from Info info0_ where info0_.id=? 请指点
Top

	回复人：yuanjian0211(元剑)	2006-3-1 17:56:29	得分:0
?	id在数据库表中为bigint型 在对象中为long型
Top

	回复人：iori_powermax()	2006-03-02 01:06:00	得分:0
?	我也在学习hibernate,不知道说的对不对. 你删除的应该是整个对象,而不是一个id,所以应该为: Info info = (Info)session.load(Info.class,id); session.delete(info); 或者还有一种删除记录的方法: info=(Info)sn.creatQuery("from Info as a where a.ID= '"+delId+"'").uniqueResult(); sn.delete(info); 另外想问一下大家: hibernate的creatSQLQuery()是不是只支持查询?好象增删改都不可以
Top

	回复人：ymfhcn(这痞子真帅)	2006-03-02 08:06:00	得分:0
?	creatSQLQuery()是执行sql语句的，不过稍微有些改动，里面什么SQL语句都可以写  | = | 一般分类 | 仙侠修真 | VBScript | .NET | 面试题 | 存储过程 | Hibernate | JavaScript | J2EE | Struts 自我介绍 我选择，所以我自由！ 切换风格 布局：选择页面布局两栏左侧导航（缺省）两栏右侧导航三栏 配色：选择配色方案纯净蓝灰（缺省）浪漫紫清爽绿海蓝粉红 提示点击带有"..."标记的栏目可以展开/收拢相应的栏目 展开所有 收拢所有 订阅我的Blog 博客日历 « 八月 2006 » 一 二 三 四 五 六 日   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31       文章归档... 八月 2006(1篇) 七月 2006(3篇) 六月 2006(2篇) 五月 2006(5篇) 四月 2006(16篇) 三月 2006(6篇) 最新发表... 关闭窗口的好方法！ 显示格式为：XX月XX日－XX月XX日（前一个为上周六，后一个为本周五） 修改Web.Config文件的函数(vb.net) VBScript得到本周的周末日期函数 给定一个日期，计算此日期是一年中的第几周！ javascript中parseInt的问题 利用javascript得到上周或下周的日期 如何得到前几天的日期 侯捷观点:Java反射机制[转载] 让JSP页面不缓存[设置JSP页面立即过期] 博客统计... 总文章数: 33 总评论数: 16 总引用数: 0 总浏览数: 2744 网站链接... J2EE J2EE&JAVA FAQ 资源 Powered by: Blog Provider: Designed by: =========================================================== Hibernate 的 session.delete(obj =========================================================== 作者: iceling2008(http://iceling2008.itpub.net) 发表于:2006.03.30 16:33 分类: Hibernate 出处：http://iceling2008.itpub.net/post/13270/64328 --------------------------------------------------------------- session.delete(obj)将obj的状态变为transient。两种情况 1）obj是session的cache里边的cache没有的，比如： session.delete(new Employee(4)); 2）obj存在于session的cache中，比如： Employee employee = (Employee)session.load(Employee.class, new Integer(4)); session.delete(employee); 这两种情况都是允许的，hibernate都会发送一条delete语句给数据库。 delete执行之后，如果调用了session.load(), 又可以分为两种情况：1）在session.flush()之前，如： tx.beginTransaction(); 　　　 session.delete(new Employee(4)); session.load(Employee.class, new Integer(4));//发生在session.flush()之前 tx.commit(); 那么hibernate会抛出ObjectDeletedException:The object with that id was deleted: 2）在session.flush()之后，如： tx.beginTransaction(); 　　　 session.delete(new Employee(4)); session.load(Employee.class, new Integer(4)); tx.commit(); tx.beginTransaction(); session.load(Employee.class, new Integer(4));//同一个session中，上面的tx.commit()将session flush了一次。 tx.commit(); 那么这个时候hibernate仅仅会抛出ObjectNotFoundException:No row with the give... 表示找不到该object。如果第二个tx里边采用session.get()也就不会抛出exception了。 delete执行之后，如果调用了session.save(obj): tx.beginTransaction(); Employee employee = (Employee)session.load(Employee.class, new Integer(4)); 　　　 session.delete(employee); System.out.println(employee); session.save(employee); System.out.println(employee); tx.commit(); 这种情况是完全合理的，合法的。 delete将employee从persistent的状态变为transient的状态。 save将employee从transient状态变为persistent的状态。save一个被delete的obj的时候，在save处hibernate强制执行session.flush()，发送delete语句，然后按照常规的save流程来进行。为什么要这么做，还没有完全想明白。 delete执行之后，如果对obj对象属性的修改，tx.commit()时不会进行dirtyChecking。 这个道理比较显然。 - 作者： HairRoot 2005年05月

高级 DAO 编程

学习编译更好的 DAO 的技巧

文档选项 将此页作为电子邮件发送 未显示需要 JavaScript 的文档选项 最新推荐 Java 应用开发源动力 － 下载免费软件，快速启动开发

级别: 初级

Sean C. Sullivan , 软件工程师

2003 年 10 月 15 日

J2EE 开发人员使用数据访问对象(Data Access Object DAO)设计模式，以便将低级别的数据访问逻辑与高级别的业务逻辑分离。实现 DAO 模式涉及比编写数据访问代码更多的内容。在本文中，Java 开发人员 Sean C. Sullivan 讨论了 DAO 编程中三个常常被忽略的方面：事务界定、异常处理和日志记录。

在过去 18 个月中，我参加了一个由有才华的软件工程师组成的小组，构建定制的、基于 Web 的供应链管理应用程序。我们的应用程序访问范围广泛的持久性数据，包括配送状态、供应链衡量(metrics)、库存、货运发票、项目管理数据和用户信息。我们用 JDBC API 连接到我们公司的不同数据库平台上，并在整个应用程序中使用 DAO 设计模式。

图 1 显示了应用程序和数据源之间的关系：

在整个应用程序中使用数据访问对象(DAO)使我们可以将底层数据访问逻辑与业务逻辑分离开来。我们构建了为每一个数据源提供 GRUD (创建、读取、更新、删除)操作的 DAO 类。

在本文中，我将为您介绍构建更好的 DAO 类的 DAO 实现策略和技术。更确切地说，我将讨论日志、异常处理和事务界定。您将学到如何将这三者结合到自己的 DAO 类中。本文假定您熟悉 JDBC API、SQL 和关系数据库编程。

我们将以对 DAO 设计模式和数据访问对象的概述开始。

DAO基础

DAO 模式是标准 J2EE 设计模式之一。开发人员用这种模式将底层数据访问操作与高层业务逻辑分离开。一个典型的 DAO 实现有以下组件：

• 一个 DAO 工厂类
• 一个 DAO 接口
• 一个实现了 DAO 接口的具体类
• 数据传输对象(有时称为值对象)

具体的 DAO 类包含访问特定数据源的数据的逻辑。在下面一节中您将学习设计和实现数据访问对象的技术。有关 DAO 设计模式的更多内容请参阅 参考资料。

回页首

事务界定

关于 DAO 要记住的重要一点是它们是事务性对象。由 DAO 所执行的每一个操作 -- 如创建、更新或者删除数据 -- 都与一个事务相关联。因此， 事务界定的概念就变得特别重要了。

事务界定是定义事务边界的方式。J2EE 规范描述了两种事务界定的模型：编程式(programmatic)和声明式(declarative)。表 1 分析了这两种模型：

表 1. 两种事务界定的模型

我们将侧重于编程式事务界定。

设计考虑

如前所述，DAO 是事务性对象。一个典型的 DAO 执行像创建、更新和删除这样的事务性操作。在设计 DAO 时，首先要问自己以下问题：

• 事务要如何开始？
• 事务应如何结束？
• 哪一个对象将负责开始一个事务？
• 哪一个对象将负责结束一个事务？
• DAO 是否要负责事务的开始和结束？
• 应用程序是否需要通过多个 DAO 访问数据？
• 事务涉及到一个 DAO 还是多个 DAO？
• 一个 DAO 是否调用另一个 DAO 的方法？

了解上述问题的答案将有助于您选择最适合的 DAO 的事务界定策略。在 DAO 中有两种主要的界定事务的策略。一种方式是让 DAO 负责界定事务，另一种将事务界定交给调用这个 DAO 方法的对象处理。如果选择了前一种方式，那么就将事务代码嵌入到 DAO 中。如果选择后一种方式，那么事务界定代码就是在 DAO 类外面。我们将使用简单的代码示例帮助您更好理解每一种方式是如何工作的。

清单 1 显示了一个有两种数据操作的 DAO：创建和更新：

												
														       public void createWarehouseProfile(WHProfile profile);
       public void updateWarehouseStatus(WHIdentifier id, StatusInfo status);

												
										

清单 2 显示了一个简单的事务。事务界定在 DAO 类外面。注意在这个例子中调用者是如何在一个事务中结合多个 DAO 操作的。

												
														      tx.begin();    // start the transaction
      dao.createWarehouseProfile(profile);
      dao.updateWarehouseStatus(id1, status1);
      dao.updateWarehouseStatus(id2, status2);
      tx.commit();   // end the transaction

												
										

这种事务界定策略对于需要在一个事务中访问多个 DAO 的应用程序特别有用。

可以用 JDBC API 或者 Java 事务 API(Java Transaction API JTA)实现事务界定。 JDBC 事务界定比 JTA 事务界定要简单，但是 JTA 提供了更多的灵活性。在下面一节中我将更深入地分析事务界定的机制。

回页首

用 JDBC 进行事务界定

JDBC 事务是用 Connection 对象控制的。JDBC Connection 接口( java.sql.Connection )提供了两种事务模式：自动提交和手工提交。 java.sql.Connection 提供了以下控制事务的方法：

• public void setAutoCommit(boolean)
• public boolean getAutoCommit()
• public void commit()
• public void rollback()

清单 3 显示了如何用 JDBC API 界定一个事务：

												
														      import java.sql.*;
      import javax.sql.*;

      // ...
      DataSource ds = obtainDataSource();
      Connection conn = ds.getConnection();
      conn.setAutoCommit(false);
      // ...
      pstmt = conn.prepareStatement("UPDATE MOVIES ...");
      pstmt.setString(1, "The Great Escape");
      pstmt.executeUpdate();
      // ...
      conn.commit();
      // ...

												
										

使用 JDBC 事务界定时，您可以将多个 SQL 语句结合到一个事务中。JDBC 事务的一个缺点是事务的范围局限于一个数据库连接。一个 JDBC 事务不能跨越多个数据库。在下面，我们将看一下如何用 JTA 进行事务界定。因为 JTA 不像 JDBC 那样有名，所以我们首先做一个简介。

回页首

JTA简介

Java 事务 API(JTA) 及其同门兄弟 Java 事务服务(Java Transaction Service JTS)为 J2EE 平台提供了分布式事务服务。一个 分布式的事务涉及一个事务管理器和一个或者多个资源管理器。一个 资源管理器是任何类型的持久性的数据存储。事务管理器负责协调所有事务参与者之间的通信。事务管理器与资源管理器之间的关系如图 2 所示：

JTA 事务比 JDBC 事务功能更强。JDBC 事务局限为一个数据库连接，而 JTA 事务可以有多个参与者。所有下列 Java 平台组件都可以参与 JTA 事务：

• JDBC 连接
• JDO PersistenceManager 对象
• JMS 队列
• JMS 主题
• 企业 JavaBeans
• 符合 J2EE 连接体系结构(J2EE Connector Architecture)规范的资源适配器

回页首

使用 JTA 的事务界定

要用 JTA 进行事务界定，应用程序要调用 javax.transaction.UserTransaction 接口中的方法。清单 4 显示了对 UserTransaction 对象的典型 JNDI 查询：

												
														      import javax.transaction.*;
      import javax.naming.*;
      // ...
      InitialContext ctx = new InitialContext();
      Object txObj = ctx.lookup("java:comp/UserTransaction");
      UserTransaction utx = (UserTransaction) txObj;


												
										

当应用程序找到了 UserTransaction 对象后，就可以开始事务了，如清单 5 所示：

												
														      utx.begin();
      // ...
      DataSource ds = obtainXADataSource();
      Connection conn = ds.getConnection();
      pstmt = conn.prepareStatement("UPDATE MOVIES ...");
      pstmt.setString(1, "Spinal Tap");
      pstmt.executeUpdate();
      // ...
      utx.commit();
      // ...


												
										

当应用程序调用 commit() 时，事务管理器用一个两阶段的提交协议结束事务。

回页首

控制事务的 JTA 方法

javax.transaction.UserTransaction 接口提供了以下事务控制方法：

• public void begin()
• public void commit()
• public void rollback()
• public int getStatus()
• public void setRollbackOnly()
• public void setTransactionTimeout(int)

应用程序调用 begin() 开始事务。应用程序调用 commit() 或者 rollback() 结束事务。参阅 参考资料以了解更多关于用 JTA 进行事务管理的内容。

回页首

使用 JTA 和 JDBC

开发人员通常在 DAO 类中用 JDBC 进行底层数据操作。如果计划用 JTA 界定事务，那么就需要有一个实现 javax.sql.XADataSource 、 javax.sql.XAConnection 和 javax.sql.XAResource 接口的 JDBC 驱动程序。一个实现了这些接口的驱动程序将可以参与 JTA 事务。一个 XADataSource 对象就是一个 XAConnection 对象的工厂。 XAConnection s 是参与 JTA 事务的 JDBC 连接。

您将需要用应用服务器的管理工具设置 XADataSource 。从应用服务器和 JDBC 驱动程序的文档中可以了解到相关的指导。

J2EE 应用程序用 JNDI 查询数据源。一旦应用程序找到了数据源对象，它就调用 javax.sql.DataSource.getConnection() 以获得到数据库的连接。

XA 连接与非 XA 连接不同。一定要记住 XA 连接参与了 JTA 事务。这意味着 XA 连接不支持 JDBC 的自动提交功能。同时，应用程序一定不要对 XA 连接调用 java.sql.Connection.commit() 或者 java.sql.Connection.rollback() 。相反，应用程序应该使用 UserTransaction.begin()、UserTransaction.commit() 和 serTransaction.rollback() 。

回页首

选择最好的方式

我们讨论了如何用 JDBC 和 JTA 界定事务。每一种方式都有其优点，您需要决定哪一种最适合于您的应用程序。

在最近的许多项目中，我们小组是用 JDBC API 进事务界定来构建 DAO 类的。这些 DAO 类可以总结如下：

• 事务界定代码嵌入在 DAO 类中。
• DAO 类使用 JDBC API 进行事务界定。
• 调用者不能界定事务。
• 事务范围局限于单个 JDBC 连接。

JDBC 事务并不总是适合复杂的企业应用程序。如果您的事务要跨越多个 DAO 或者多个数据库，那么下列实现策略也许更合适：

• 事务用 JTA 界定。
• 事务界定代码从 DAO 中分离出来。
• 调用者负责界定事务。
• DAO 加入一个全局事务。

JDBC 方式由于其简单性而具有吸引力，JTA　方式提供了更大的灵活性。您所选择的实现将取决于应用程序的特定需求。

回页首

日志记录和 DAO

一个良好实现的 DAO 类将使用日志记录来捕捉有关其运行时行为的细节。您可以选择记录异常、配置信息、连接状态、JDBC 驱动程序元数据、或者查询参数。日志对于开发的所有阶段都很有用。我经常在开发时、测试时和生产中分析应用程序日志。

在本节，我将展示一个显示如何将 Jakarta Commons Logging 加入到 DAO 中的代码示例。在这之前，让我们回顾一下一些基本知识。

选择日志库

许多开发人员使用一种原始格式进行日志记录： System.out.println 和 System.err.println 。 Println 语句速度快且使用方便，但是它们没有提供全功能的日志记录系统所具有的功能。表 2 列出了 Java 平台的日志库：

表 2. Java 平台的日志库

Jakarta Commons Logging 可以与 java.util.logging 或者 Jakarta Log4j 一同使用。Commons Logging 是一个日志抽象层，它隔离了应用程序与底层日志实现。使用 Commons Logging，您可以通过改变配置文件更换底层日志实现。Commons Logging 在 Jakarta Struts 1.1 和 Jakarta HttpClient 2.0 中使用。

一个日志记录示例

清单 7 显示了如何在 DAO 类中使用 Jakarta Commons Logging：

												
														import org.apache.commons.logging.*;

class DocumentDAOImpl implements DocumentDAO
{
      static private final Log log = LogFactory.getLog(DocumentDAOImpl.class);

      public void deleteDocument(String id)
      {
          // ...
          log.debug("deleting document: " + id);
          // ...
          try
          {
              // ... data operations ...
          }
          catch (SomeException ex)
          {
              log.error("Unable to delete document", ex);
              // ... handle the exception ...
	}
      }
}

												
										

日志记录是所有任务关键型应用程序的重要部分。如果在 DAO 中遇到故障，那么日志通常可以提供判断出错位置的最好信息。将日志加入到 DAO 可以保证您有机会进行调试和故障排除。

回页首

DAO 中的异常处理

我们讨论过了事务界定和日志，现在对于如何在数据访问对象上应用它们有了更深入的理解。我们的第三个和最后一个讨论议题是异常处理。遵从几个简单的异常处理指导可以使您的 DAO 更容易使用、更健壮及更易于维护。

在实现 DAO 模式时，考虑以下问题：

• DAO 的公共接口中的方法是否抛出检查过的异常？
• 如果是的话，抛出何种检查过的异常？
• 在 DAO 实现类中如何处理异常？

在使用 DAO 模式的过程中，我们的小组开发了一些处理异常的原则。遵从这些原则可以极大地改进您的 DAO：

• DAO 方法应该抛出有意义的异常。
• DAO 方法不应该抛出 java.lang.Exception 。 java.lang.Exception 太一般化了。它不传递关于底层问题的任何信息。
  
• DAO 方法不应该抛出 java.sql.SQLException 。SQLException 是一个低级别的 JDBC 异常。一个 DAO 应该力争封装 JDBC 而不是将 JDBC 公开给应用程序的其余部分。
  
• 只有在可以合理地预期调用者可以处理异常时，DAO 接口中的方法才应该抛出检查过的异常。如果调用者不能以有意义的方式处理这个异常，那么考虑抛出一个未检查的(运行时)异常。
• 如果数据访问代码捕获了一个异常，不要忽略它。忽略捕获的异常的 DAO 是很难进行故障诊断的。
• 使用链接的异常将低级别的异常转化为高级别的异常。
• 考虑定义标准 DAO 异常类。Spring Framework (参阅 参考资料)提供了很好的一套预定义的 DAO 异常类。

有关异常和异常处理技术的更多信息参阅 参考资料。

回页首

实现实例： MovieDAO

MovieDAO 是一个展示本文中讨论的所有技术的 DAO：事务界定、日志和异常处理。您可以在 参考资料一节中找到 MovieDAO 源代码。代码分为三个包：

• daoexamples.exception
• daoexamples.movie
• daoexamples.moviedemo

DAO 模式的这个实现包含下面列出的类和接口：

• daoexamples.movie.MovieDAOFactory
• daoexamples.movie.MovieDAO
• daoexamples.movie.MovieDAOImpl
• daoexamples.movie.MovieDAOImplJTA
• daoexamples.movie.Movie
• daoexamples.movie.MovieImpl
• daoexamples.movie.MovieNotFoundException
• daoexamples.movie.MovieUtil

MovieDAO 接口定义了 DAO 的数据操作。这个接口有五个方法，如下所示：

• public Movie findMovieById(String id)
• public java.util.Collection findMoviesByYear(String year)
• public void deleteMovie(String id)
• public Movie createMovie(String rating, String year, String, title)
• public void updateMovie(String id, String rating, String year, String title)

daoexamples.movie 包包含 MovieDAO 接口的两个实现。每一个实现使用一种不同的方式进行事务界定，如表 3 所示：

表 3. MovieDAO 实现

MovieDAO 演示应用程序

这个演示应用程序是一个名为 daoexamples.moviedemo.DemoServlet 的 servlet 类。 DemoServlet 使用这两个 Movie DAO 查询和更新表中的电影数据。

这个 servlet 展示了如何将支持 JTA 的 MovieDAO 和 Java 消息服务(Java Message Service)结合到一个事务中，如清单 8 所示。

												
															UserTransaction utx = MovieUtil.getUserTransaction();
	utx.begin();
	batman = dao.createMovie("R",
			"2008",
			"Batman Reloaded");
	publisher = new MessagePublisher();
	publisher.publishTextMessage("I'll be back");
	dao.updateMovie(topgun.getId(),
			"PG-13",
			topgun.getReleaseYear(),
			topgun.getTitle());
	dao.deleteMovie(legallyblonde.getId());
	utx.commit();

												
										

--------------------------------------------------------------------------------
 
作者：:     来源：     发表时间：2006-06-08     浏览次数：18    字号：大  中  小
　　
通过过滤器判断用户权限.
第一步:建立UserPermissionFilter类.

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;

import test.system.SysUserApi;
import test.vo.SysUserVO;
import test.system.dao.SysUserDao;
import test.Const;

public class UserPermissionFilter extends HttpServlet implements Filter {

  protected FilterConfig filterConfig = null;

  public void destroy() {
    this.filterConfig = null;
  }

  public void doFilter(
      ServletRequest request,
      ServletResponse response,
      FilterChain filterChain) throws IOException, ServletException {
    try {
      HttpServletRequest req = (HttpServletRequest) request;
      SysUserVO userSession = new SysUserVO();
      userSession = (SysUserVO)req.getSession().getAttribute(Const.SESSION_USER);
      if (userSession == null) {
        HttpServletResponse rep = (HttpServletResponse) response;

        rep.sendRedirect("/admin/login.jsp");
             }else{
        filterChain.doFilter(request, response);
      }
    }
    catch (Exception e) {}
  }
  public void init(FilterConfig filterConfig) throws ServletException {
    this.filterConfig = filterConfig;
  }
  public FilterConfig getFilterConfig() {
    return filterConfig;
  }

  public void setFilterConfig(FilterConfig filterConfig) {
    this.filterConfig = filterConfig;
  }

}

第二步:配置WEB.xml文件
设置过滤器:
  <filter>
    <filter-name>userpermission</filter-name>
    <filter-class>sports.tools.UserPermissionFilter</filter-class>
  </filter>
设置过滤器映射,因为过滤器不能过滤全部的程序,所以可以用列表的形式来增加需要过滤的文件.如下.一个过滤器可以过滤多个映射文件.
  <filter-mapping>
    <filter-name>userpermission</filter-name>
    <url-pattern>/admin/index.jsp</url-pattern>
  </filter-mapping>

  <filter-mapping>
    <filter-name>userpermission</filter-name>
    <url-pattern>/admin/edit/*</url-pattern>
  </filter-mapping>
 
 
 
======================================
http://www.itwenzhai.com/data/2006/0608/article_22958.htm
=========================================
http://www.itwenzhai.com/data/2006/0626/article_25178.htm
=========================================

  不重复DAO
===============

由于 Java™ 5 泛型的采用，有关泛型类型安全 Data Access Object (DAO) 实现的想法变得切实可行。在本文中，系统架构师 Per Mellqvist 展示了基于 Hibernate 的泛型 DAO 实现类。然后展示如何使用 Spring AOP introductions 将类型安全接口添加到类中以便于查询执行。
对于大多数开发人员，为系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复标识为 “代码味道”，但我们大多数都已经学会忍受它。其实有解决方案。可以使用许多 ORM 工具来避免代码重复。例如，使用 Hibernate，您可以简单地为所有的持久域对象直接使用会话操作。这种方法的缺点是损失了类型安全。

为什么您要为数据访问代码提供类型安全接口？我会争辩说，当它与现代 IDE 工具一起使用时，会减少编程错误并提高生产率。首先，类型安全接口清楚地指明哪些域对象具有可用的持久存储。其次，它消除了易出错的类型强制转换的需要（这是一个在查询操作中比在 CRUD 中更常见的问题）。最后，它有效利用了今天大多数 IDE 具备的自动完成特性。使用自动完成是记住什么查询可用于特定域类的快捷方法。

在本文中，我将为您展示如何避免再三地重复 DAO 代码，而仍保留类型安全接口的优点。事实上，您需要为每个新 DAO 编写的只是 Hibernate 映射文件、无格式旧 Java 接口以及 Spring 配置文件中的 10 行。

DAO 实现

DAO 模式对任何企业 Java 开发人员来说都应该很熟悉。但是模式的实现各不相同，所以我们来澄清一下本文提供的 DAO 实现背后的假设：

系统中的所有数据库访问都通过 DAO 进行以实现封装。
每个 DAO 实例负责一个主要域对象或实体。如果域对象具有独立生命周期，它应具有自己的 DAO。
DAO 负责域对象的创建、读取（按主键）、更新和删除（creations, reads, updates, and deletions，CRUD）。
DAO 可允许基于除主键之外的标准进行查询。我将之称为查找器方法 或查找器。查找器的返回值通常是 DAO 负责的域对象集合。
DAO 不负责处理事务、会话或连接。这些不由 DAO 处理是为了实现灵活性。
泛型 DAO 接口

泛型 DAO 的基础是其 CRUD 操作。下面的接口定义泛型 DAO 的方法：

清单 1. 泛型 DAO 接口
public interface GenericDao <T, PK extends Serializable> {

    /** Persist the newInstance object into database */
    PK create(T newInstance);

    /** Retrieve an object that was previously persisted to the database using
     *   the indicated id as primary key
     */
    T read(PK id);

    /** Save changes made to a persistent object.  */
    void update(T transientObject);

    /** Remove an object from persistent storage in the database */
    void delete(T persistentObject);
}

实现接口

用 Hibernate 实现清单 1 中的接口十分简单，如清单 2 所示。它只需调用底层 Hibernate 方法和添加强制类型转换。Spring 负责会话和事务管理。（当然，我假设这些函数已做了适当的设置，但该主题在 Hibernate 和 Springt 手册中有详细介绍。）

清单 2. 第一个泛型 DAO 实现
public class GenericDaoHibernateImpl <T, PK extends Serializable>
    implements GenericDao<T, PK>, FinderExecutor {
    private Class<T> type;

    public GenericDaoHibernateImpl(Class<T> type) {
        this.type = type;
    }

    public PK create(T o) {
        return (PK) getSession().save(o);
    }

    public T read(PK id) {
        return (T) getSession().get(type, id);
    }

    public void update(T o) {
        getSession().update(o);
    }

    public void delete(T o) {
        getSession().delete(o);
    }

    // Not showing implementations of getSession() and setSessionFactory()
            }
 

Spring 配置

最后，在 Spring 配置中，我创建了 GenericDaoHibernateImpl 的一个实例。必须告诉 GenericDaoHibernateImpl 的构造函数 DAO 实例将负责哪个域类。只有这样，Hibernate 才能在运行时知道由 DAO 管理的对象类型。在清单 3 中，我将域类 Person 从示例应用程序传递给构造函数，并将先前配置的 Hibernate 会话工厂设置为已实例化的 DAO 的参数：

清单 3. 配置 DAO
<bean id="personDao" class="genericdao.impl.GenericDaoHibernateImpl">
        <constructor-arg>
            <value>genericdaotest.domain.Person</value>
        </constructor-arg>
        <property name="sessionFactory">
            <ref bean="sessionFactory"/>
        </property>
</bean>
        
2。
我还没有完成，但我所完成的确实已经可以使用了。在清单 4 中，可以看到原封不动使用该泛型 DAO 的示例：

清单 4. 使用 DAO
public void someMethodCreatingAPerson() {
    ...
    GenericDao dao = (GenericDao)
     beanFactory.getBean("personDao"); // This should normally be injected

    Person p = new Person("Per", 90);
    dao.create(p);
}
        

现在，我有一个能够进行类型安全 CRUD 操作的泛型 DAO。让子类 GenericDaoHibernateImpl 为每个域对象添加查询能力将非常合理。因为本文的目的在于展示如何不为每个查询编写显式的 Java 代码来实现查询，但是，我将使用其他两个工具将查询引入 DAO，也就是 Spring AOP 和 Hibernate 命名的查询。

Spring AOP introductions

可以使用 Spring AOP 中的 introductions 将功能添加到现有对象，方法是将功能包装在代理中，定义应实现的接口，并将所有先前未支持的方法指派到单个处理程序。在我的 DAO 实现中，我使用 introductions 将许多查找器方法添加到现有泛型 DAO 类中。因为查找器方法是特定于每个域对象的，因此将其应用于泛型 DAO 的类型化接口。

Spring 配置如清单 5 所示：

清单 5. FinderIntroductionAdvisor 的 Spring 配置
<bean id="finderIntroductionAdvisor" class="genericdao.impl.FinderIntroductionAdvisor"/>

<bean id="abstractDaoTarget"
        class="genericdao.impl.GenericDaoHibernateImpl" abstract="true">
        <property name="sessionFactory">
            <ref bean="sessionFactory"/>
        </property>
</bean>

<bean id="abstractDao"
        class="org.springframework.aop.framework.ProxyFactoryBean" abstract="true">
        <property name="interceptorNames">
            <list>
                <value>finderIntroductionAdvisor</value>
            </list>
        </property>
</bean>
        

在清单 5 的配置文件中，我定义了三个 Spring bean。第一个 bean 是 FinderIntroductionAdvisor，它处理引入到 DAO 的所有方法，这些方法在 GenericDaoHibernateImpl 类中不可用。我稍后将详细介绍 Advisor bean。

第二个 bean 是 “抽象的”。在 Spring 中，这意味着该 bean 可在其他 bean 定义中被重用，但不被实例化。除了抽象特性之外，该 bean 定义只指出我想要 GenericDaoHibernateImpl 的实例以及该实例需要对 SessionFactory 的引用。注意，GenericDaoHibernateImpl 类仅定义一个构造函数，该构造函数接受域类作为其参数。因为该 bean 定义是抽象的，所以我将来可以无数次地重用该定义，并将构造函数参数设置为合适的域类。

最后，第三个也是最有趣的 bean 将 GenericDaoHibernateImpl 的 vanilla 实例包装在代理中，赋予其执行查找器方法的能力。该 bean 定义也是抽象的，不指定希望引入到 vanilla DAO 的接口。该接口对于每个具体的实例是不同的。注意，清单 5 显示的整个配置仅定义一次。

3。

扩展 GenericDAO

当然，每个 DAO 的接口都基于 GenericDao 接口。我只需使该接口适应特定的域类并扩展该接口以包括查找器方法。在清单 6 中，可以看到为特定目的扩展的 GenericDao 接口示例：

清单 6. PersonDao 接口
public interface PersonDao extends GenericDao<Person, Long> {
    List<Person> findByName(String name);
}

很明显，清单 6 中定义的方法旨在按名称查找 Person。必需的 Java 实现代码全部是泛型代码，在添加更多 DAO 时不需要任何更新。

配置 PersonDao

因为 Spring 配置依赖于先前定义的 “抽象” bean，因此它变得相当简洁。我需要指出 DAO 负责哪个域类，并且需要告诉 Springs 该 DAO 应实现哪个接口（一些方法是直接使用，一些方法则是通过使用 introductions 来使用）。清单 7 展示了 PersonDAO 的 Spring 配置文件：

清单 7. PersonDao 的 Spring 配置
<bean id="personDao" parent="abstractDao">
    <property name="proxyInterfaces">
        <value>genericdaotest.dao.PersonDao</value>
    </property>
    <property name="target">
        <bean parent="abstractDaoTarget">
            <constructor-arg>
                <value>genericdaotest.domain.Person</value>
            </constructor-arg>
        </bean>
    </property>
</bean>
        

在清单 8 中，可以看到使用了这个更新后的 DAO 版本：

清单 8. 使用类型安全接口
public void someMethodCreatingAPerson() {
    ...
    PersonDao dao = (PersonDao)
     beanFactory.getBean("personDao"); // This should normally be injected

    Person p = new Person("Per", 90);
    dao.create(p);

    List<Person> result = dao.findByName("Per"); // Runtime exception
}
        

虽然清单 8 中的代码是使用类型安全 PersonDao 接口的正确方法，但 DAO 的实现并不完整。调用 findByName() 会导致运行时异常。问题在于我还没有实现调用 findByName() 所必需的查询。剩下要做的就是指定查询。为更正该问题，我使用了 Hibernate 命名查询。

Hibernate 命名查询

使用 Hibernate，可以在 Hibernate 映射文件 (hbm.xml) 中定义 HQL 查询并为其命名。稍后可以通过简单地引用给定名称来在 Java 代码中使用该查询。该方法的优点之一是能够在部署时优化查询，而无需更改代码。您一会将会看到，另一个优点是无需编写任何新 Java 实现代码，就可以实现 “完整的” DAO。清单 9 是带有命名查询的映射文件的示例：

清单 9. 带有命名查询的映射文件
 <hibernate-mapping package="genericdaotest.domain">
     <class name="Person">
         <id name="id">
             <generator class="native"/>
         </id>
         <property name="name" />
         <property name="weight" />
     </class>

     <query name="Person.findByName">
         <![CDATA[select p from Person p where p.name = ? ]]>
     </query>
 </hibernate-mapping>
        

清单 9 定义了域类 Person 的 Hibernate 映射，该域类具有两个属性：name 和 weight。Person 是具有上述属性的简单 POJO。该文件还包含一个在数据库中查找 Person 所有实例的查询，其中 “name” 等于提供的参数。Hibernate 不为命名查询提供任何真正的名称空间功能。出于讨论目的，我为所有查询名称都加了域类的短（非限定）名称作为前缀。在现实世界中，使用包括包名称的完全类名可能是更好的主意。

逐步概述

您已经看到了为任何域对象创建和配置新 DAO 所必需的全部步骤。三个简单的步骤是：

定义一个接口，它扩展 GenericDao 并包含所需的任何查找器方法。
将每个查找器的命名查询添加到域对象的 hbm.xml 映射文件。
为 DAO 添加 10 行 Spring 配置文件。
查看执行查找器方法的代码（只编写了一次！）来结束我的讨论。

4。

可重用的 DAO 类

使用的 Spring advisor 和 interceptor 很简单，事实上它们的工作是向后引用 GenericDaoHibernateImplClass。方法名以 “find” 打头的所有调用都传递给 DAO 和单个方法 executeFinder()。

清单 10. FinderIntroductionAdvisor 的实现
public class FinderIntroductionAdvisor extends DefaultIntroductionAdvisor {
    public FinderIntroductionAdvisor() {
        super(new FinderIntroductionInterceptor());
    }
}

public class FinderIntroductionInterceptor implements IntroductionInterceptor {

    public Object invoke(MethodInvocation methodInvocation) throws Throwable {

        FinderExecutor genericDao = (FinderExecutor) methodInvocation.getThis();

        String methodName = methodInvocation.getMethod().getName();
        if (methodName.startsWith("find")) {
            Object[] arguments = methodInvocation.getArguments();
            return genericDao.executeFinder(methodInvocation.getMethod(), arguments);
        } else {
            return methodInvocation.proceed();
        }
    }

    public boolean implementsInterface(Class intf) {
        return intf.isInterface() && FinderExecutor.class.isAssignableFrom(intf);
    }
}
 

executeFinder() 方法

清单 10 的实现中惟一缺少的是 executeFinder() 实现。该代码查看调用的类和方法的名称，并使用配置上的约定将其与 Hibernate 查询的名称相匹配。还可以使用 FinderNamingStrategy 来支持其他命名查询的方法。默认实现查找叫做 “ClassName.methodName” 的查询，其中 ClassName 是不带包的短名称。清单 11 完成了泛型类型安全 DAO 实现：

清单 11. executeFinder() 的实现
public List<T> executeFinder(Method method, final Object[] queryArgs) {
     final String queryName = queryNameFromMethod(method);
     final Query namedQuery = getSession().getNamedQuery(queryName);
     String[] namedParameters = namedQuery.getNamedParameters();
     for(int i = 0; i < queryArgs.length; i++) {
             Object arg = queryArgs[i];
             Type argType =  namedQuery.setParameter(i, arg);
      }
      return (List<T>) namedQuery.list();
 }

 public String queryNameFromMethod(Method finderMethod) {
     return type.getSimpleName() + "." + finderMethod.getName();
 }
 

结束语

在 Java 5 之前，该语言不支持编写既类型安全又 泛型的代码，您必须只能选择其中之一。在本文中，您已经看到一个结合使用 Java 5 泛型与 Spring 和 Hibernate（以及 AOP）等工具来提高生产率的示例。泛型类型安全 DAO 类相当容易编写 —— 您只需要单个接口、一些命名查询和为 Spring 配置添加的 10 行代码 —— 而且可以极大地减少错误并节省时间。

几乎本文的所有代码都是可重用的。尽管您的 DAO 类可能包含此处没有实现的查询和操作类型（比如，批操作），但使用我所展示的技术，您至少应该能够实现其中的一部分。参阅 参考资料 了解其他泛型类型安全 DAO 类实现。

致谢

自 Java 语言中出现泛型以来，单个泛型类型安全 DAO 的概念已经成为主题。我曾在 JavaOne 2004 中与 Don Smith 简要讨论了泛型 DAO 的灵活性。本文使用的 DAO 实现类旨在作为示例实现，实际上还存在其他实现。例如，Christian Bauer 已经发布了带有 CRUD 操作和标准搜索的实现，Eric Burke 也在该领域做出了工作。我确信将会有更多的实现出现。我要额外感谢 Christian，他目睹了我编写泛型类型安全 DAO 的第一次尝试并提出改进建议。最后，我要感谢 Ramnivas Laddad 的无价帮助，他审阅了本文。