原文： https://howtodoinjava.com/spring-orm/spring-hibernate-integration-example/

此 Spring Hibernate 集成教程重点介绍 Hibernate 与 Spring 框架的结合使用。 我将展示这种集成的结果，一个基本的端到端应用程序流看起来如何。

1. 开发环境

对于那些不使用 maven 进行依赖管理并且依赖下载的 jar 文件的用户。 我创建了另一个项目，其中包含要下载的所有必需 jar 文件。 另外，我已经使用 Spring 3.2.5 和 hibernate 4 完成了集成。

因此，如果您属于以上两个类别中的任何一个，请阅读以下链接文章，以防出现任何问题。 Spring + Hibernate 4 集成教程，包含所有 jar 文件

要构建此示例项目，我将逐步指导您 。 通过这种方式，我们还可以遍历一些概念。

2. 创建 Maven Web 项目

在命令提示符下使用以下命令创建 maven Web 项目。

  1. $ mvn archetype:generate -DgroupId=com.howtodoinjava.app 
  2.                             -DartifactId=Spring3HibernateIntegration
  3.                             -DarchetypeArtifactId=maven-archetype-webapp 
  4.                             -DinteractiveMode=false

现在，使用下面的 maven 命令将此 Web 项目转换为 eclipse 动态 Web 项目。

  1. $ cd Spring3HibernateIntegration
  2. $ mvn eclipse:eclipse -Dwtpversion=2.0

3. Maven 依赖

更新pom.xml文件以包含 spring 和 hibernate 依赖项。 它还将包括在项目参考中添加的 mysql 驱动程序。

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>Spring3HibernateIntegration</artifactId>
  6.   <packaging>war</packaging>
  7.   <version>1.0-SNAPSHOT</version>
  8.   <name>Spring3HibernateIntegration 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>3.0.5.RELEASE</org.springframework.version>
  19.   </properties>
  20.   <dependencies>
  22.       <dependency>
  23.       <groupId>org.springframework</groupId>
  24.       <artifactId>spring-core</artifactId>
  25.       <version>${org.springframework.version}</version>
  26.     </dependency>
  28.     <dependency>
  29.       <groupId>org.springframework</groupId>
  30.       <artifactId>spring-expression</artifactId>
  31.       <version>${org.springframework.version}</version>
  32.     </dependency>
  34.     <dependency>
  35.       <groupId>org.springframework</groupId>
  36.       <artifactId>spring-beans</artifactId>
  37.       <version>${org.springframework.version}</version>
  38.     </dependency>
  40.     <dependency>
  41.       <groupId>org.springframework</groupId>
  42.       <artifactId>spring-context</artifactId>
  43.       <version>${org.springframework.version}</version>
  44.     </dependency>
  46.     <dependency>
  47.       <groupId>org.springframework</groupId>
  48.       <artifactId>spring-context-support</artifactId>
  49.       <version>${org.springframework.version}</version>
  50.     </dependency>
  52.     <dependency>
  53.       <groupId>org.springframework</groupId>
  54.       <artifactId>spring-jdbc</artifactId>
  55.       <version>${org.springframework.version}</version>
  56.     </dependency>
  58.     <dependency>
  59.       <groupId>org.springframework</groupId>
  60.       <artifactId>spring-orm</artifactId>
  61.       <version>${org.springframework.version}</version>
  62.     </dependency>
  64.     <dependency>
  65.       <groupId>org.springframework</groupId>
  66.       <artifactId>spring-web</artifactId>
  67.       <version>${org.springframework.version}</version>
  68.     </dependency>
  70.     <dependency>
  71.       <groupId>org.springframework</groupId>
  72.       <artifactId>spring-webmvc</artifactId>
  73.       <version>${org.springframework.version}</version>
  74.     </dependency>
  76.     <dependency>  
  77.        <groupId>log4j</groupId>  
  78.        <artifactId>log4j</artifactId>  
  79.        <version>1.2.15</version>  
  80.        <scope>runtime</scope>  
  81.      </dependency>  
  83.     <dependency>
  84.         <groupId>org.hibernate</groupId>
  85.         <artifactId>hibernate-core</artifactId>
  86.         <version>3.6.3.Final</version>
  87.     </dependency>
  89.     <dependency>
  90.         <groupId>javassist</groupId>
  91.         <artifactId>javassist</artifactId>
  92.         <version>3.12.1.GA</version>
  93.     </dependency>
  95.      <dependency>
  96.         <groupId>javax.servlet</groupId>
  97.         <artifactId>jstl</artifactId>
  98.         <version>1.2</version>
  99.         <scope>runtime</scope>
  100.     </dependency>
  102.     <dependency>
  103.         <groupId>taglibs</groupId>
  104.         <artifactId>standard</artifactId>
  105.         <version>1.1.2</version>
  106.         <scope>runtime</scope>
  107.     </dependency>
  109.     <dependency>
  110.       <groupId>commons-dbcp</groupId>
  111.       <artifactId>commons-dbcp</artifactId>
  112.       <version>1.4</version>
  113.     </dependency>
  115.    <dependency>
  116.         <groupId>mysql</groupId>
  117.         <artifactId>mysql-connector-java</artifactId>
  118.         <version>5.1.9</version>
  119.     </dependency>
  121.   </dependencies>
  122.   <build>
  123.     <finalName>Spring3HibernateIntegration</finalName>
  124.   </build>
  125. </project>

