Struts1SH整合-阿里云开发者社区

Spring2.5+Hibernate3.5+Struts1.3整合开发

为了避免出现jar包不兼容,或者重复加载的情况,先把jar包整理出来:

hibernate核心安装包下的:
            hibernate3.jar
            lib/required/*
            lib/optional/ehcache-1.2.3.jar
hibernate 注解安装包下的:
            lib/test/slf4j-log4j12.jar
Spring安装包下的
            dist/spring.jar
            dist/modules/spring-webmvc-struts.jar
            lib/jakarta-commons/commons-logging.jar、commons-dbcp.jar、commons-pool.jar
            lib/aspectj/aspectjweaver.jar、aspectjrt.jar
            lib/cglib/cglib-nodep-2.1_3.jar
            lib/j2ee/common-annotations.jar
            lib/log4j/log4j-1.2.15.jar
Struts
            struts-1.3.8-lib.zip,需要使用到解压目录下的所有jar包,建议把jstl-1.0.2.jar和standard-1.0.2.jar更换为1.1版本。Spring中已经存在一个antlr-2.7.6.jar，所以把
            struts中的antlr-2.7.2.jar删除，避免jar冲突.
数据库驱动

替换旧的jar包,删除重复的jar包,jar包就准备好了,在此选用Mysql作为数据库,在临时数据库中创建一个person表,表的结构如下:

 
     use test;  
   
     create table person  
   
     (  
   
            name varchar(12),         
   
            id   int  
   
     )

不要一开始就进行三大框架的整合,我们首先进行Spring与Hibernate的整合,然后再进行Spring与Struts的整合.

把要做的事情整理好,能够便于我们开发:

搭建Hibernate

创建表
创建对应的javaBean---Person类,放置在domain包下
创建PersonDao,提供一个save方法,接收一个Person对象,放置在dao下
创建BusinessService,维护一个PersonDao对象,对外界提供save功能,放置在service下
配置person.hbm.xml文件,放置在domain包下
配置hibernate.cfg.xml,放置在类路径下

表和实体创建好后,就开始配置person.hbm.xml文件:

 
     <hibernate-mapping>  
   
         <!--   
   
             name:javaBean  
   
             table:对应的表名  
   
          -->  
   
         <class name="..domain.Person" table="person">  
   
             <!-- 配置主键 -->  
   
             <id name="id" type="integer">                  
   
                 <column name="id"></column>  
   
                 <!-- 自增 -->  
   
                 <generator class="increment"></generator>  
   
             </id>  
   
             <!-- 配置其他列 -->  
   
             <property name="name" type="string">  
   
                 <column name="name" sql-type="varchar(12)"></column>  
   
             </property>          
   
         </class>  
   
     </hibernate-mapping>

接下来配置hibernate.cfg.xml文件,相信大家对session-factory的配置很熟悉,就不再赘述了:

 
     <hibernate-configuration>  
   
         <session-factory>  
   
             <property name="hibernate.connection.username">root</property>  
   
             <property name="hibernate.connection.password">root</property>  
   
             <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>  
   
             <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>  
   
             <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>  
   
             <property name="hibernate.show_sql">true</property>  
   
             <property name="hibernate.hbm2ddl.auto">update</property>  
   
             <mapping resource="../domain/Person.hbm.xml"/>  
   
         </session-factory>  
   
     </hibernate-configuration>

为了简化对数据库的操作,我们在PersonDao里面维护一个HibernateTemplate,标注注解,用Spring注入进来:

 
    @Resource
   
     private HibernateTemplate hibernateTemplate;

同样,BusinessService维护的PersonDao也使用注解注入:

 
    @Resource
   
     private PersonDao personDao;

Hibernate的搭建就完成了.

由于目前为止没有使用到Struts,我们不用在WEB上对Spring+Hibernate进行测试,用junit或者main方法都可以,在此用main方法测试.

搭建Spring

创建RegisterAction类(为后续的Struts作准备),在类加入main方法,放入web.action包中
配置beans.xml文件,放在类路径下

我们将在后面使用Spring的事务管理,所以要引入tx命名空间,事务管理器还需要被管理的切入点,不然就只是没有灵魂的空壳而已,aop命名空间也是必须的,还有对标注@Resource注解的字段进行注入,因而要引入context命名空间.

由于数据源在hibernate.cfg.xml文件中配置,hibernate中的session,就相当于Spring中的datasource,我们需要Spring获取hibernate.cfg.xml文件中的数据,Spring的org.springframework.orm.hibernate3包中,有着一系列整合hibernate框架的类,我们只需要使用LocalSessionFactoryBean类即可:

 
     <!-- 这是Spring整合Hibernate的入口 -->  
   
     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
   
         <!--   
   
             Spring生成sessionFactory需要Hibernate的配置文件Hibernate.cfg.xml   
   
             classpath:hibernate.cfg.xml: 表示在类路径下查找hibernate.cfg.xml文件,语法格式classpath:配置文件  
   
         -->          
   
         <property name="configLocation" value="classpath:hibernate.cfg.xml" />  
   
     </bean>

Spring标榜自己的声明式事务管理是多么多么的强大,我们不对事务管理器进行配置,岂不是白费了Spring的一番苦心?

 
     <!-- Spring支持5种事务管理器,分别对应不同的委托机制,我们现在使用Hibernate,就要使用Hibernate的事务管理器实现.  
   
             Spring支持的5种事务管理器:  
   
                 org.springframework.jdbc.datasource.DataSourceTransactionManager  
   
                 org.springframework.orm.hibernate3.HibernateTransactionManager  
   
                 org.springframework.jdo.JdoTransactionManager  
   
                 org.springframework.transaction.jta.JtaTransactionManager  
   
                 org.springframework.orm.ojb.PersistenceBrokerTransactionManager -->  
   
     <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
   
         <property name="sessionFactory" ref="sessionFactory"></property>  
   
     </bean>

接下来该配置事务管理器的通知(其实事务管理器就是一个切面):

 
     <!-- 配置通知   
   
         transaction-manager: 表示通知织入到的切面  
   
     -->  
   
     <tx:advice id="advice" transaction-manager="txManager">  
   
         <tx:attributes>  
   
             <tx:method name="save*" read-only="false" isolation="DEFAULT" propagation="REQUIRED"/>  
   
             <!-- 如果是其它方法 -->  
   
             <tx:method name="*" read-only="true"/>  
   
         </tx:attributes>  
   
     </tx:advice>

切入点:

 
     <!-- 配置切入点 -->  
   
     <aop:config>  
   
         <aop:pointcut id="perform" expression="execution(* ..service..*.*(..))"/>  <!-- 本文所有包名都用..代替,此表达式包名有误 -->  
   
         <aop:advisor pointcut-ref="perform" advice-ref="advice"/>  
   
     </aop:config>

由于PersonDao中维护了一个HibernateTemplate,BusinessService中维护了一个PersonDao,我们需要在配置文件中对它们进行注入:

 
     <!-- HibernateTemplate -->  
   
     <bean id="hibernateTemplat" class="org.springframework.orm.hibernate3.HibernateTemplate">  
   
         <property name="sessionFactory" ref="sessionFactory"></property>  
   
     </bean>  
   
     <!-- Dao层对象 -->  
   
     <bean id="personDao" class=".t.dao.PersonDao"></bean>  
   
     <!-- 配置业务层对象 -->  
   
     <bean id="service" class="..service.BusinessService"></bean>  
   
     <!-- 注册注解解析器 -->  
   
     <context:annotation-config></context:annotation-config>

最后再在RegisterAction中进行测试,RegisterAction:

 
     public class RegisterAction {    //由于只是测试,不需要继承Action  
   
         public static void main(String[] args) throws Exception {  
   
             ApplicationContext act = new ClassPathXmlApplicationContext("beans.xml");  
   
             BusinessService service = (BusinessService) act.getBean("service");  
   
             Person person = new Person();  
   
             //id设置了自增,不用管  
   
             person.setName("zhang");  
   
             service.save(person);  
   
         }  
   
     }

注:由于PersonDao和BusinessService都没有实现接口,故代理对象使用cglib库生成目标对象的子类.如果对事务管理器工作产生怀疑,可以在dao中分别抛出运行时异常和编译时异常进行测试.

搭建Struts

创建register.jsp和success.jsp文件,直接放在根目录下
RegisterAction继承自DispatchAction
维护一个BusinessService,由Spring运行时注入
配置struts-config.xml
配置web.xml

 
     <input type="hidden" name="method" value="save" />

待会在Struts的配置文件中对方法进行转发就行了.

success.jsp文件中也随便输出什么就行了,只要是看到就代表Action的跳转成功了.

把RegisterAction稍微修改一下:

 
     public class RegisterAction extends DispatchAction{ 
   
         /** 
   
          * 加了点形参,接收Struts传递的对象 
   
          */ 
   
         public ActionForward save(ActionMapping mapping, ActionForm form, 
   
                 HttpServletRequest request, HttpServletResponse response) { 
   
             ApplicationContext act = new ClassPathXmlApplicationContext("beans.xml"); 
   
             BusinessService service = (BusinessService) act.getBean("service"); 
   
             Person person = new Person(); 
   
             person.setName(request.getParameter("name")); 
   
             service.save(person); 
   
             return mapping.findForward("success"); 
   
         } 
   
    }

