spring学习(四) ———— 整合web项目(SSH)

　　　　　清楚了spring的IOC 和 AOP，最后一篇就来整合SSH框架把，记录下来，以后应该会用的到。

　　　　　　　　　　　　　　　　　　　　--WH

一、web项目中如何使用spring？

　　　　　　当tomcat启动时，就应该加载spring的配置文件，而不是每次都要手动使用new  ClassPathXmlApplicationContext来加载xml。所以，spring提供了一个ContextLoaderListener。有了它，tomcat启动时，就会加载配置文件。

　　　　　　导入spring.web....jar

　　　　　　　　　　

　　　　　　1、web.xml中添加监听器

　　　　　　　　　　

1 <!-- 配置监听器，用于加载spring 配置文件 -->
2     <listener>
3         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
4     </listener>

1 <!-- 配置监听器，用于加载spring 配置文件 -->
2     <listener>
3         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
4     </listener>

　　　　　　　　这样配置的监听器，默认加载的是WEB-INF目录下的xml文件，而我们的配置文件在src下，所以需要进行下一步的配置。

　　　　　　2、web.xml中配置 applicationContext.xml 位置

　　　　　　　　　　

1 <!-- 设置web全局初始化参数，设置配置文件位置
2         * 名称#contextConfigLocation 固定值
3         * 值# “classpath:”表示类路径（src）
4             也可以有子包 #  classspath:com/wuhao/applicationContext.xml
5     -->
6     <context-param>
7         <param-name>contextConfigLocation</param-name>
8         <param-value>classpath:applicationContext.xml</param-value>
9     </context-param>

1 <!-- 设置web全局初始化参数，设置配置文件位置
2         * 名称#contextConfigLocation 固定值
3         * 值# “classpath:”表示类路径（src）
4             也可以有子包 #  classspath:com/wuhao/applicationContext.xml
5     -->
6     <context-param>
7         <param-name>contextConfigLocation</param-name>
8         <param-value>classpath:applicationContext.xml</param-value>
9     </context-param>

　　　　　　3、从ServletContext中获得spring容器，创建的容器已经放在ServletContext中了

　　　　　　　　　　　　

1 //方式1：手动从ServletContext作用域获得内容
2         //WebApplicationContext applicationContext = (WebApplicationContext) this.getServletContext().getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
3
4         //方式2：提供工具类
5         WebApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());

1 //方式1：手动从ServletContext作用域获得内容
2         //WebApplicationContext applicationContext = (WebApplicationContext) this.getServletContext().getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
3
4         //方式2：提供工具类
5         WebApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());

　　　　　　　　　　

二、SSH整合所用到的jar包

　　　　　　2.1、struts2所需jar

　　　　　　　　版本：2.3.15.1

　　　　　　　　位置：struts-2.3.15.1\apps\struts2-blank\WEB-INF\lib

　　　　　　　　　　　　

　　　　　　　　　　总共：13个jar包　　　　　　　　

　　　　　　2.2、hibernate

　　　　　　　　　　版本：3.6.10

　　　　　　　　　　所需jar

　　　　　　　　　　　　　　1、核心jar：hibernate3.jar

　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　2、必须：lib/required 所有

　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　3、jpa ：lib\jpa 所有

　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　4、c3p0 \lib\optional\c3p0

　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　5、 log4j 整合jar　　slf4j-log4j12-1.7.2.jar

　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　6、mysql驱动包　　mysql-connector-java-5.1.22-bin.jar

　　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　7、二级缓存　　ehcache-1.5.0.jar  、backport-util-concurrent.jar 原本要导3个，logging包在前面struts包中有了，所以无需在导入

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　　　　　　　　　 hibernate总共：13个jar包

　　　　　　2.3、spring

　　　　　　　　　　版本：3.2.0

　　　　　　　　　　jar包：

　　　　　　　　　　　　　核心：4个(core、beans、expression、context) + commons-logging..jar(这个jar包在前面很多地方导入过，struts2、hibernate的二级缓存、spring都需要，只需要导一份即可)

　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　aop：aop联盟、spring aop、aspectj、spring-aspect

