Struts2+Hibernate+Spring 整合示例[转]

原文 http://blog.csdn.net/tkd03072010/article/details/7468769

Spring整合Struts2、Hibernate原理概述：

从用户角度来看，用户发出HTTP请求，当MVC框架的控制器组件拦截到用户请求时，将调用系统的业务逻辑组件，业务逻辑组件则调用系统的DAO组件，而DAO组件则依赖于SessionFactory和DataSource等底层组件实现数据库访问。

从系统实现角度看，Ioc容器先创建SessionFactory和DataSource等底层组件，然后将这些底层组件注入给DAO组件，提供一个完整的DAO组件，并将此DAO组件注入给业务逻辑组件，从而提供一个完整的业务逻辑组件，而业务逻辑组件又被注入给控制器组件，控制器组件负责拦截用户请求，并将处理结果呈现给用户——这一系列的衔接，都由Spring的IoC容器提供实现。

简单来说，Spring通过IoC容器上管（Struts2）Action的创建并依赖注入给控制器，下管（Hibernate）SessionFactory的创建并依赖注入给DAO组件，是一个巨大的工厂。（个人理解）

源代码下载：Regist_S2SH.rar

1.项目结构：

2.web.xml配置文件：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
5. http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
6. <welcome-file-list>
7. <welcome-file>index.jsp</welcome-file>
8. </welcome-file-list>
9. <!-- 使用ContextLoaderListener初始化Spring容器 -->
10. <listener>
11. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
12. </listener>
13. <!-- 定义Struts 2的FilterDispathcer的Filter -->
14. <filter>
15. <filter-name>struts2</filter-name>
16. <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
17. </filter>
18. <!-- FilterDispatcher用来初始化Struts 2并且处理所有的WEB请求。 -->
19. <filter-mapping>
20. <filter-name>struts2</filter-name>
21. <url-pattern>/*</url-pattern>
22. </filter-mapping>
23. </web-app>

3.applicationContext.xml配置

1. <?xml version="1.0" encoding="GBK"?>
2. <!-- 指定Spring配置文件的Schema信息 -->
3. <beans xmlns="http://www.springframework.org/schema/beans"
4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5. xmlns:aop="http://www.springframework.org/schema/aop"
6. xmlns:tx="http://www.springframework.org/schema/tx"
7. xsi:schemaLocation="http://www.springframework.org/schema/beans
8. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
9. http://www.springframework.org/schema/tx
10. http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
11. http://www.springframework.org/schema/aop
12. http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
13. <!-- 定义数据源Bean，使用C3P0数据源实现 -->
14. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
15. destroy-method="close">
16. <!-- 指定连接数据库的驱动 -->
17. <property name="driverClass" value="com.mysql.jdbc.Driver"/>
18. <!-- 指定连接数据库的URL -->
19. <property name="jdbcUrl" value="jdbc:mysql://localhost/javaee"/>
20. <!-- 指定连接数据库的用户名 -->
21. <property name="user" value="root"/>
22. <!-- 指定连接数据库的密码 -->
23. <property name="password" value="1120"/>
24. <!-- 指定连接数据库连接池的最大连接数 -->
25. <property name="maxPoolSize" value="40"/>
26. <!-- 指定连接数据库连接池的最小连接数 -->
27. <property name="minPoolSize" value="1"/>
28. <!-- 指定连接数据库连接池的初始化连接数 -->
29. <property name="initialPoolSize" value="1"/>
30. <!-- 指定连接数据库连接池的连接的最大空闲时间 -->
31. <property name="maxIdleTime" value="20"/>
32. </bean>
33. <!-- 定义Hibernate的SessionFactory -->
34. <bean id="sessionFactory"
35. class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
36. <!-- 依赖注入数据源，注入正是上面定义的dataSource -->
37. <property name="dataSource" ref="dataSource"/>
38. <!-- mappingResouces属性用来列出全部映射文件 -->
39. <property name="mappingResources">
40. <list>
41. <!-- 以下用来列出Hibernate映射文件 -->
42. <value>com/xqh/model/Person.hbm.xml</value>
43. </list>
44. </property>
45. <!-- 定义Hibernate的SessionFactory的属性 -->
46. <property name="hibernateProperties">
47. <!-- 配置Hibernate属性 -->
48. <value>
49. hibernate.dialect=org.hibernate.dialect.MySQLInnoDBDialect
50. hibernate.hbm2ddl.auto=update
51. hibernate.show_sql=true
52. hibernate.format_sql=true;
53. </value>
54. </property>
55. </bean>
56. <!-- 定义DAO Bean-->
57. <bean id="personDao" class=
58. "com.xqh.dao.impl.PersonDaoHibernate">
59. <!-- 注入持久化操作所需的SessionFactory -->
60. <property name="sessionFactory" ref="sessionFactory"/>
61. </bean>
62. <!-- 配置一个业务逻辑组件 -->
63. <bean id="service" class=
64. "com.xqh.service.impl.ServiceImpl">
65. <!-- 注入持久化访问所需的DAO组件 -->
66. <property name="personDao" ref="personDao"/>
67. </bean>
68. <!-- 配置Hibernate的局部事务管理器，使用HibernateTransactionManager类 -->
69. <!-- 该类实现PlatformTransactionManager接口，是针对Hibernate的特定实现-->
70. <bean id="transactionManager"
71. class="org.springframework.orm.hibernate3.HibernateTransactionManager">
72. <!-- 配置HibernateTransactionManager时需要依注入SessionFactory的引用 -->
73. <property name="sessionFactory" ref="sessionFactory"/>
74. </bean>
75. <!-- 配置事务增强处理,指定事务管理器 -->
76. <tx:advice id="txAdvice" transaction-manager="transactionManager">
77. <!-- 用于配置详细的事务语义 -->
78. <tx:attributes>
79. <!-- 所有以'get'开头的方法是read-only的 -->
80. <tx:method name="get*" read-only="true"/>
81. <!-- 其他方法使用默认的事务设置 -->
82. <tx:method name="*"/>
83. </tx:attributes>
84. </tx:advice>
85. <aop:config>
86. <!-- 配置一个切入点 -->
87. <aop:pointcut id="pointcut"
88. expression="bean(service)"/>
89. <!-- 指定在pointcut切入点应用txAdvice事务增强处理 -->
90. <aop:advisor advice-ref="txAdvice"
91. pointcut-ref="pointcut"/>
92. </aop:config>
93. </beans>

4.struts.xml配置：

1. <?xml version="1.0" encoding="GBK"?>
2. <!-- 指定Struts 2配置文件的DTD信息 -->
3. <!DOCTYPE struts PUBLIC
4. "-//Apache Software Foundation//DTD Struts Configuration 2.1.7//EN"
5. "http://struts.apache.org/dtds/struts-2.1.7.dtd">
6. <!-- Struts 2配置文件的根元素 -->
7. <struts>
8. <!-- 配置了系列常量 -->
9. <constant name="struts.i18n.encoding" value="GBK"/>
10. <constant name="struts.devMode" value="true"/>
11. <package name="xqh" extends="struts-default">
12. <!-- 定义处理用户请求的Action，指定该Action的实现类-->
13. <action name="registPro"
14. class="com.xqh.action.RegistAction">
15. <!-- 为两个逻辑视图配置视图页面 -->
16. <result name="error">/error.jsp</result>
17. <result name="success">/welcome.jsp</result>
18. </action>
19. <!-- 让用户直接访问该应用时列出所有视图页面 -->
20. <action name="*">
21. <result>/{1}.jsp</result>
22. </action>
23. </package>
24. </struts>

5.RegistAction.java代码清单：

1. package com.xqh.action;
2. import com.opensymphony.xwork2.Action;
3. import com.xqh.model.Person;
4. import com.xqh.service.Service;
5. public class RegistAction
6. implements Action
7. {
8. //下面是用于封装用户请求参数的属性
9. private Person person;
10. //用于封装处理结果的属性
11. private String tip;
12. //系统所用的业务逻辑组件
13. private Service service;
14. //设置注入业务逻辑组件所必需的setter方法
15. public void setService(Service service)
16. {
17. this.service = service;
18. }
19. //person属性的setter和getter方法
20. public void setPerson(Person person)
21. {
22. this.person = person;
23. }
24. public Person getPerson()
25. {
26. return this.person;
27. }
28. //tip属性的setter和getter方法
29. public void setTip(String tip)
30. {
31. this.tip = tip;
32. }
33. public String getTip()
34. {
35. return this.tip;
36. }
37. //处理用户请求的execute方法
38. public String execute()
39. throws Exception
40. {
41. //调用业务逻辑组件的regist方法来处理请求
42. if (service.regist(person))
43. {
44. setTip("哈哈，注册成功！");
45. return SUCCESS;
46. }
47. else
48. {
49. return ERROR;
50. }
51. }
52. }

6.personDao.java 代码清单：

1. package com.xqh.dao;
2. import java.util.List;
3. import com.xqh.model.Person;
4. public interface PersonDao
5. {
6. /**
7. * 加载Person实例
8. * @param id 需要加载的Person实例的主键值
9. * @return 返回加载的Person实例
10. */
11. Person get(Integer id);
12. /**
13. * 保存Person实例
14. * @param person 需要保存的Person实例
15. * @return 刚刚保存的Person实例的标识属性值
16. */
17. Integer save(Person person);
18. /**
19. * 修改Person实例
20. * @param person 需要修改的Person实例
21. */
22. void update(Person person);
23. /**
24. * 删除Person实例
25. * @param id 需要删除的Person实例的标识属性值
26. */
27. void delete(Integer id);
28. /**
29. * 删除Person实例
30. * @param person 需要删除的Person实例
31. */
32. void delete(Person person);
33. /**
34. * 根据用户名查找Person
35. * @param name 查询的人名
36. * @return 指定用户名对应的全部Person
37. */
38. List<Person> findByName(String name);
39. /**
40. * 查询全部Person实例
41. * @return 全部Person实例
42. */
43. public List<Person> findAllPerson();
44. }