4. 创建数据库架构

现在让我们决定数据库架构结构，因为在下一步中编写实体类时将需要它。

  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. );

5. 编写 Hibernate 实体类

现在该写EmployeeEntity了。 此类将使用 Hibernate 模式映射到数据库中的Employee表。 JPA 将在持久性管理设置中包括任何用@Entity注解的类。 如果您使用注解，则不需要persistence.xml。

  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 
  12. {
  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. }

6. 编写数据访问代码

让我们编写将与数据库交互负责的 DAO 类。 此类实际上将使用 Hibernate 会话工厂进行数据库交互。 会话工厂实现将在运行时使用 spring IoC 功能 注入参考变量。

EmployeeDao.java

  1. package com.howtodoinjava.dao;
  3. import java.util.List;
  4. import com.howtodoinjava.entity.EmployeeEntity;
  6. public interface EmployeeDAO
  7. {
  8.     public void addEmployee(EmployeeEntity employee);
  9.     public List<EmployeeEntity> getAllEmployees();
  10.     public void deleteEmployee(Integer employeeId);
  11. }

EmployeeDaoImpl.java

  1. package com.howtodoinjava.dao;
  3. import java.util.List;
  5. import org.hibernate.SessionFactory;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Repository;
  9. import com.howtodoinjava.entity.EmployeeEntity;
  11. @Repository
  12. public class EmployeeDaoImpl implements EmployeeDAO
  13. {
  14.     @Autowired
  15.     private SessionFactory sessionFactory;
  16.     @Override
  17.     public void addEmployee(EmployeeEntity employee) {
  18.         this.sessionFactory.getCurrentSession().save(employee);
  19.     }
  20.     @SuppressWarnings("unchecked")
  21.     @Override
  22.     public List<EmployeeEntity> getAllEmployees() {
  23.         return this.sessionFactory.getCurrentSession().createQuery("from EmployeeEntity").list();
  24.     }
  25.     @Override
  26.     public void deleteEmployee(Integer employeeId) {
  27.         EmployeeEntity employee = (EmployeeEntity) sessionFactory.getCurrentSession().load(
  28.                 EmployeeEntity.class, employeeId);
  29.         if (null != employee) {
  30.             this.sessionFactory.getCurrentSession().delete(employee);
  31.         }
  32.     }
  33. }

我已经写了一个管理层，由于较少的复杂性，它在本演示中似乎是多余的，但是如果您编写此层，它通常会被视为最佳实践。 该层将仅接收来自控制器的调用，并将此调用传递到 dao 层。

EmployeeManager.java

  1. package com.howtodoinjava.service;
  3. import java.util.List;
  5. import com.howtodoinjava.entity.EmployeeEntity;
  7. public interface EmployeeManager {
  8.     public void addEmployee(EmployeeEntity employee);
  9.     public List<EmployeeEntity> getAllEmployees();
  10.     public void deleteEmployee(Integer employeeId);
  11. }

EmployeeManagerImpl.java

  1. package com.howtodoinjava.service;
  3. import java.util.List;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  7. import org.springframework.transaction.annotation.Transactional;
  9. import com.howtodoinjava.dao.EmployeeDAO;
  10. import com.howtodoinjava.entity.EmployeeEntity;
  12. @Service
  13. public class EmployeeManagerImpl implements EmployeeManager 
  14. {
  15.     @Autowired
  16.     private EmployeeDAO employeeDAO;
  17.     @Override
  18.     @Transactional
  19.     public void addEmployee(EmployeeEntity employee) {
  20.         employeeDAO.addEmployee(employee);
  21.     }
  22.     @Override
  23.     @Transactional
  24.     public List<EmployeeEntity> getAllEmployees() {
  25.         return employeeDAO.getAllEmployees();
  26.     }
  27.     @Override
  28.     @Transactional
  29.     public void deleteEmployee(Integer employeeId) {
  30.         employeeDAO.deleteEmployee(employeeId);
  31.     }
  32.     public void setEmployeeDAO(EmployeeDAO employeeDAO) {
  33.         this.employeeDAO = employeeDAO;
  34.     }
  35. }

7. Spring 控制器和视图文件