　　　　　　　　　　　　　　　　　　aop联盟：spring-framework-3.0.2.RELEASE-dependencies\org.aopalliance\com.springsource.org.aopalliance\1.0.0

　　　　　　　　　　　　　　　　　　spring aop和spring-aspect：在核心包中

　　　　　　　　　　　　　　　　　　aspectj：spring-framework-3.0.2.RELEASE-dependencies\org.aspectj\com.springsource.org.aspectj.weaver\1.6.8.RELEASE　　　　　

　　　　　　　　　　　　　　jdbc：2个 spring-jdbc、spring-tx

　　　　　　　　　　　　　　web：1个 spring-web

　　　　　　　　　　　　　　test：1个 spring-test （整合测试）

　　　　　　　　　　总共：12个

　　　　　　2.4、整合jar

　　　　　　　　　　spring3 整合hibernate3，spring提供整合jar ： spring-orm...jar

　　　　　　　　　　struts2 整合 spring3 ，struts提供整合jar：struts2-spring-plugin-2.3.15.1.jar

　　　　　　　　　　　　　　位置：struts-2.3.15.1\lib

　　　　　　　　　　总共：2个

　　　　　　　　

　　　　　　2.5、整理jar

　　　　　　　　　　前面拿到总共39个，去除一个重复的，剩下总共38个。

　　　　　　　　　　　　　　　　

　　　　　　　　　　

三、配置文件

　　　　　　3.1、hibernate

　　　　　　　　　　hibernate.cfg.xml　　核心配置文件

　　　　　　　　　　*.hbm.xml  映射文件（domain)

　　　　　　3.2、spring

　　　　　　　　　　applicationContext.xml

　　　　　　　　　　jdbcInfo.properties

　　　　　　　　　　web.xml(ContextLoaderListener)

　　　　　　3.3、struts2

　　　　　　　　　　struts.xml

　　　　　　　　　　web.xml(前端过滤器　　StrutsPrepareAndExecuteFilter)

　　　　　　

四、spring整合hibernate

　　　　　　4.1、首先要了解hibernate的配置文件，和hibernate需要什么，然后如何将其让spring来管理。

　　　　　　　　　　hibernate.cfg.xml

　　　　　　　　　　　　

　　　　　　　　　　　　

　　　　　　　　通过这两个图，可以知道，spring需要帮hibernate获取session，而获取session则先要获得sessionFactory，获取sessionFactory则需要加载配置文件。所以spring就需要提供两个东西，一个sessionFactory，一个session。spring如何做的呢？

　　　　　　　　　　　　

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xsi:schemaLocation="
 5 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 6
 7 <!-- 配置数据源  c3p0,-->
 8 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
 9     <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
10     <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test_1"></property>
11     <property name="user" value="root"></property>
12     <property name="password" value="root"></property>
13 </bean>
14
15 <!-- 获取sessionFactory需要加载hibernate.cfg.xml获取其中的配置的信息，那么直接将那些配置信息在这里配置 -->
16 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
17     <property name="dataSource" ref="dataSource"></property>
18     <!-- 配置一些其他的信息，方言等 -->
19     <property name="hibernateProperties">
20         <props>
21             <prop key="hibernate.dialect">
22                 org.hibernate.dialect.MySQLDialect
23             </prop>
24             <prop key="hibernate.show_sql">true</prop>
25             <prop key="hibernate.format_sql">true</prop>
26             <prop key="hibernate.hbm2ddl.auto">update</prop>
27         </props>
28     </property>
29     <!-- 添加映射文件 -->
30     <property name="mappingLocations" value="classpath:com/wuhao/domain/User.hbm.xml"></property>
31 </bean>
32
33 <!-- hibernate中通过sessionFactory创建得session对对象进行操作，spring提供一个hibernateTemplate进行操作，跟spring中的jdbcTemplate一样，
34     继承HibernateDaoSupport后，注入SessionFactory即可，在dao层就不用在写hibernateTemplate的set方法了。
35  -->
36  <bean id="userDao" class="com.wuhao.dao.UserDao">
37      <property name="sessionFactory" ref="sessionFactory"></property>
38  </bean>
39
40
41 </beans>

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xsi:schemaLocation="
 5 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 6
 7 <!-- 配置数据源  c3p0,-->
 8 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
 9     <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
