现在的位置: 首页 > 综合 > 正文

webwork+spring+hibernate的整合

2013年11月03日 ⁄ 综合 ⁄ 共 8198字 ⁄ 字号 小 中 大 ⁄ 评论关闭

1、webwork、spring的集成
  (1)、开启spring的集成：
         首先将最新的spring的jar加到classpath中，然后在src目录下建立webwork.properties文件，文件只包含下面的内容
        webwork.objectFactory=spring
         这种情况下,所有的对象都至少会试图使用Spring来创建.如果它们不能被Spring创建,然后WebWork会自己创建对象.接下来,在
        web.xml打开Spring的Listener

  1. <listener>  
  2.    <listener-class>
  3.         org.springframework.web.context.ContextLoaderListener
  4.    listener-class>  
  5. listener>  

 由于使用标准的Listener来集成Spring,它可以被配置来支持除了applicationContext.xml之外的配置文件.把下面的几行添加到
       web.xml会让Spring的ApplicationContext从所有匹配给定的规则的文件中初始化:

  1. <!-- Context Configuration locations for Spring XML files -->  
  2.         <context-param>  
  3.              <param-name>contextConfigLocationparam-name>  
  4.              <param-value>/WEB-INF/applicationContext-*.xml,classpath*:applicationContext       
  5.        context-param>  

 根据需要配置相应的spring上下文文。
   (2)、在spring中初始化Action
         正常情况下,在xwork.xml里可以为每个action指定类.当你使用SpringObjectFactory时WebWork会请求Spring来
         创建action并按照缺省指定的自动装配行为来装配依赖的组件.SpringObjectFactory 也会设置所有的bean的后置处理程序
        (post processors)来完成类似对Action进行事务,安全等等方面的代理的事情.Spring可以不依赖外在的配置来自动确定.
         对于大多数的使用,这就是全部需要的了,用来配置action,设置它们获取服务和依赖组件.
         强烈推荐使用一种声明式的方法来让Spring知道为action提供什么.这包括让bean能够自动装配,无论是把Action里的
         依赖的属性命名为和Spring应该提供的Bean的名字一致(这允许基于名字的自动装配),或者使用by type方式的自动装配,也就是在注册到
        Spring的Bean中需要的类型仅拥有一个.也可以包括使用JDK5的标准来声明事务和安全需求,而不是必须在你的Spring配置里明确设置代理.
         如果能找到方法让Spring在没有任何明确的配置(在_applicationContext.xml_中)的情况下知道需要为action做什么,那么就不
         需要在两个地方维护这个配置了.
         当然,有时候可能想要Spring完全来管理bean.这是有实际意义的,例如,如果想要为bean设置更复杂的AOP或者Spring相关的技术,
         例如Acegi.为了达到这个目的,所有必须要做的事情就是在Spring的 applicationContext.xml 里配置bean,然后在 xwork.xml
         里改变你的WebWork action的类属性来使用在Spring里面定义的bean的名字,而不再使用类名. 
        xwork.xml文件也会改变action类的属性,最后留下的就像这样   

  1. <xwork>  
  2.       <!-- Include webwork defaults (from WebWork JAR). -->  
  3.         <include file="webwork-default.xml" />  
  4.   
  5.       <!-- Configuration for the default package. -->  
  6.         <package name="default" extends="webwork-default">  
  7.           <action name="register" class="userAction" method="register">  
  8.              <result name="success">/pages/registerSuccess.jspresult>  
  9.           action>  
  10.         package>  
  11. /xwork>  

在applicationContext.xml 里定义了一个名字为 "userAction"的Spring的bean.注意cn.com.nawang.Action.UserAction不需要
改变,因为它可能是自动装配的：

  1. <bean id="userAction" class="cn.com.nawang.action.UserAction" >     
  2.              <property name="userService" ref="userService"/>  
  3. bean>  

注：bean中的id值必须与xwork.xml中对应的class值一致。
       
2、 基于Hibernate3的原生API实现DAO
        Hibernate 3.0.1引入了一个新的特性：“带上下文环境的Session”。 这一特性使得Hibernate自身具备了每个事务绑定当前 Session 对象的功能。
         这与Spring中每个Hibernate的 Session 与事务同步的功能大致相同。
   (1)、 为Dao创建基类BaseDao

  1. public class BaseDao {   
  2.             private SessionFactory  sessionFactory;   
  3.   
  4.             public void setSessionFactory(SessionFactory sessionFactory) {   
  5.                 this.sessionFactory = sessionFactory;   
  6.             }   
  7.        
  8.             public Session getSession(){   
  9.                  Session session = this.sessionFactory.getCurrentSession();   
  10.                  return session;   
  11.             }   
  12.  }  

(2)、在子类Dao中实现具体持久化操作

  1. public class UserDao extends BaseDao implements IUserDao {   
  2.            public void saveUser(User user) throws HibernateException {   
  3.               getSession().save(user);   
  4.            }         
  5. }   

(3)、在上下文中配置

xml 代码
  1. <bean id="baseDao" class="cn.com.nawang.dao.BaseDao">  
  2.            <property name="sessionFactory" ref="sessionFactory"/>  
  3.         bean>  
  4.         
  5.         <bean id="userDao" class="cn.com.nawang.dao.impl.UserDao" parent="baseDao"/>  
  6.            
  7.         <bean id="userService" class="cn.com.nawang.service.impl.UserService">  
  8.            <property name="userDao" ref="userDao"/>  
  9.         bean>  
  10.        
  11.         <bean id="userAction" class="cn.com.nawang.action.UserAction" >     
  12.           <property name="userService" ref="userService"/>  
  13. bean>       

