原文： https://howtodoinjava.com/struts2/spring-4-struts-2-hibernate-integration-tutorial/

以前，我已经介绍了 Spring3 + Hibernate 集成示例和 Struts2 helloworld 示例。 在本教程中，我将讨论将 spring 框架与 Struts 和 Hibernate 结合使用时要记住的所有重要点。 另外，请注意，本教程使用了其他次要但很重要的概念，例如日志记录，TLD 的使用和事务以及已集成到本教程中。 因此，请记住还要检查其详细信息。

在本教程中，我将使用简单的功能（例如全部获取，添加和删除）来构建员工管理屏幕。 它看起来像这样：

Spring4 Struts2 Hibernate 集成教程 - 图1

我将按照以下步骤讨论集成过程：

  1. 1) Integration Overview 
  2. 2) Spring + Struts Integration
  3. 3) Spring + Hibernate Integration
  4. 4) Other Integrated Functionalities
  5.     a) Log4j
  6.     b) TLDs
  7.     c) Transactions
  8. 5) Important Points to Keep Remember
  9. 6) Database Schema Used in Tutorial
  10. 7) 下载源码

1）概述

在进入集成细节之前，让我们先确定一下为什么我们需要此集成本身。 像 Struts 一样，Spring 也可以充当 MVC 实现。 两种框架都有其优缺点，仍然有很多人会同意 Spring 更好，并且提供了更广泛的功能。 对我来说，只有两种情况，您需要本教程中提供的信息：

i）您有一个用 Struts 编写的旧应用，并且想要使用 spring 来提高应用的功能很多倍。

ii）您确实想根据自己的原因来学习它。

否则，我不知道为什么有人会在 Spring 选择支柱。 如果您知道其他一些好的理由，请与我们所有人分享。 那挺棒的。

继续，在本教程中，我将委托从 Struts 到 Spring 进行动作管理。 进行委派的原因是，通过 Spring 上下文实例化Action类时，它可以使用 spring 在其自己的 MVC 实现中为其提供的Controller类的所有其他功能。 因此，您将获得所有 spring 功能以及 struts Action类，以具有包括ActionForm概念在内的控制器逻辑。

2）Spring + Struts 集成

这是核心逻辑，从在web.xml中注册ContextLoaderListener和StrutsPrepareAndExecuteFilter开始。 ContextLoaderListener带有初始化参数contextConfigLocation，并负责设置和启动 Spring WebApplicationContext。 现在，struts 将在与 Spring 相关的服务中特别是在依赖项注入 and dependency injection (DI) patterns in spring framework and related interview questions”)中利用此上下文。

StrutsPrepareAndExecuteFilter在类路径中查找struts.xml文件，并配置 strut 的特定内容，例如动作映射，全局转发和其他在struts.xml文件中定义的内容。