10     <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test_1"></property>
11     <property name="user" value="root"></property>
12     <property name="password" value="root"></property>
13 </bean>
14
15 <!-- 获取sessionFactory需要加载hibernate.cfg.xml获取其中的配置的信息，那么直接将那些配置信息在这里配置 -->
16 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
17     <property name="dataSource" ref="dataSource"></property>
18     <!-- 配置一些其他的信息，方言等 -->
19     <property name="hibernateProperties">
20         <props>
21             <prop key="hibernate.dialect">
22                 org.hibernate.dialect.MySQLDialect
23             </prop>
24             <prop key="hibernate.show_sql">true</prop>
25             <prop key="hibernate.format_sql">true</prop>
26             <prop key="hibernate.hbm2ddl.auto">update</prop>
27         </props>
28     </property>
29     <!-- 添加映射文件 -->
30     <property name="mappingLocations" value="classpath:com/wuhao/domain/User.hbm.xml"></property>
31 </bean>
32
33 <!-- hibernate中通过sessionFactory创建得session对对象进行操作，spring提供一个hibernateTemplate进行操作，跟spring中的jdbcTemplate一样，
34     继承HibernateDaoSupport后，注入SessionFactory即可，在dao层就不用在写hibernateTemplate的set方法了。
35  -->
36  <bean id="userDao" class="com.wuhao.dao.UserDao">
37      <property name="sessionFactory" ref="sessionFactory"></property>
38  </bean>
39
40
41 </beans>

　　　　　　　　使用：

　　　　　　　　　　　　　

　　　　　　　　这样一来，就可以将hibernte.cfg.xml给删除掉了。

　　　　　　　　还有一个问题，事务的处理。

　　　　　　　　简单，之前一篇文章我们就讲解了spring如何进行事务管理的，那时候使用的是jdbc管理器，现在换一个即可，使用hibernate事务管理器

　　　　　　　　　　　　

　　　　　　　　所以整合完hibernate后，spring的配置文件就成了这样

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:aop="http://www.springframework.org/schema/aop"
 5        xmlns:tx="http://www.springframework.org/schema/tx"
 6        xsi:schemaLocation="http://www.springframework.org/schema/beans
 7                               http://www.springframework.org/schema/beans/spring-beans.xsd
 8                               http://www.springframework.org/schema/aop
 9                               http://www.springframework.org/schema/aop/spring-aop.xsd
10                               http://www.springframework.org/schema/tx
11                               http://www.springframework.org/schema/tx/spring-tx.xsd">
12 <!-- hibernate -->
13 <!-- 配置数据源  c3p0,-->
14 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
15     <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
16     <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test_1"></property>
17     <property name="user" value="root"></property>
18     <property name="password" value="root"></property>
19 </bean>
20
21 <!-- 获取sessionFactory需要加载hibernate.cfg.xml获取其中的配置的信息，那么直接将那些配置信息在这里配置 -->
22 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
23     <property name="dataSource" ref="dataSource"></property>
24     <!-- 配置一些其他的信息，方言等 -->
25     <property name="hibernateProperties">
26         <props>
27             <prop key="hibernate.dialect">
28                 org.hibernate.dialect.MySQLDialect
29             </prop>
30             <prop key="hibernate.show_sql">true</prop>
31             <prop key="hibernate.format_sql">true</prop>
32             <prop key="hibernate.hbm2ddl.auto">update</prop>
33         </props>
34     </property>
35     <!-- 添加映射文件 -->
36     <property name="mappingLocations" value="classpath:com/wuhao/domain/User.hbm.xml"></property>
37 </bean>
38
39 <!-- hibernate中通过sessionFactory创建得session对对象进行操作，spring提供一个hibernateTemplate进行操作，跟spring中的jdbcTemplate一样，
40     继承HibernateDaoSupport后，注入SessionFactory即可，在dao层就不用在写hibernateTemplate的set方法了。
41  -->
42  <bean id="userDao" class="com.wuhao.dao.UserDao">
43      <property name="sessionFactory" ref="sessionFactory"></property>
44  </bean>
45
46  <!-- hiberntae事务管理器,也需要将sessionFactory加进来，从hibernate中得代码就可以看出来，事务也是由sessionFactory获取来的-->
47 <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
48     <property name="sessionFactory" ref="sessionFactory"></property>
49 </bean>
50 <!-- 事务详情 -->
51 <tx:advice id="txAdvice" transaction-manager="txManager">
52     <tx:attributes>
53         <tx:method name="add" propagation="REQUIRED"/>
54     </tx:attributes>
55 </tx:advice>
56
57 <!-- aop事务管理 ，要使用事务和aop，需要在上面导入dtd。我这里图方便，没写接口，所以需要叫spring使用cglib-->
58 <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
59 <aop:config>
60     <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.wuhao.service.*.*(..))"/>
61 </aop:config>
62 </beans>

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:aop="http://www.springframework.org/schema/aop"
 5        xmlns:tx="http://www.springframework.org/schema/tx"
 6        xsi:schemaLocation="http://www.springframework.org/schema/beans
 7                               http://www.springframework.org/schema/beans/spring-beans.xsd
 8                               http://www.springframework.org/schema/aop
 9                               http://www.springframework.org/schema/aop/spring-aop.xsd