在WEB-INF下配置Struts的Action映射信息:

 
     <struts-config> 
   
         <action-mappings> 
   
             <action path="/register"  
   
                     type="..web.action.RegisterAction"  
   
                     scope="request" 
   
                     parameter="method">   //跟register.jsp中隐藏域的值对应 
   
                 <forward name="success" path="/success.jsp"></forward>         
   
             </action> 
   
         </action-mappings> 
   
     </struts-config>

再将ActionServlet在web.xml文件中映射进来就行了.

测试,如果跳转到success.jsp页面就代表成功了.

好了,程序逻辑就是这样,但是有三点需要注意,首先,Hibernate的配置文件中配置了一个连接池,这是Hibernate的开发者为了让人们学习Hibernate而开发的一个简易连接池,这个连接池在实际应用中是有BUG的,不能使用.那么我们就要在Spring里面配置连接池,并且要交由Spring管理:

Hibernate配置文件修改后如下:

 
     <hibernate-configuration> 
   
         <session-factory> 
   
             <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property> 
   
             <property name="hibernate.show_sql">true</property> 
   
             <property name="hibernate.hbm2ddl.auto">update</property> 
   
             <mapping resource="../../domain/Person.hbm.xml"/> 
   
         </session-factory> 
   
     </hibernate-configuration>