7.personDaoHibernate.java代码清单：

1. package com.xqh.dao.impl;
2. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
3. import com.xqh.dao.PersonDao;
4. import com.xqh.model.Person;
5. import java.util.*;
6. public class PersonDaoHibernate
7. extends HibernateDaoSupport implements PersonDao
8. {
9. /**
10. * 加载Person实例
11. * @param id 需要加载的Person实例的标识属性值
12. * @return 指定id对应的Person实例
13. */
14. public Person get(Integer id)
15. {
16. return getHibernateTemplate()
17. .get(Person.class, id);
18. }
19. /**
20. * 保存Person实例
21. * @param person 需要保存的Person实例
22. * @return 刚刚保存的Person实例的标识属性值
23. */
24. public Integer save(Person person)
25. {
26. return (Integer)getHibernateTemplate()
27. .save(person);
28. }
29. /**
30. * 修改Person实例
31. * @param person 需要修改的Person实例
32. */
33. public void update(Person person)
34. {
35. getHibernateTemplate().update(person);
36. }
37. /**
38. * 删除Person实例
39. * @param id 需要删除的Person实例的标识属性值
40. */
41. public void delete(Integer id)
42. {
43. getHibernateTemplate().delete(get(id));
44. }
45. /**
46. * 删除Person实例
47. * @param person 需要删除的Person实例
48. */
49. public void delete(Person person)
50. {
51. getHibernateTemplate().delete(person);
52. }
53. /**
54. * 根据用户名查找Person
55. * @param name 查询的人名
56. * @return 指定用户名对应的全部Person
57. */
58. @SuppressWarnings("unchecked")
59. public List<Person> findByName(String name)
60. {
61. return (List<Person>)getHibernateTemplate()
62. .find("from Person p where p.name like ?" , name);
63. }
64. /**
65. * 查询全部Person实例
66. * @return 全部Person实例
67. */
68. @SuppressWarnings("unchecked")
69. public List<Person> findAllPerson()
70. {
71. return (List<Person>)getHibernateTemplate()
72. .find("from Person");
73. }
74. }