10                               http://www.springframework.org/schema/tx
11                               http://www.springframework.org/schema/tx/spring-tx.xsd">
12 <!-- hibernate -->
13 <!-- 配置数据源  c3p0,-->
14 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
15     <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
16     <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test_1"></property>
17     <property name="user" value="root"></property>
18     <property name="password" value="root"></property>
19 </bean>
20
21 <!-- 获取sessionFactory需要加载hibernate.cfg.xml获取其中的配置的信息，那么直接将那些配置信息在这里配置 -->
22 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
23     <property name="dataSource" ref="dataSource"></property>
24     <!-- 配置一些其他的信息，方言等 -->
25     <property name="hibernateProperties">
26         <props>
27             <prop key="hibernate.dialect">
28                 org.hibernate.dialect.MySQLDialect
29             </prop>
30             <prop key="hibernate.show_sql">true</prop>
31             <prop key="hibernate.format_sql">true</prop>
32             <prop key="hibernate.hbm2ddl.auto">update</prop>
33         </props>
34     </property>
35     <!-- 添加映射文件 -->
36     <property name="mappingLocations" value="classpath:com/wuhao/domain/User.hbm.xml"></property>
37 </bean>
38
39 <!-- hibernate中通过sessionFactory创建得session对对象进行操作，spring提供一个hibernateTemplate进行操作，跟spring中的jdbcTemplate一样，
40     继承HibernateDaoSupport后，注入SessionFactory即可，在dao层就不用在写hibernateTemplate的set方法了。
41  -->
42  <bean id="userDao" class="com.wuhao.dao.UserDao">
43      <property name="sessionFactory" ref="sessionFactory"></property>
44  </bean>
45
46  <!-- hiberntae事务管理器,也需要将sessionFactory加进来，从hibernate中得代码就可以看出来，事务也是由sessionFactory获取来的-->
47 <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
48     <property name="sessionFactory" ref="sessionFactory"></property>
49 </bean>
50 <!-- 事务详情 -->
51 <tx:advice id="txAdvice" transaction-manager="txManager">
52     <tx:attributes>
53         <tx:method name="add" propagation="REQUIRED"/>
54     </tx:attributes>
55 </tx:advice>
56
57 <!-- aop事务管理 ，要使用事务和aop，需要在上面导入dtd。我这里图方便，没写接口，所以需要叫spring使用cglib-->
58 <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
59 <aop:config>
60     <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.wuhao.service.*.*(..))"/>
61 </aop:config>
62 </beans>

　　　　　　总结：其实非常简单，一开始整合肯定毫无头绪，不知道从哪里下手，那么就先将一个最简单的hibernate操作对象的小demo写出来，看看hibernate需要什么，然后spring就配置什么，给什么。这样就简单明了了。

五、struts2整合spring

　　　　　　5.1、struts2自己创建action。而不用spring帮我们创建

　　　　　　　　　　struts.xml

　　　　　　　　　　　　　　　　　　　　　