删除了关于连接的信息,然后在Spring的配置文件中加上连接池,以c3p0为例:

 
     <!-- 配置数据源 -->  
   
     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"> 
   
             <property name="driverClass" value="com.mysql.jdbc.Driver" /> 
   
             <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=GBK"/> 
   
             <property name="user" value="root" /> 
   
             <property name="password" value="root" /> 
   
             <!--连接池中保留的最小连接数。--> 
   
             <property name="minPoolSize" value="5" /> 
   
             <!--连接池中保留的最大连接数。Default: 15 --> 
   
             <property name="maxPoolSize" value="30" /> 
   
             <!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 --> 
   
             <property name="initialPoolSize" value="10"/> 
   
             <!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 --> 
   
             <property name="maxIdleTime" value="60"/> 
   
             <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 --> 
   
             <property name="acquireIncrement" value="5" /> 
   
             <!--JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements   
   
                 属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。   
   
                 如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0--> 
   
             <property name="maxStatements" value="0" /> 
   
             <!--每60秒检查所有连接池中的空闲连接。Default: 0 --> 
   
             <property name="idleConnectionTestPeriod" value="60" /> 
   
             <!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 --> 
   
             <property name="acquireRetryAttempts" value="30" /> 
   
             <!--获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效   
   
                 保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试   
   
                 获取连接失败后该数据源将申明已断开并永久关闭。Default: false--> 
   
             <property name="breakAfterAcquireFailure" value="true" /> 
   
     </bean>

在Spring的配置文件中加入这个还不够,它虽然知道有这么个连接池,但是没有管理起来,我们需要增加Spring在创建SessionFactory时的参数:

 
     <!-- 创建本地化工厂Bean,这是Spring整合Hibernate的入口 --> 
   
     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
   
         <!--  
   
             不得不说Spring的这玩意设计的很好,有dataSource这个属性, 
   
             dataSource就对应Hibernate中的sessionFactory  
   
         --> 
   
         <property name="dataSource" ref="dataSource"></property> 
   
         <!--  
   
             Spring生成sessionFactory需要Hibernate的配置文件Hibernate.cfg.xml  
   
             classpath:hibernate.cfg.xml: 表示在类路径下查找hibernate.cfg.xml文件,语法格式classpath:配置文件 
   
         -->         
   
         <property name="configLocation" value="classpath:hibernate.cfg.xml" /> 
   
     </bean>

这样一来,Spring就会管理这个连接池,池也能发挥作用了.第一点需要注意的就是Hibernate的池并不好用,学习娱乐一下没有问题,不要放在真正的项目上面去.

第二点就是Action中的BusinessService需要由Spring注入进来,而不是在同一个Action中都写上相同的获取BusinessService的代码.好吧,也许这个很简单,就不用说了...

第三点.

就是当你以为第二点很简单的时候你就错了!你要知道Action是什么时候创建的,它是由Spring创建的吗?Spring会在Struts创建这个Action的时候给它注入对象吗?Struts1中的Action只有一个,且都是在服务器初始化的时候一并初始化的,想要让Spring注入这个对象,至少也要让Spring在服务器初始化的时候加载进来

ApplicationContext act = new ClassPathXmlApplicationContext("beans.xml");

这段代码只能在程序运行时加载beans.xml文件,我们要让beans.xml文件随服务器的启动而启动,就需要配置上下文参数:

 
     <context-param> 
   
           <param-name>contextConfigLocation</param-name> 
   
            <!-- 加载beans.xml文件的方法二:classpath:beans.xml --> 
   
           <param-value>/WEB-INF/classes/beans.xml</param-value>   
   
     </context-param>