8.Person.java代码清单：

1. package com.xqh.model;
2. public class Person
3. {
4. private Integer id;
5. private String name;
6. private int age;
7. //无参数的构造器
8. public Person()
9. {
10. }
11. //初始化全部属性的构造器
12. public Person(String name , int age)
13. {
14. this.name = name;
15. this.age = age;
16. }
17. //id属性的setter和getter方法
18. public void setId(Integer id)
19. {
20. this.id = id;
21. }
22. public Integer getId()
23. {
24. return this.id;
25. }
26. //name属性的setter和getter方法
27. public void setName(String name)
28. {
29. this.name = name;
30. }
31. public String getName()
32. {
33. return this.name;
34. }   //age属性的setter和getter方法
35. public void setAge(int age)
36. {
37. this.age = age;
38. }
39. public int getAge()
40. {
41. return this.age;
42. }
43. }

9.Person.hbm.xml配置：

1. <?xml version="1.0" encoding="GBK"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
5. <hibernate-mapping package="com.xqh.model">
6. <class name="Person" table="tb_person">
7. <!-- 映射标识属性 -->
8. <id name="id" column="Id"
9. type="int">
10. <!-- 指定主键生成器策略 -->
11. <generator class="increment"/>
12. </id>
13. <!-- 映射普通属性 -->
14. <property name="name" type="string"/>
15. <property name="age" type="int"/>
16. </class>
17. </hibernate-mapping>

10.Service.java代码清单：

1. package com.xqh.service;
2. import com.xqh.model.Person;
3. public interface Service
4. {
5. //注册用户
6. boolean regist(Person person);
7. }

11.ServiceImpl.java代码清单：

1. package com.xqh.service.impl;
2. import com.xqh.dao.PersonDao;
3. import com.xqh.model.Person;
4. import com.xqh.service.Service;
5. public class ServiceImpl
6. implements Service
7. {
8. private PersonDao personDao;
9. //依赖注入DAO组件所需的setter方法
10. public void setPersonDao(PersonDao personDao)
11. {
12. this.personDao = personDao;
13. }
14. //注册用户
15. public boolean regist(Person person)
16. {
17. //调用DAO组件的方法来实现业务逻辑
18. int result = personDao.save(person);
19. if (result > 0)
20. {
21. return true;
22. }
23. return false;
24. }
25. }

12.运行结果：