现在是时候编写 spring 控制器和处理器方法了，这些实际上将由 spring 框架的调度程序 servlet 调用以处理实际的应用程序逻辑。

EditEmployeeController.java

  1. package com.howtodoinjava.controller;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.stereotype.Controller;
  5. import org.springframework.ui.ModelMap;
  6. import org.springframework.validation.BindingResult;
  7. import org.springframework.web.bind.annotation.ModelAttribute;
  8. import org.springframework.web.bind.annotation.PathVariable;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RequestMethod;
  11. import org.springframework.web.bind.annotation.RequestParam;
  13. import com.howtodoinjava.entity.EmployeeEntity;
  14. import com.howtodoinjava.service.EmployeeManager;
  16. @Controller
  17. public class EditEmployeeController 
  18. {
  19.     @Autowired
  20.     private EmployeeManager employeeManager;
  21.     @RequestMapping(value = "/", method = RequestMethod.GET)
  22.     public String listEmployees(ModelMap map)
  23.     {
  24.         map.addAttribute("employee", new EmployeeEntity());
  25.         map.addAttribute("employeeList", employeeManager.getAllEmployees());
  26.         return "editEmployeeList";
  27.     }
  28.     @RequestMapping(value = "/add", method = RequestMethod.POST)
  29.     public String addEmployee(@ModelAttribute(value="employee") EmployeeEntity employee, BindingResult result)
  30.     {
  31.         employeeManager.addEmployee(employee);
  32.         return "redirect:/";
  33.     }
  34.     @RequestMapping("/delete/{employeeId}")
  35.     public String deleteEmplyee(@PathVariable("employeeId") Integer employeeId)
  36.     {
  37.         employeeManager.deleteEmployee(employeeId);
  38.         return "redirect:/";
  39.     }
  40.     public void setEmployeeManager(EmployeeManager employeeManager) {
  41.         this.employeeManager = employeeManager;
  42.     }
  43. }

现在，我们将编写应用程序的视图层，该视图层实际上是.jsp文件。

editEmployeeList.jsp

  1. <%@taglib uri="http://www.springframework.org/tags" prefix="spring"%>
  2. <%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>
  3. <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
  4. <html>
  5.     <head>
  6.         <title>Spring 3 hibernate integration example on www.howtodoinjava.com</title>
  7.     </head>
  8.     <body>
  9.     <h2>Employee Management Screen : Spring 3 hibernate integration example on www.howtodoinjava.com</h2>
  10.     <form:form method="post" action="add" commandName="employee">
  11.         <table>
  12.         <tr>
  13.             <td><form:label path="firstname"><spring:message code="label.firstname"/></form:label></td>
  14.             <td><form:input path="firstname" /></td>
  15.         </tr>
  16.         <tr>
  17.             <td><form:label path="lastname"><spring:message code="label.lastname"/></form:label></td>
  18.             <td><form:input path="lastname" /></td>
  19.         </tr>
  20.         <tr>
  21.             <td><form:label path="email"><spring:message code="label.email"/></form:label></td>
  22.             <td><form:input path="email" /></td>
  23.         </tr>
  24.         <tr>
  25.             <td><form:label path="telephone"><spring:message code="label.telephone"/></form:label></td>
  26.             <td><form:input path="telephone" /></td>
  27.         </tr>
  28.         <tr>
  29.             <td colspan="2">
  30.                 <input type="submit" value="<spring:message code="label.add"/>"/>
  31.             </td>
  32.         </tr>
  33.     </table> 
  34.     </form:form>
  35.     <h3>Employees</h3>
  36.     <c:if  test="${!empty employeeList}">
  37.     <table class="data">
  38.     <tr>
  39.         <th>Name</th>
  40.         <th>Email</th>
  41.         <th>Telephone</th>
  42.         <th>Action</th>
  43.     </tr>
  44.     <c:forEach items="${employeeList}" var="emp">
  45.         <tr>
  46.             <td>${emp.lastname}, ${emp.firstname} </td>
  47.             <td>${emp.email}</td>
  48.             <td>${emp.telephone}</td>
  49.             <td>delete</td>
  50.         </tr>
  51.     </c:forEach>
  52.     </table>
  53.     </c:if>
  54.     </body>
  55. </html>

8. Spring 分派器 Servlet