这段代码放在web.xml文件中,启动web应用的时候,这些参数就被读取到了ServletContext中,,整个web应用程序都共享这个上下文参数,注意和<init-param>标签不同,<init-param>是servlet范围内的参数,只能在servlet的init()方法中取得.

好了,光有上下文参数还不够,它只是以contextConfigLocation为Key,存储在ServletContext中而已,我们要让Spring容器启动,还是得用老办法:

 
     <!-- 通过servlet配置Spring容器随Web应用的启动而初始化 --> 
   
     <servlet> 
   
              <servlet-name>contextLoader</servlet-name> 
   
              <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class> 
   
             <load-on-startup>2</load-on-startup> 
   
     </servlet>

让ContextLoaderServlet 这个类加载,然后读取contextConfigLocation的数据,从而启动Spring,但是我并没有在这里指定读取哪个文件,也没有告诉它读取ServletContext中的contextConfigLocation,那么它是如何知道的呢?

 
     public static final String CONFIG_LOCATION_PARAM = "contextConfigLocation";

ContextLoaderServlet里面维护了一个ContextLoader,上面这个字符串常量是ContextLoader中的一人属性,那么就不用再说什么了吧?Spring会自动去找这个Key.

启动Spring就没有问题了,但是这样还不够,事实上我们需要在Struts创建Action的时候把BusinessService注入进来,这就需要我们对Struts的工作机制有相当的了解.Struts在工作的时候,使用了很多Processor(处理程序),每个处理程序都只完成一个功能,我们要利用Struts的这个特点,在适当的位置加入一个处理程序,然后注入对象.不过,Spring已经帮我们完成了这个功能,毕竟它号称支持全部主流框架,我们需要用到一个处理程序,但是不用考虑实现细节,修改后的Struts-config.xml文件如下:

 
     <struts-config> 
   
         <action-mappings> 
   
             <action path="/register"  
   
                     scope="request" 
   
                     parameter="method"> 
   
                 <forward name="success" path="/success.jsp"></forward>         
   
             </action> 
   
         </action-mappings> 
   
         <!--  
   
             ActionServlet中所有的工作委托给RequestProcessor负责 
   
             controller:struts中ActionServlet把请求委托给processorClass属性所指定的类来完成 
   
                * org.springframework.web.struts.DelegatingRequestProcessor该类完成 
   
                spring负责创建struts的Action对象,并注入业务层对象,剩下的工作仍由Struts完成 
   
         --> 
   
         <controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor"/> 
   
     </struts-config>

关键就是最后一句.注意:上面action中没有type属性,因为已经不需要了,写了也没有用,这是因为只要有DelegatingRequestProcessor 这个处理程序在,Struts读取这个配置文件的时候,它就会拿path指定的值去找Spring中的bean,意味着你其他不想要这样处理的action也要这样处理,不过Spring里面也很简单:

 
     <!-- 配置RegisterAction --> 
   
     <bean name="/register" class="..web.action.RegisterAction"> 
   
         <property name="service" ref="service"></property> 
   
     </bean>

就像这样,在Spring中加上这个一个bean就可以了,注意它和action的path属性值是一样的.最后修改的RegisterAction如下:

 
     public class RegisterAction extends DispatchAction{ 
   
         private BusinessService service;
 
         public ActionForward save(ActionMapping mapping, ActionForm form, 
   
                 HttpServletRequest request, HttpServletResponse response) { 
   
             Person person = new Person(); 
   
             person.setName(request.getParameter("name")); 
   
             this.service.save(person); 
   
             return mapping.findForward("success"); 
   
         } 
   
         public void setService(BusinessService service) { 
   
             this.service = service; 
   
         } 
   
    }

已经不需要多余的代码了,对象由Spring注入进来,然后剩下工作由Struts完成.没有解决中文乱码的问题.不过整合已经完成了.

另外,再提供另外一种解决方案,称做"分离",可以不必让Struts和Spring耦合的这么紧.

由于web.xml文件中已经将beans.xml读取到ServletContext中了,我们可以使用工具类读取ServletContext里面beans.xml的配置信息.先将beans.xml文件中关于action的配置删掉,再将Struts-config.xml文件中的处理程序删掉,给action配上type,就样就是一个传统的action配置.现在,Struts和Spring中已经没有各自的配置项了,是不是已经解耦了呢?不过光这样还不行,我们要修改RegisterAction中的代码,只需要加入两行而已:

 
     WebApplicationContext wct = WebApplicationContextUtils.getWebApplicationContext(this.getServlet().getServletContext()); 
   
     service = (BusinessService) wct.getBean("service");