　　　　　　　　　　action中userService对象的创建就需要让spring帮我们创建

　　　　　　　　　　　　　　　　　　

　　　　　　　　　　applicationContext.xml

　　　　　　　　　　　　　　

　　　　　　　　　　这样，就可以了。

　　　　　　

　　　　　　5.2、spring帮我们创建action，struts2什么也不用做了。‘

　　　　　　　　　　　　前提：需要导入struts-spring-plugin...jar

　　　　　　　　　　

　　　　　　全部整合完后的applicationContext.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:aop="http://www.springframework.org/schema/aop"
 5        xmlns:tx="http://www.springframework.org/schema/tx"
 6        xsi:schemaLocation="http://www.springframework.org/schema/beans
 7                               http://www.springframework.org/schema/beans/spring-beans.xsd
 8                               http://www.springframework.org/schema/aop
 9                               http://www.springframework.org/schema/aop/spring-aop.xsd
10                               http://www.springframework.org/schema/tx
11                               http://www.springframework.org/schema/tx/spring-tx.xsd">
12 <!-- struts2自己创建Action的配置，就不需要21到24行的代码，如果是spring创建action，则需要 -->
13 <!--
14     action中的userService对象，在这里配置就能够获取到。为什么能够直接配置就能够得到，
15     需要导入struts-spring-plugin...jar，因为有它和default.properties的结合所以才能够直接配置得到
16  -->
17 <bean id="userService" class="com.wuhao.service.UserService">
18 <!-- userDao在hibernate整合时就已经创建了bean，所以就直接拿过来用 -->
19     <property name="userDao" ref="userDao"></property>
20 </bean>
21 <!-- 配置action -->
22 <bean id="userAction" class="com.wuhao.action.UserAction">
23     <property name="userService" ref="userService"></property>
24 </bean>
25
26 <!-- hibernate -->
27 <!-- 配置数据源  c3p0,-->
28 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
29     <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
30     <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test_1"></property>
31     <property name="user" value="root"></property>
32     <property name="password" value="root"></property>
33 </bean>
34
35 <!-- 获取sessionFactory需要加载hibernate.cfg.xml获取其中的配置的信息，那么直接将那些配置信息在这里配置 -->
36 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
37     <property name="dataSource" ref="dataSource"></property>
38     <!-- 配置一些其他的信息，方言等 -->
39     <property name="hibernateProperties">
40         <props>
41             <prop key="hibernate.dialect">
42                 org.hibernate.dialect.MySQLDialect
43             </prop>
44             <prop key="hibernate.show_sql">true</prop>
45             <prop key="hibernate.format_sql">true</prop>
46             <prop key="hibernate.hbm2ddl.auto">update</prop>
47         </props>
48     </property>
49     <!-- 添加映射文件 -->
50     <property name="mappingLocations" value="classpath:com/wuhao/domain/User.hbm.xml"></property>
51 </bean>
52
53 <!-- hibernate中通过sessionFactory创建得session对对象进行操作，spring提供一个hibernateTemplate进行操作，跟spring中的jdbcTemplate一样，
54     继承HibernateDaoSupport后，注入SessionFactory即可，在dao层就不用在写hibernateTemplate的set方法了。
55  -->
56  <bean id="userDao" class="com.wuhao.dao.UserDao">
57      <property name="sessionFactory" ref="sessionFactory"></property>
58  </bean>
59
60  <!-- hiberntae事务管理器,也需要将sessionFactory加进来，从hibernate中得代码就可以看出来，事务也是由sessionFactory获取来的-->
61 <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
62     <property name="sessionFactory" ref="sessionFactory"></property>
63 </bean>
64 <!-- 事务详情 -->
65 <tx:advice id="txAdvice" transaction-manager="txManager">
66     <tx:attributes>
67         <tx:method name="add" propagation="REQUIRED"/>
68     </tx:attributes>
69 </tx:advice>
70
71 <!-- aop事务管理 ，要使用事务和aop，需要在上面导入dtd。我这里图方便，没写接口，所以需要叫spring使用cglib-->
72 <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
73 <aop:config>
74     <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.wuhao.service.*.*(..))"/>
75 </aop:config>
76 </beans>

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:aop="http://www.springframework.org/schema/aop"
 5        xmlns:tx="http://www.springframework.org/schema/tx"
 6        xsi:schemaLocation="http://www.springframework.org/schema/beans
 7                               http://www.springframework.org/schema/beans/spring-beans.xsd
 8                               http://www.springframework.org/schema/aop
 9                               http://www.springframework.org/schema/aop/spring-aop.xsd