我们的 Java 代码已经完成，现在可以配置应用程序了。 让我们从web.xml开始。 在web.xml中，我们将为 spring 框架配置前控制器，即DispatcherServlet。

  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://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  7.     id="WebApp_ID" version="2.5">
  9. <display-name>Archetype Created Web Application</display-name>
  10.     <welcome-file-list>
  11.         <welcome-file>/WEB-INF/index.jsp</welcome-file>
  12.     </welcome-file-list>
  13.     <servlet>
  14.         <servlet-name>employee</servlet-name>
  15.         <servlet-class>
  16.             org.springframework.web.servlet.DispatcherServlet
  17.         </servlet-class>
  18.         <load-on-startup>1</load-on-startup>
  19.     </servlet>
  20.     <servlet-mapping>
  21.         <servlet-name>employee</servlet-name>
  22.         <url-pattern>/</url-pattern>
  23.     </servlet-mapping>
  24.     <context-param>
  25.         <param-name>contextConfigLocation</param-name>
  26.         <param-value>/WEB-INF/employee-servlet.xml</param-value>
  27.     </context-param>
  28.     <listener>
  29.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  30.     </listener>
  31. </web-app>

9. Spring Hibernate 集成配置

让我们为 Hibernate 数据源，消息资源，视图解析器和其他此类对象配置 spring 框架。

employee-servlet.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">
  18.     <context:annotation-config />
  19.     <context:component-scan base-package="com.howtodoinjava.controller" />
  20.     <bean id="jspViewResolver"
  21.         class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  22.         <property name="viewClass"
  23.             value="org.springframework.web.servlet.view.JstlView"></property>
  24.         <property name="prefix" value="/WEB-INF/view/"></property>
  25.         <property name="suffix" value=".jsp"></property>
  26.     </bean>
  27.     <bean id="messageSource"
  28.         class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
  29.         <property name="basename" value="classpath:messages"></property>
  30.         <property name="defaultEncoding" value="UTF-8"></property>
  31.     </bean>
  32.     <bean id="propertyConfigurer"
  33.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
  34.         p:location="/WEB-INF/jdbc.properties"></bean>
  35.     <bean id="dataSource"
  36.         class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"
  37.         p:driverClassName="${jdbc.driverClassName}"
  38.         p:url="${jdbc.databaseurl}" p:username="${jdbc.username}"
  39.         p:password="${jdbc.password}"></bean>
  40.     <bean id="sessionFactory"
  41.         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  42.         <property name="dataSource" ref="dataSource"></property>
  43.         <property name="configLocation">
  44.             <value>classpath:hibernate.cfg.xml</value>
  45.         </property>
  46.         <property name="configurationClass">
  47.             <value>org.hibernate.cfg.AnnotationConfiguration</value>
  48.         </property>
  49.         <property name="hibernateProperties">
  50.             <props>
  51.                 <prop key="hibernate.dialect">${jdbc.dialect}</prop>
  52.                 <prop key="hibernate.show_sql">true</prop>
  53.             </props>
  54.         </property>
  55.     </bean>
  56.     <bean id="employeeDAO" class="com.howtodoinjava.dao.EmployeeDaoImpl"></bean>
  57.     <bean id="employeeManager" class="com.howtodoinjava.service.EmployeeManagerImpl"></bean>
  58.     <tx:annotation-driven />
  59.     <bean id="transactionManager"
  60.         class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  61.         <property name="sessionFactory" ref="sessionFactory"></property>
  62.     </bean>
  63. </beans>

使用注解时，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"></mapping>
  9.     </session-factory>
  10. </hibernate-configuration>

10. JDBC 属性

让我们提到 jdbc 连接属性和消息资源属性。

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

messages_en.properties

  1. label.firstname=First Name
  2. label.lastname=Last Name
  3. label.email=Email
  4. label.telephone=Telephone
  5. label.add=Add Employee
  7. label.menu=Actions
  8. label.title=Employee Form
  9. label.footer=www.HowToDoInJava.com

而已。 您的应用程序已准备好部署在您选择的服务器上。 最后，您的项目结构应如下所示。

Spring Hibernate 集成示例 - 图1

Spring + hibernate 集成项目结构

如果您在 Eclipse 逐步中发现构建或运行此 spring hibernate 集成示例时遇到任何问题，请发表评论，我将尽力帮助您。

下载源码

更新：

如果您遇到问题：java.lang.NoClassDefFoundError: Lorg/hibernate/cache/CacheProvider，可能的解决方案：请尝试将org.springframework.orm.hibernate3.LocalSessionFactoryBean更改为org.springframework.orm.hibernate4.LocalSessionFactoryBean，hibernate3 到 hibernate4。

更多参考：

http://stackoverflow.com/questions/7528862/exception-noclassdeffounderror-for-cacheprovider

https://code.google.com/archive/p/jgk-spring-recipes/wikis/Migrating_Spring31_Hibernate4.wiki

java.lang.NoClassDefFoundError: org/aopalliance/intercept/MethodInterceptor

可能的解决方案：下载并将com.springsource.org.aopalliance-1.0.0.jar并添加到你的类路径

参考：

http://forum.spring.io/forum/spring-projects/aop/74011-java-lang-noclassdeffounderror-org-aopalliance-intercept-methodinterceptor

下载源码

学习愉快！