重启服务，在web页面上触发register的action，执行后，抛出下面的异常：
      Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here
    google了下，大概明白了是因为没有配置了事务导致的错误。在配置事务之前，查看了以前的一个采用HibernateDaoSupport实现的项目，记得当时并不需要配置事务就可以正常运行。

于是，让UserDao继承于HibernateDaoSupport，修改后的代码如下：

  1. public class UserDao extends BaseDao implements IUserDao {   
  2.            public void saveUser(User user) throws HibernateException {   
  3.               getHibernateTemplate().save(user);   
  4.            }         
  5. }  

 
    保存修改内容，重启服务，重启中出现错误，查看了spring in action中的相关配置，发现baseTransaction这个bean的配置稍有不同，
    上面那个配置是参考springside的，当时那个项目赶，就直接拿过来用，也没出现问题，就不认真去考虑，现在拷贝到现有项目中，却出错了，
    于是先根据书上的介绍做相应修改，改后的内容如下：

java 代码
  1. public class UserDao extends BaseDao implements IUserDao {   
  2.            public void saveUser(User user) throws HibernateException {   
  3.               getHibernateTemplate().save(user);   
  4.            }         
  5.  }  

接下去，修改spring上下文中的相关配置，

  1. <bean id="userDao" class="cn.com.nawang.dao.impl.UserDao">  
  2.            <property name="sessionFactory" ref="sessionFactory"/>  
  3.         bean>  
  4.            
  5.         <bean id="userService" class="cn.com.nawang.service.impl.UserService">  
  6.            <property name="userDao" ref="userDao"/>  
  7.         bean>  
  8.        
  9.         <bean id="userAction" class="cn.com.nawang.action.UserAction" >     
  10.           <property name="userService" ref="userService"/>  
  11. bean>    

 保存修改后的，重启服务，再次触发register的action，用户信息成功保存。
    
     去掉HibernateDaoSupport的dao实现后，又换回基于hibernate3.0原生API的实现方式，根据之前google后的结果，给userService配置
     事务，拷贝了下之前项目中的配置，并做相应修改，修改后的内容如下：

  1. <bean id="baseTransaction"    
  2.        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">  
  3.         <property name="transactionManager" ref="transactionManager"/>  
  4.         <property name="proxyTargetClass" value="true"/>  
  5.         <property name="transactionAttributes">  
  6.            <props>                    
  7.                <prop key="get*">PROPAGATION_REQUIRED,readOnlyprop>  
  8.                <prop key="find*">PROPAGATION_REQUIRED,readOnlyprop>  
  9.                <prop key="load*">PROPAGATION_REQUIRED,readOnlyprop>                    
  10.                <prop key="save*">PROPAGATION_REQUIREDprop>                    
  11.                <prop key="add*">PROPAGATION_REQUIREDprop>                    
  12.                <prop key="update*">PROPAGATION_REQUIREDprop>                    
  13.                <prop key="delete*">PROPAGATION_REQUIREDprop>                
  14.            props>           
  15.         property>      
  16.     bean>    
  17.        
  18.     <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  19.         <property name="sessionFactory" ref="sessionFactory"/>  
  20.     bean>          
  21.        
  22.     <bean id="baseDao" class="cn.com.nawang.dao.BaseDao">  
  23.         <property name="sessionFactory" ref="sessionFactory"/>  
  24.     bean>  
  25.         
  26.     <bean id="userDao" class="cn.com.nawang.dao.impl.UserDao" parent="baseDao"/>  
  27.        
  28.     <bean id="userServiceTarget" class="cn.com.nawang.service.impl.UserService">  
  29.        <property name="userDao" ref="userDao"/>  
  30.     bean>  
  31.        
  32.     <bean id="userService" parent="baseTransaction">  
  33.        <property name="target" ref="userServiceTarget"/>  
  34.     bean>  
  35.        
  36.     <bean id="userAction" class="cn.com.nawang.action.UserAction" >     
  37.        <property name="userService" ref="userService"/>  
  38.     bean>  

 保存修改内容，重启服务，重启中出现错误，查看了spring in action中的相关配置，发现baseTransaction这个bean的配置稍有不同，
    上面那个配置是参考springside的，当时那个项目赶，就直接拿过来用，也没出现问题，就不认真去考虑，现在拷贝到现有项目中，却出错了，
    于是先根据书上的介绍做相应修改，改后的内容如下：

  1. <bean id="baseTransaction"    
  2.      class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" lazy-init="true">  
  3.        <property name="transactionManager" ref="transactionManager"/>  
  4.        <property name="transactionAttributes">  
  5.           <props>                    
  6.               <prop key="get*">PROPAGATION_REQUIRED,readOnlyprop>  
  7.               <prop key="find*">PROPAGATION_REQUIRED,readOnlyprop>  
  8.               <prop key="load*">PROPAGATION_REQUIRED,readOnlyprop>                    
  9.               <prop key="save*">PROPAGATION_REQUIREDprop>                                  
  10.               <prop key="update*">PROPAGATION_REQUIREDprop>                    
  11.               <prop key="delete*">PROPAGATION_REQUIREDprop>                
  12.           props>           
  13.        property>      
  14.    bean>  

去掉了

  1. <property name="proxyTargetClass" value="true"/>  

 的配置，将abstract="true"改为lazy-init="true"，保存修改
    重启服务，并再次触发register的action，一切如所愿。

 

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