10                               http://www.springframework.org/schema/tx
11                               http://www.springframework.org/schema/tx/spring-tx.xsd">
12 <!-- struts2自己创建Action的配置，就不需要21到24行的代码，如果是spring创建action，则需要 -->
13 <!--
14     action中的userService对象，在这里配置就能够获取到。为什么能够直接配置就能够得到，
15     需要导入struts-spring-plugin...jar，因为有它和default.properties的结合所以才能够直接配置得到
16  -->
17 <bean id="userService" class="com.wuhao.service.UserService">
18 <!-- userDao在hibernate整合时就已经创建了bean，所以就直接拿过来用 -->
19     <property name="userDao" ref="userDao"></property>
20 </bean>
21 <!-- 配置action -->
22 <bean id="userAction" class="com.wuhao.action.UserAction">
23     <property name="userService" ref="userService"></property>
24 </bean>
25
26 <!-- hibernate -->
27 <!-- 配置数据源  c3p0,-->
28 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
29     <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
30     <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test_1"></property>
31     <property name="user" value="root"></property>
32     <property name="password" value="root"></property>
33 </bean>
34
35 <!-- 获取sessionFactory需要加载hibernate.cfg.xml获取其中的配置的信息，那么直接将那些配置信息在这里配置 -->
36 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
37     <property name="dataSource" ref="dataSource"></property>
38     <!-- 配置一些其他的信息，方言等 -->
39     <property name="hibernateProperties">
40         <props>
41             <prop key="hibernate.dialect">
42                 org.hibernate.dialect.MySQLDialect
43             </prop>
44             <prop key="hibernate.show_sql">true</prop>
45             <prop key="hibernate.format_sql">true</prop>
46             <prop key="hibernate.hbm2ddl.auto">update</prop>
47         </props>
48     </property>
49     <!-- 添加映射文件 -->
50     <property name="mappingLocations" value="classpath:com/wuhao/domain/User.hbm.xml"></property>
51 </bean>
52
53 <!-- hibernate中通过sessionFactory创建得session对对象进行操作，spring提供一个hibernateTemplate进行操作，跟spring中的jdbcTemplate一样，
54     继承HibernateDaoSupport后，注入SessionFactory即可，在dao层就不用在写hibernateTemplate的set方法了。
55  -->
56  <bean id="userDao" class="com.wuhao.dao.UserDao">
57      <property name="sessionFactory" ref="sessionFactory"></property>
58  </bean>
59
60  <!-- hiberntae事务管理器,也需要将sessionFactory加进来，从hibernate中得代码就可以看出来，事务也是由sessionFactory获取来的-->
61 <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
62     <property name="sessionFactory" ref="sessionFactory"></property>
63 </bean>
64 <!-- 事务详情 -->
65 <tx:advice id="txAdvice" transaction-manager="txManager">
66     <tx:attributes>
67         <tx:method name="add" propagation="REQUIRED"/>
68     </tx:attributes>
69 </tx:advice>
70
71 <!-- aop事务管理 ，要使用事务和aop，需要在上面导入dtd。我这里图方便，没写接口，所以需要叫spring使用cglib-->
72 <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
73 <aop:config>
74     <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.wuhao.service.*.*(..))"/>
75 </aop:config>
76 </beans>

六、总结

　　　　　　那么到这里，手动整合ssh就结束了，其实非常简单，一步步来，从导包到整合hibernate在整合struts的步骤进行，那么就可以成功整合了，上面所有的我都没有采用接口编程，为了方便，日后注意一下这点即可。非常简单。

　　　　　　但是在整合hibernate时，我们的你domain都映射文件都是自己手动编写的，实际开发中肯定不需要一个个手动编写，因为是先有数据库，然后在来写你domain，所以之后会说到通过反转引擎根据数据库中的表来创建domain和映射文件。