web.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  3. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.     xmlns="http://java.sun.com/xml/ns/javaee"
  5.     xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  6.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://www.oracle.com/technetwork/java/index.html; id="WebApp_ID" version="2.5">
  8.   <display-name>Spring+Struts+Hibernate Integration Example</display-name>
  9.       <welcome-file-list>
  10.           <welcome-file>/WEB-INF/index.jsp</welcome-file>
  11.       </welcome-file-list>
  13.       <!-- Specify the spring context information location;
  14.       Default location is applicationContext.xml file in classpath
  15.        -->
  16.       <context-param>
  17.         <param-name>contextConfigLocation</param-name>
  18.         <param-value>classpath:beans.xml</param-value>
  19.     </context-param>
  20.     <!-- Bootstrap listener to start up and shut down Spring's root WebApplicationContext. -->
  21.       <listener>  
  22.           <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  23.     </listener> 
  24.     <!-- Handles both the preparation and execution phases of the Struts dispatching process. -->
  25.     <filter>  
  26.         <filter-name>struts2</filter-name>  
  27.         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>  
  28.         <init-param>
  29.             <param-name>debug</param-name>
  30.             <param-value>0</param-value>
  31.         </init-param>
  32.         <init-param>
  33.             <param-name>detail</param-name>
  34.             <param-value>0</param-value>
  35.         </init-param>
  36.     </filter>  
  37.     <filter-mapping>  
  38.         <filter-name>struts2</filter-name>  
  39.         <url-pattern>/*</url-pattern>  
  40.     </filter-mapping>  
  41.     <!-- Struts Tag Library Descriptors -->
  42.     <jsp-config>
  43.         <taglib>
  44.             <taglib-uri>/tags/struts-bean</taglib-uri>
  45.             <taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
  46.         </taglib>
  47.         <taglib>
  48.             <taglib-uri>/tags/struts-html</taglib-uri>
  49.             <taglib-location>/WEB-INF/struts-html.tld</taglib-location>
  50.         </taglib>
  51.         <taglib>
  52.             <taglib-uri>/tags/struts-logic</taglib-uri>
  53.             <taglib-location>/WEB-INF/struts-logic.tld</taglib-location>
  54.         </taglib>
  55.         <taglib>
  56.             <taglib-uri>/tags/struts-nested</taglib-uri>
  57.             <taglib-location>/WEB-INF/struts-nested.tld</taglib-location>
  58.         </taglib>
  59.     </jsp-config>
  60. </web-app>

第二步，将在struts.xml文件中创建操作映射，如下所示：

struts.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE struts PUBLIC
  3. "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
  4. "http://struts.apache.org/dtds/struts-2.0.dtd">    
  6. <struts>
  7.     <!-- devMode is helpful when you want some extra logs for debugging -->
  8.     <constant name="struts.devMode" value="false" />
  9.     <!-- Global message resource; 
  10.          Otherwise you will have seperate message resource for each Action 
  11.     -->
  12.     <constant name="struts.custom.i18n.resources" value="messages" /> 
  13.     <!-- 
  14.         This is important if you are planning to have slashes in Action URLs
  15.         e.g. In this demo, employee is deleted using URL /delete/10
  16.         This this is set to false; then struts will try to find mapping for 
  17.         URL "/10" instaed of "/delete/10"
  18.      -->
  19.     <constant name="struts.enable.SlashesInActionNames" value="true"/>
  21.     <!-- Normal Action mappings are defined here -->
  22.     <package name="default" namespace="" extends="struts-default">
  23.         <!-- Two things to Notice: 
  24.              1) class is set to 'editEmployeeAction' which is bean defined by Spring context
  25.              2) We have given the method to be called here as well;
  26.            -->
  27.         <action name="list" class="editEmployeeAction" method="listEmployees">
  28.             <result>/view/editEmployeeList.jsp</result>
  29.         </action>
  30.         <action name="add" class="editEmployeeAction" method="addEmployee">
  31.             <result type="redirect">/list</result>
  32.         </action>
  33.         <action name="delete/*" class="editEmployeeAction" method="deleteEmployee">
  34.             <param name="employee.id">{1}</param>
  35.             <result type="redirect">/list</result>
  36.         </action>
  37.         <action name="*" class="editEmployeeAction" method="listEmployees">
  38.           <result>/view/editEmployeeList.jsp</result>
  39.         </action> 
  40.     </package>
  42. </struts>

在单独的 strut 应用程序中，我们将在“class”属性中具有完整的Action类及其包装信息。 在这里，我们将类名命名为editEmployeeAction。 它在哪里定义？ 我们将要求 Spring 为我们查找。

Spring 上下文文件beans.xml是典型的 Spring 单独上下文文件，具有 Web 应用运行所需的所有内容，其中包括 struts 正在寻找的 bean 定义editEmployeeAction。

beans.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:context="http://www.springframework.org/schema/context"
  6.     xmlns:jee="http://www.springframework.org/schema/jee"
  7.     xmlns:lang="http://www.springframework.org/schema/lang"
  8.     xmlns:p="http://www.springframework.org/schema/p"
  9.     xmlns:tx="http://www.springframework.org/schema/tx"
  10.     xmlns:util="http://www.springframework.org/schema/util"
  11.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  12.         http://www.springframework.org/schema/aop/ http://www.springframework.org/schema/aop/spring-aop.xsd
  13.         http://www.springframework.org/schema/context/ http://www.springframework.org/schema/context/spring-context.xsd
  14.         http://www.springframework.org/schema/jee/ http://www.springframework.org/schema/jee/spring-jee.xsd
  15.         http://www.springframework.org/schema/lang/ http://www.springframework.org/schema/lang/spring-lang.xsd
  16.         http://www.springframework.org/schema/tx/ http://www.springframework.org/schema/tx/spring-tx.xsd
  17.         http://www.springframework.org/schema/util/ http://www.springframework.org/schema/util/spring-util.xsd">
  19.     <!-- This bean has been referred fron struts.xml file; So type it correctly; -->
  20.     <!-- Make scope prototype; This is really important. -->
  21.     <bean name="editEmployeeAction" class="com.howtodoinjava.controller.EditEmployeeAction" scope="prototype">
  22.          <property name="employeeManager">
  23.             <ref bean="employeeManager"/>
  24.          </property>
  25.     </bean>
  27.     <!-- These beans are injected automatically by spring context -->
  28.     <bean id="employeeDAO" class="com.howtodoinjava.dao.EmployeeDaoImpl">
  29.         <property name="sessionFactory" ref="sessionFactory"/>
  30.     </bean>
  32.     <bean id="employeeManager" class="com.howtodoinjava.service.EmployeeManagerImpl">
  33.         <property name="employeeDAO" ref="employeeDAO"/>
  34.     </bean>
  36.     <!-- Configure jdbc.properties -->
  37.     <bean id="propertyConfigurer"
  38.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
  39.         p:location="/WEB-INF/jdbc.properties" />
  41.     <!-- Data Source configuration -->
  42.     <bean id="dataSource"
  43.         class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"
  44.         p:driverClassName="${jdbc.driverClassName}"
  45.         p:url="${jdbc.databaseurl}" p:username="${jdbc.username}"
  46.         p:password="${jdbc.password}" />
  48.     <!-- Configure hibernate session factory -->    
  49.     <bean id="sessionFactory"
  50.         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  51.         <property name="dataSource" ref="dataSource" />
  52.         <property name="configLocation">
  53.             <value>classpath:hibernate.cfg.xml</value>
  54.         </property>
  55.         <property name="configurationClass">
  56.             <value>org.hibernate.cfg.AnnotationConfiguration</value>
  57.         </property>
  58.         <property name="hibernateProperties">
  59.             <props>
  60.                 <prop key="hibernate.dialect">${jdbc.dialect}</prop>
  61.                 <prop key="hibernate.show_sql">true</prop>
  62.             </props>
  63.         </property>
  64.     </bean>
  65.     <!-- Run SQL queries in transactions -->
  66.     <tx:annotation-driven />
  67.     <bean id="transactionManager"
  68.         class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  69.         <property name="sessionFactory" ref="sessionFactory" />
  70.     </bean>
  72. </beans>

这是我们要做的将 Struts 与 spring 框架集成在一起的所有步骤。 现在，您的动作类如下所示：

EditEmployeeAction.java

  1. package com.howtodoinjava.controller;
  3. import java.util.List;
  5. import org.apache.log4j.Logger;
  7. import com.howtodoinjava.entity.EmployeeEntity;
  8. import com.howtodoinjava.service.EmployeeManager;
  9. import com.opensymphony.xwork2.ActionSupport;
  10. import com.opensymphony.xwork2.Preparable;
  12. public class EditEmployeeAction extends ActionSupport implements Preparable    
  13. {
  14.     private static final long serialVersionUID = 1L;
  16.     //Logger configured using log4j
  17.     private static final Logger logger = Logger.getLogger(EditEmployeeAction.class);
  19.     //List of employees; Setter and Getter are below
  20.     private List<EmployeeEntity> employees;
  22.     //Employee object to be added; Setter and Getter are below
  23.     private EmployeeEntity employee;
  25.     //Employee manager injected by spring context; This is cool !!
  26.     private EmployeeManager employeeManager;
  28.     //This method return list of employees in database
  29.     public String listEmployees() {
  30.         logger.info("listEmployees method called");
  31.         employees = employeeManager.getAllEmployees();
  32.         return SUCCESS;
  33.     }
  35.     //This method will be called when a employee object is added
  36.     public String addEmployee() {
  37.         logger.info("addEmployee method called");
  38.         employeeManager.addEmployee(employee);
  39.         return SUCCESS;
  40.     }
  42.     //Deletes a employee by it's id passed in path parameter
  43.     public String deleteEmployee() {
  44.         logger.info("deleteEmployee method called");
  45.         employeeManager.deleteEmployee(employee.getId());
  46.         return SUCCESS;
  47.     }
  49.     //This method will be called before any of Action method is invoked;
  50.     //So some pre-processing if required.
  51.     @Override
  52.     public void prepare() throws Exception {
  53.         employee = null;
  54.     }
  56.     //Getters and Setters hidden
  57. }

Spring 还将 DAO 引用注入到Manager类。

EmployeeManagerImpl.java

  1. package com.howtodoinjava.service;
  3. import java.util.List;
  5. import org.springframework.transaction.annotation.Transactional;
  7. import com.howtodoinjava.dao.EmployeeDAO;
  8. import com.howtodoinjava.entity.EmployeeEntity;
  10. public class EmployeeManagerImpl implements EmployeeManager 
  11. {
  12.     //Employee dao injected by Spring context
  13.     private EmployeeDAO employeeDAO;
  15.     //This method will be called when a employee object is added
  16.     @Override
  17.     @Transactional
  18.     public void addEmployee(EmployeeEntity employee) {
  19.         employeeDAO.addEmployee(employee);
  20.     }
  22.     //This method return list of employees in database
  23.     @Override
  24.     @Transactional
  25.     public List<EmployeeEntity> getAllEmployees() {
  26.         return employeeDAO.getAllEmployees();
  27.     }
  28.     //Deletes a employee by it's id
  29.     @Override
  30.     @Transactional
  31.     public void deleteEmployee(Integer employeeId) {
  32.         employeeDAO.deleteEmployee(employeeId);
  33.     }
  35.     //This setter will be used by Spring context to inject the dao's instance
  36.     public void setEmployeeDAO(EmployeeDAO employeeDAO) {
  37.         this.employeeDAO = employeeDAO;
  38.     }
  39. }

3）Spring + Hibernate 集成

现在我们必须将 Hibernate 集成到应用中。 最好的地方是利用 Spring 的强大功能进行集成，以充分利用依赖注入来与不同的 ORM 一起使用。

上面beans.xml文件中已经给出了 Spring 所需的 Hibernate 依赖关系。 您将需要的其他文件是：

hibernate.cfg.xml

  1. <?xml version='1.0' encoding='utf-8'?>
  2. <!DOCTYPE hibernate-configuration PUBLIC
  3.     "-//Hibernate/Hibernate Configuration DTD//EN"
  4.     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  6. <hibernate-configuration>
  7.     <session-factory>
  8.         <mapping class="com.howtodoinjava.entity.EmployeeEntity" />
  9.     </session-factory>
  10. </hibernate-configuration>

jdbc.properties

  1. jdbc.driverClassName=com.mysql.jdbc.Driver
  2. jdbc.dialect=org.hibernate.dialect.MySQLDialect
  3. jdbc.databaseurl=jdbc:mysql://127.0.0.1:3306/test
  4. jdbc.username=root
  5. jdbc.password=password

EmployeeDaoImpl.java

  1. package com.howtodoinjava.dao;
  3. import java.util.List;
  5. import org.hibernate.SessionFactory;
  6. import org.springframework.stereotype.Repository;
  8. import com.howtodoinjava.entity.EmployeeEntity;
  10. @Repository
  11. public class EmployeeDaoImpl implements EmployeeDAO  
  12. {
  13.     //Session factory injected by spring context
  14.     private SessionFactory sessionFactory;
  16.     //This method will be called when a employee object is added
  17.     @Override
  18.     public void addEmployee(EmployeeEntity employee) {
  19.         this.sessionFactory.getCurrentSession().save(employee);
  20.     }
  22.     //This method return list of employees in database
  23.     @SuppressWarnings("unchecked")
  24.     @Override
  25.     public List<EmployeeEntity> getAllEmployees() {
  26.         return this.sessionFactory.getCurrentSession().createQuery("from EmployeeEntity").list();
  27.     }
  29.     //Deletes a employee by it's id
  30.     @Override
  31.     public void deleteEmployee(Integer employeeId) {
  32.         EmployeeEntity employee = (EmployeeEntity) sessionFactory.getCurrentSession()
  33.                                         .load(EmployeeEntity.class, employeeId);
  34.         if (null != employee) {
  35.             this.sessionFactory.getCurrentSession().delete(employee);
  36.         }
  37.     }
  39.     //This setter will be used by Spring context to inject the sessionFactory instance
  40.     public void setSessionFactory(SessionFactory sessionFactory) {
  41.         this.sessionFactory = sessionFactory;
  42.     }
  43. }

供您参考，EmployeeEntity类如下所示：

EmployeeEntity.java

  1. package com.howtodoinjava.entity;
  3. import javax.persistence.Column;
  4. import javax.persistence.Entity;
  5. import javax.persistence.GeneratedValue;
  6. import javax.persistence.Id;
  7. import javax.persistence.Table;
  9. @Entity
  10. @Table(name="EMPLOYEE")
  11. public class EmployeeEntity {
  13.     @Id
  14.     @Column(name="ID")
  15.     @GeneratedValue
  16.     private Integer id;
  18.     @Column(name="FIRSTNAME")
  19.     private String firstname;
  21.     @Column(name="LASTNAME")
  22.     private String lastname;
  24.     @Column(name="EMAIL")
  25.     private String email;
  27.     @Column(name="TELEPHONE")
  28.     private String telephone;
  30.     //Setters and Getters
  31. }

4）其他集成功能

除了 struts + spring + hibernate，我们还使用以下组件来构建应用。

a）Log4j

Spring 通过扫描类路径中的 log4j 自动配置日志记录。 我们使用pom.xml文件添加了 log4j 依赖项。 现在，您只需要在类路径中放置一个log4j.xml或log4j.properties文件。

log4j.properties

  1. log4j.rootLogger=info, stdout, R
  3. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
  4. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
  5. log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
  7. log4j.appender.R=org.apache.log4j.RollingFileAppender
  8. log4j.appender.R.File=c:/log/demo.log
  9. log4j.appender.R.MaxFileSize=100KB
  10. log4j.appender.R.MaxBackupIndex=1
  11. log4j.appender.R.layout=org.apache.log4j.PatternLayout
  12. log4j.appender.R.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

b）顶级域

如果您查看web.xml文件，我们在其中包含了一些 TLD。 我们可以随时在视图层中使用它们，如下所示：

editEmployeeList.jsp

  1. <%@ taglib prefix="s" uri="/struts-tags"%> 
  2. <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
  3. <html>
  4. <head>
  5.     <title>Spring-4 + Struts-3 + Hibernate Integration Demo</title>
  6.     <style>
  7.     table.list
  8.     {
  9.         border-collapse:collapse;
  10.         width: 40%;
  11.     }
  12.     table.list, table.list td, table.list th
  13.     {
  14.         border:1px solid gray;
  15.         padding: 5px;
  16.     }
  17.     </style>
  18. </head>
  19. <body>
  21. <h2>Spring-4 + Struts-3 + Hibernate Integration Demo</h2>
  23. <s:form method="post" action="add">
  24.     <table>
  25.         <tr>
  26.             <td><s:textfield key="label.firstname" name="employee.firstname"/></td> 
  27.         </tr>
  28.         <tr>
  29.             <td><s:textfield key="label.lastname" name="employee.lastname"/></td>
  30.         </tr>
  31.         <tr>
  32.             <td><s:textfield key="label.email" name="employee.email"/></td>
  33.         </tr>
  34.         <tr>
  35.             <td><s:textfield key="label.telephone" name="employee.telephone"/></td>
  36.         </tr>
  37.         <tr>
  38.             <td>
  39.                 <s:submit key="label.add"></s:submit>
  40.             </td>
  41.         </tr>
  42.     </table> 
  43. </s:form>
  45. <h3>Employees</h3>
  46. <c:if  test="${!empty employees}">
  47.     <table class="list">
  48.         <tr>
  49.             <th align="left">Name</th>
  50.             <th align="left">Email</th>
  51.             <th align="left">Telephone</th>
  52.             <th align="left">Actions</th>
  53.         </tr>
  54.         <c:forEach items="${employees}" var="emp">
  55.             <tr>
  56.                 <td>${emp.lastname}, ${emp.firstname} </td>
  57.                 <td>${emp.email}</td>
  58.                 <td>${emp.telephone}</td>
  59.                 <td><a href="delete/${emp.id}">delete</a></td>
  60.             </tr>
  61.         </c:forEach>
  62.     </table>
  63. </c:if>
  65. </body>
  66. </html>

c）事务

EmployeeManagerImpl.java在诸如getAllEmployees()和deleteEmployee()之类的方法中使用注解@Transactional。 这实际上是在单个事务中运行在此方法下执行的所有数据库查询。 像这样在beans.xml上下文文件中声明了事务依赖项。

  1. <!-- Run SQL queries in transactions -->
  2. <tx:annotation-driven />
  4. <bean id="transactionManager"
  5.     class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  6.     <property name="sessionFactory" ref="sessionFactory" />
  7. </bean>

5）要记住的要点

a）如果运行时无法找到lib文件夹中存在的类，则将来自项目依赖项的 jar 文件添加到项目部署程序集中。

b）使bean.xml中定义的Action类的作用域为“原型”。 Spring 提供的 bean 的默认范围是单例，并且必须为每个请求创建新的 Struts Action类，因为它包含特定于用户会话的数据。 为了容纳两者，请将Action类 bean 标记为原型。

c）在运行此应用之前，请不要忘记设置数据库。 如果安装不正确，将导致您出现一些异常。

d）另外，请在项目运行时依赖项中也包括struts2-spring-plugin。

6）教程中使用的数据库架构

下表已在 MySQL 中的名为“test”的数据库中创建。

  1. CREATE TABLE EMPLOYEE
  2. (
  3.     ID          INT PRIMARY KEY AUTO_INCREMENT,
  4.     FIRSTNAME   VARCHAR(30),
  5.     LASTNAME    VARCHAR(30),
  6.     TELEPHONE   VARCHAR(15),
  7.     EMAIL       VARCHAR(30),
  8.     CREATED     TIMESTAMP DEFAULT NOW()
  9. );

如果您打算自己构建应用，则在下面给定的直接在此应用中使用的结构将为您提供帮助。

Spring4 Struts2 Hibernate 集成教程 - 图2

Spring Struts Hibernate 集成的目录结构

此项目中使用的pom.xml文件具有所有项目相关性（有些额外），如下所示：

pom.xml

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  3.   <modelVersion>4.0.0</modelVersion>
  4.   <groupId>com.howtodoinjava.app</groupId>
  5.   <artifactId>Spring4Struts2HibernateIntegration</artifactId>
  6.   <packaging>war</packaging>
  7.   <version>1.0-SNAPSHOT</version>
  8.   <name>Spring4Struts2HibernateIntegration Maven Webapp</name>
  9.   <url>http://maven.apache.org</url>
  10.   <!-- JBoss repository for Hibernate -->
  11.   <repositories>
  12.     <repository>
  13.         <id>JBoss repository</id>
  14.         <url>http://repository.jboss.org/nexus/content/groups/public/</url>
  15.     </repository>
  16.   </repositories>
  17.   <properties>
  18.     <org.springframework.version>4.0.3.RELEASE</org.springframework.version>
  19.   </properties>
  20.   <dependencies>
  22.     <dependency>
  23.       <groupId>junit</groupId>
  24.       <artifactId>junit</artifactId>
  25.       <version>4.11</version>
  26.       <scope>test</scope>
  27.     </dependency>
  29.     <dependency>
  30.         <groupId>org.apache.struts</groupId>
  31.         <artifactId>struts2-core</artifactId>
  32.         <version>2.3.16.2</version>
  33.     </dependency>
  35.    <dependency>
  36.         <groupId>org.apache.struts</groupId>
  37.         <artifactId>struts2-spring-plugin</artifactId>
  38.         <version>2.3.16.2</version>
  39.     </dependency>
  41.      <!--
  42.         Core utilities used by other modules.
  43.         Define this if you use Spring Utility APIs (org.springframework.core.*/org.springframework.util.*)
  44.     -->
  45.     <dependency>
  46.       <groupId>org.springframework</groupId>
  47.       <artifactId>spring-core</artifactId>
  48.       <version>${org.springframework.version}</version>
  49.       <scope>runtime</scope>
  50.     </dependency>
  51.     <dependency>
  52.         <groupId>org.springframework</groupId>
  53.         <artifactId>spring-web</artifactId>
  54.         <version>${org.springframework.version}</version>
  55.         <scope>runtime</scope>
  56.     </dependency>
  57.     <dependency>
  58.         <groupId>org.springframework</groupId>
  59.         <artifactId>spring-webmvc</artifactId>
  60.         <version>${org.springframework.version}</version>
  61.         <scope>runtime</scope>
  62.     </dependency>
  64.     <!--
  65.         Bean Factory and JavaBeans utilities (depends on spring-core)
  66.         Define this if you use Spring Bean APIs (org.springframework.beans.*)
  67.     -->
  68.     <dependency>
  69.       <groupId>org.springframework</groupId>
  70.       <artifactId>spring-beans</artifactId>
  71.       <version>${org.springframework.version}</version>
  72.     </dependency>
  73.     <!--
  74.         Application Context (depends on spring-core, spring-expression, spring-aop, spring-beans)
  75.         This is the central artifact for Spring's Dependency Injection Container and is generally always defined
  76.     -->
  77.     <dependency>
  78.       <groupId>org.springframework</groupId>
  79.       <artifactId>spring-context</artifactId>
  80.       <version>${org.springframework.version}</version>
  81.     </dependency>
  82.     <!--
  83.         Aspect Oriented Programming (AOP) Framework (depends on spring-core, spring-beans)
  84.         Define this if you use Spring AOP APIs (org.springframework.aop.*)
  85.     -->
  86.     <dependency>
  87.       <groupId>org.springframework</groupId>
  88.       <artifactId>spring-aop</artifactId>
  89.       <version>${org.springframework.version}</version>
  90.     </dependency>
  91.     <dependency>
  92.         <groupId>org.aspectj</groupId>
  93.         <artifactId>aspectjtools</artifactId>
  94.         <version>1.6.2</version>
  95.     </dependency>
  96.     <dependency>
  97.         <groupId>cglib</groupId>
  98.         <artifactId>cglib</artifactId>
  99.         <version>3.1</version>
  100.     </dependency>
  102.     <!--
  103.         Transaction Management Abstraction (depends on spring-core, spring-beans, spring-aop, spring-context)
  104.         Define this if you use Spring Transactions or DAO Exception Hierarchy
  105.         (org.springframework.transaction.*/org.springframework.dao.*)
  106.     -->
  107.     <dependency>
  108.       <groupId>org.springframework</groupId>
  109.       <artifactId>spring-tx</artifactId>
  110.       <version>${org.springframework.version}</version>
  111.     </dependency>
  112.     <!--
  113.         JDBC Data Access Library (depends on spring-core, spring-beans, spring-context, spring-tx)
  114.         Define this if you use Spring's JdbcTemplate API (org.springframework.jdbc.*)
  115.     -->
  116.     <dependency>
  117.       <groupId>org.springframework</groupId>
  118.       <artifactId>spring-jdbc</artifactId>
  119.       <version>${org.springframework.version}</version>
  120.     </dependency>
  122.     <!--
  123.         Object-to-Relation-Mapping (ORM) integration with Hibernate, JPA, and iBatis.
  124.         (depends on spring-core, spring-beans, spring-context, spring-tx)
  125.         Define this if you need ORM (org.springframework.orm.*)
  126.     -->
  127.     <dependency>
  128.       <groupId>org.springframework</groupId>
  129.       <artifactId>spring-orm</artifactId>
  130.       <version>${org.springframework.version}</version>
  131.     </dependency>
  133.     <dependency>  
  134.        <groupId>log4j</groupId>  
  135.        <artifactId>log4j</artifactId>  
  136.        <version>1.2.15</version>  
  137.        <exclusions>  
  138.          <exclusion>  
  139.            <groupId>javax.mail</groupId>  
  140.            <artifactId>mail</artifactId>  
  141.          </exclusion>  
  142.          <exclusion>  
  143.            <groupId>javax.jms</groupId>  
  144.            <artifactId>jms</artifactId>  
  145.          </exclusion>  
  146.          <exclusion>  
  147.            <groupId>com.sun.jdmk</groupId>  
  148.            <artifactId>jmxtools</artifactId>  
  149.          </exclusion>  
  150.          <exclusion>  
  151.            <groupId>com.sun.jmx</groupId>  
  152.            <artifactId>jmxri</artifactId>  
  153.          </exclusion>  
  154.        </exclusions>  
  155.        <scope>runtime</scope>  
  156.      </dependency>  
  158.      <dependency>
  159.         <groupId>org.hibernate</groupId>
  160.         <artifactId>hibernate-core</artifactId>
  161.         <version>3.6.3.Final</version>
  162.     </dependency>
  164.     <dependency>
  165.         <groupId>javassist</groupId>
  166.         <artifactId>javassist</artifactId>
  167.         <version>3.12.1.GA</version>
  168.     </dependency>
  170.      <dependency>
  171.         <groupId>javax.servlet</groupId>
  172.         <artifactId>jstl</artifactId>
  173.         <version>1.2</version>
  174.         <scope>runtime</scope>
  175.     </dependency>
  177.     <dependency>
  178.         <groupId>taglibs</groupId>
  179.         <artifactId>standard</artifactId>
  180.         <version>1.1.2</version>
  181.         <scope>runtime</scope>
  182.     </dependency>
  184.     <dependency>
  185.       <groupId>commons-dbcp</groupId>
  186.       <artifactId>commons-dbcp</artifactId>
  187.       <version>1.4</version>
  188.     </dependency>
  190.    <dependency>
  191.         <groupId>mysql</groupId>
  192.         <artifactId>mysql-connector-java</artifactId>
  193.         <version>5.1.9</version>
  194.     </dependency>
  196.   </dependencies>
  197.   <build>
  198.     <finalName>Spring3Struts2HibernateIntegration</finalName>
  199.     <plugins>
  200.         <plugin>
  201.             <artifactId>maven-compiler-plugin</artifactId>
  202.             <version>2.3.2</version>
  203.             <configuration>
  204.                 <source>1.6</source>
  205.                 <target>1.6</target>
  206.             </configuration>
  207.         </plugin>
  208.     </plugins>
  209.   </build>
  210. </project>

7）下载源代码

下载以上示例的源代码或获取.war文件。

下载源码

下载.war文件

这是 Spring4 + Struts2 + hibernate 集成教程的全部内容。 让我知道您的想法和疑问。

祝您学习愉快！