We learned how to integrate Spring and Hibernate in our last tutorial. Today we will move forward and integrate Spring MVC and Hibernate frameworks in a web application CRUD example. Our final project structure looks like below image, we will look into each of the components one by one. 
Note that I am using Spring 4.0.3.Release and Hibernate 4.3.5.Final versions for our example, the same program is also compatible for Spring 4 and Hibernate 3, however you need to make small changes in spring bean configuration file discussed in the last tutorial.
Maven 依赖
让我们看看冬眠和春季MVC框架集成所需的所有maven依赖。
1<?xml version="1.0" encoding="UTF-8"?>
2<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
3 xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
4 <modelVersion>4.0.0</modelVersion>
5 <groupId>com.journaldev.spring</groupId>
6 <artifactId>SpringMVCHibernate</artifactId>
7 <name>SpringMVCHibernate</name>
8 <packaging>war</packaging>
9 <version>1.0.0-BUILD-SNAPSHOT</version>
10 <properties>
11 <java-version>1.6</java-version>
12 <org.springframework-version>4.0.3.RELEASE</org.springframework-version>
13 <org.aspectj-version>1.7.4</org.aspectj-version>
14 <org.slf4j-version>1.7.5</org.slf4j-version>
15 <hibernate.version>4.3.5.Final</hibernate.version>
16 </properties>
17 <dependencies>
18 <!-- Spring -->
19 <dependency>
20 <groupId>org.springframework</groupId>
21 <artifactId>spring-context</artifactId>
22 <version>${org.springframework-version}</version>
23 <exclusions>
24 <!-- Exclude Commons Logging in favor of SLF4j -->
25 <exclusion>
26 <groupId>commons-logging</groupId>
27 <artifactId>commons-logging</artifactId>
28 </exclusion>
29 </exclusions>
30 </dependency>
31 <dependency>
32 <groupId>org.springframework</groupId>
33 <artifactId>spring-webmvc</artifactId>
34 <version>${org.springframework-version}</version>
35 </dependency>
36 <dependency>
37 <groupId>org.springframework</groupId>
38 <artifactId>spring-tx</artifactId>
39 <version>${org.springframework-version}</version>
40 </dependency>
41
42 <!-- Hibernate -->
43 <dependency>
44 <groupId>org.hibernate</groupId>
45 <artifactId>hibernate-core</artifactId>
46 <version>${hibernate.version}</version>
47 </dependency>
48 <dependency>
49 <groupId>org.hibernate</groupId>
50 <artifactId>hibernate-entitymanager</artifactId>
51 <version>${hibernate.version}</version>
52 </dependency>
53
54 <!-- Apache Commons DBCP -->
55 <dependency>
56 <groupId>commons-dbcp</groupId>
57 <artifactId>commons-dbcp</artifactId>
58 <version>1.4</version>
59 </dependency>
60 <!-- Spring ORM -->
61 <dependency>
62 <groupId>org.springframework</groupId>
63 <artifactId>spring-orm</artifactId>
64 <version>${org.springframework-version}</version>
65 </dependency>
66
67 <!-- AspectJ -->
68 <dependency>
69 <groupId>org.aspectj</groupId>
70 <artifactId>aspectjrt</artifactId>
71 <version>${org.aspectj-version}</version>
72 </dependency>
73
74 <!-- Logging -->
75 <dependency>
76 <groupId>org.slf4j</groupId>
77 <artifactId>slf4j-api</artifactId>
78 <version>${org.slf4j-version}</version>
79 </dependency>
80 <dependency>
81 <groupId>org.slf4j</groupId>
82 <artifactId>jcl-over-slf4j</artifactId>
83 <version>${org.slf4j-version}</version>
84 <scope>runtime</scope>
85 </dependency>
86 <dependency>
87 <groupId>org.slf4j</groupId>
88 <artifactId>slf4j-log4j12</artifactId>
89 <version>${org.slf4j-version}</version>
90 <scope>runtime</scope>
91 </dependency>
92 <dependency>
93 <groupId>log4j</groupId>
94 <artifactId>log4j</artifactId>
95 <version>1.2.15</version>
96 <exclusions>
97 <exclusion>
98 <groupId>javax.mail</groupId>
99 <artifactId>mail</artifactId>
100 </exclusion>
101 <exclusion>
102 <groupId>javax.jms</groupId>
103 <artifactId>jms</artifactId>
104 </exclusion>
105 <exclusion>
106 <groupId>com.sun.jdmk</groupId>
107 <artifactId>jmxtools</artifactId>
108 </exclusion>
109 <exclusion>
110 <groupId>com.sun.jmx</groupId>
111 <artifactId>jmxri</artifactId>
112 </exclusion>
113 </exclusions>
114 <scope>runtime</scope>
115 </dependency>
116
117 <!-- @Inject -->
118 <dependency>
119 <groupId>javax.inject</groupId>
120 <artifactId>javax.inject</artifactId>
121 <version>1</version>
122 </dependency>
123
124 <!-- Servlet -->
125 <dependency>
126 <groupId>javax.servlet</groupId>
127 <artifactId>servlet-api</artifactId>
128 <version>2.5</version>
129 <scope>provided</scope>
130 </dependency>
131 <dependency>
132 <groupId>javax.servlet.jsp</groupId>
133 <artifactId>jsp-api</artifactId>
134 <version>2.1</version>
135 <scope>provided</scope>
136 </dependency>
137 <dependency>
138 <groupId>javax.servlet</groupId>
139 <artifactId>jstl</artifactId>
140 <version>1.2</version>
141 </dependency>
142
143 <!-- Test -->
144 <dependency>
145 <groupId>junit</groupId>
146 <artifactId>junit</artifactId>
147 <version>4.7</version>
148 <scope>test</scope>
149 </dependency>
150
151 </dependencies>
152 <build>
153 <plugins>
154 <plugin>
155 <artifactId>maven-eclipse-plugin</artifactId>
156 <version>2.9</version>
157 <configuration>
158 <additionalProjectnatures>
159 <projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
160 </additionalProjectnatures>
161 <additionalBuildcommands>
162 <buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
163 </additionalBuildcommands>
164 <downloadSources>true</downloadSources>
165 <downloadJavadocs>true</downloadJavadocs>
166 </configuration>
167 </plugin>
168 <plugin>
169 <groupId>org.apache.maven.plugins</groupId>
170 <artifactId>maven-compiler-plugin</artifactId>
171 <version>2.5.1</version>
172 <configuration>
173 <source>1.6</source>
174 <target>1.6</target>
175 <compilerArgument>-Xlint:all</compilerArgument>
176 <showWarnings>true</showWarnings>
177 <showDeprecation>true</showDeprecation>
178 </configuration>
179 </plugin>
180 <plugin>
181 <groupId>org.codehaus.mojo</groupId>
182 <artifactId>exec-maven-plugin</artifactId>
183 <version>1.2.1</version>
184 <configuration>
185 <mainClass>org.test.int1.Main</mainClass>
186 </configuration>
187 </plugin>
188 </plugins>
189 <finalName>${project.artifactId}</finalName>
190 </build>
191</project>
当我创建春季MVC项目时,一些上面的依赖包括STS(春季工具套件)。上面的重要依赖是 春季背景, 春季webmvc, 春季-tx, hibernate-core, hibernate-entitymanager和 春季-orm。我正在使用Apache Commons DBCP来组合连接,但在现实生活中,你最有可能有连接组合由容器完成,我们所需要的只是提供使用的JNDI参考细节。 NOTE:我注意到一些读者正在获得数据库连接问题。 请注意,我的pomxml中没有数据库驱动程序。 这对我来说是有效的,因为我有MySQL驱动程序在Libcat目录中和一些数据源连接配置
部署描述
我们需要在我们的 Web 应用程序中插入 Spring 框架,这是通过将 Spring 框架DispatcherServlet配置为前置控制器完成的。
1<?xml version="1.0" encoding="UTF-8"?>
2<web-app version="2.5" xmlns="https://java.sun.com/xml/ns/javaee"
3 xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
4 xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
5
6 <!-- The definition of the Root Spring Container shared by all Servlets and Filters -->
7 <context-param>
8 <param-name>contextConfigLocation</param-name>
9 <param-value>/WEB-INF/spring/root-context.xml</param-value>
10 </context-param>
11
12 <!-- Creates the Spring Container shared by all Servlets and Filters -->
13 <listener>
14 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
15 </listener>
16
17 <!-- Processes application requests -->
18 <servlet>
19 <servlet-name>appServlet</servlet-name>
20 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
21 <init-param>
22 <param-name>contextConfigLocation</param-name>
23 <param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
24 </init-param>
25 <load-on-startup>1</load-on-startup>
26 </servlet>
27
28 <servlet-mapping>
29 <servlet-name>appServlet</servlet-name>
30 <url-pattern>/</url-pattern>
31 </servlet-mapping>
32
33</web-app>
大部分是锅炉板代码,最重要的部分是春天文本文件位置,在那里我们将配置我们的春豆和服务。
Hibernate 实体 Bean
但是,我们也可以在 XML 文件中使用简单的 java bean 和地图详细信息,在这种情况下,我们需要在设置 Hibernate SessionFactory 时提供地图文件详细信息。
1package com.journaldev.spring.model;
2
3import javax.persistence.Column;
4import javax.persistence.Entity;
5import javax.persistence.GeneratedValue;
6import javax.persistence.GenerationType;
7import javax.persistence.Id;
8import javax.persistence.Table;
9
10/**
11 * Entity bean with JPA annotations
12 * Hibernate provides JPA implementation
13 * @author pankaj
14 *
15 */
16@Entity
17@Table(name="PERSON")
18public class Person {
19
20 @Id
21 @Column(name="id")
22 @GeneratedValue(strategy=GenerationType.IDENTITY)
23 private int id;
24
25 private String name;
26
27 private String country;
28
29 public int getId() {
30 return id;
31 }
32
33 public void setId(int id) {
34 this.id = id;
35 }
36
37 public String getName() {
38 return name;
39 }
40
41 public void setName(String name) {
42 this.name = name;
43 }
44
45 public String getCountry() {
46 return country;
47 }
48
49 public void setCountry(String country) {
50 this.country = country;
51 }
52
53 @Override
54 public String toString(){
55 return "id="+id+", name="+name+", country="+country;
56 }
57}
我们的实体向 MySQL 数据库中的 PERSON 表进行地图,请注意,我没有注明名称和国家字段与@Column注释,因为它们具有相同的名称。
1CREATE TABLE `Person` (
2 `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
3 `name` varchar(20) NOT NULL DEFAULT '',
4 `country` varchar(20) DEFAULT NULL,
5 PRIMARY KEY (`id`)
6) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
Hibernate DAO 应用程序
我们将创建PersonDAO界面,宣布我们将在我们的项目中使用的方法,接下来,我们将为其提供 hibernate 特定的实现。
1package com.journaldev.spring.dao;
2
3import java.util.List;
4
5import com.journaldev.spring.model.Person;
6
7public interface PersonDAO {
8
9 public void addPerson(Person p);
10 public void updatePerson(Person p);
11 public List<Person> listPersons();
12 public Person getPersonById(int id);
13 public void removePerson(int id);
14}
Hibernate 特定的 DAO 实施方式如下所示。
1package com.journaldev.spring.dao;
2
3import java.util.List;
4
5import org.hibernate.Session;
6import org.hibernate.SessionFactory;
7import org.slf4j.Logger;
8import org.slf4j.LoggerFactory;
9import org.springframework.stereotype.Repository;
10
11import com.journaldev.spring.model.Person;
12
13@Repository
14public class PersonDAOImpl implements PersonDAO {
15
16 private static final Logger logger = LoggerFactory.getLogger(PersonDAOImpl.class);
17
18 private SessionFactory sessionFactory;
19
20 public void setSessionFactory(SessionFactory sf){
21 this.sessionFactory = sf;
22 }
23
24 @Override
25 public void addPerson(Person p) {
26 Session session = this.sessionFactory.getCurrentSession();
27 session.persist(p);
28 logger.info("Person saved successfully, Person Details="+p);
29 }
30
31 @Override
32 public void updatePerson(Person p) {
33 Session session = this.sessionFactory.getCurrentSession();
34 session.update(p);
35 logger.info("Person updated successfully, Person Details="+p);
36 }
37
38 @SuppressWarnings("unchecked")
39 @Override
40 public List<Person> listPersons() {
41 Session session = this.sessionFactory.getCurrentSession();
42 List<Person> personsList = session.createQuery("from Person").list();
43 for(Person p : personsList){
44 logger.info("Person List::"+p);
45 }
46 return personsList;
47 }
48
49 @Override
50 public Person getPersonById(int id) {
51 Session session = this.sessionFactory.getCurrentSession();
52 Person p = (Person) session.load(Person.class, new Integer(id));
53 logger.info("Person loaded successfully, Person details="+p);
54 return p;
55 }
56
57 @Override
58 public void removePerson(int id) {
59 Session session = this.sessionFactory.getCurrentSession();
60 Person p = (Person) session.load(Person.class, new Integer(id));
61 if(null != p){
62 session.delete(p);
63 }
64 logger.info("Person deleted successfully, person details="+p);
65 }
66
67}
请注意,我不使用 Hibernate 交易,这是因为它将由 Spring 框架负责。
春季服务班级
以下是使用 Hibernate DAO 类来工作的人物对象的服务类。
1package com.journaldev.spring.service;
2
3import java.util.List;
4
5import com.journaldev.spring.model.Person;
6
7public interface PersonService {
8
9 public void addPerson(Person p);
10 public void updatePerson(Person p);
11 public List<Person> listPersons();
12 public Person getPersonById(int id);
13 public void removePerson(int id);
14
15}
1package com.journaldev.spring.service;
2
3import java.util.List;
4
5import org.springframework.stereotype.Service;
6import org.springframework.transaction.annotation.Transactional;
7
8import com.journaldev.spring.dao.PersonDAO;
9import com.journaldev.spring.model.Person;
10
11@Service
12public class PersonServiceImpl implements PersonService {
13
14 private PersonDAO personDAO;
15
16 public void setPersonDAO(PersonDAO personDAO) {
17 this.personDAO = personDAO;
18 }
19
20 @Override
21 @Transactional
22 public void addPerson(Person p) {
23 this.personDAO.addPerson(p);
24 }
25
26 @Override
27 @Transactional
28 public void updatePerson(Person p) {
29 this.personDAO.updatePerson(p);
30 }
31
32 @Override
33 @Transactional
34 public List<Person> listPersons() {
35 return this.personDAO.listPersons();
36 }
37
38 @Override
39 @Transactional
40 public Person getPersonById(int id) {
41 return this.personDAO.getPersonById(id);
42 }
43
44 @Override
45 @Transactional
46 public void removePerson(int id) {
47 this.personDAO.removePerson(id);
48 }
49
50}
请注意,使用@Transactional注释来应用春季声明交易管理。
春季控制班级
我们的DAO和服务类已经准备好了,是时候编写我们的控制器类,该类将负责客户端请求,并使用服务类执行数据库特定的操作,然后返回视图页面。
1package com.journaldev.spring;
2
3import org.springframework.beans.factory.annotation.Autowired;
4import org.springframework.beans.factory.annotation.Qualifier;
5import org.springframework.stereotype.Controller;
6import org.springframework.ui.Model;
7import org.springframework.web.bind.annotation.ModelAttribute;
8import org.springframework.web.bind.annotation.PathVariable;
9import org.springframework.web.bind.annotation.RequestMapping;
10import org.springframework.web.bind.annotation.RequestMethod;
11
12import com.journaldev.spring.model.Person;
13import com.journaldev.spring.service.PersonService;
14
15@Controller
16public class PersonController {
17
18 private PersonService personService;
19
20 @Autowired(required=true)
21 @Qualifier(value="personService")
22 public void setPersonService(PersonService ps){
23 this.personService = ps;
24 }
25
26 @RequestMapping(value = "/persons", method = RequestMethod.GET)
27 public String listPersons(Model model) {
28 model.addAttribute("person", new Person());
29 model.addAttribute("listPersons", this.personService.listPersons());
30 return "person";
31 }
32
33 //For add and update person both
34 @RequestMapping(value= "/person/add", method = RequestMethod.POST)
35 public String addPerson(@ModelAttribute("person") Person p){
36
37 if(p.getId() == 0){
38 //new person, add it
39 this.personService.addPerson(p);
40 }else{
41 //existing person, call update
42 this.personService.updatePerson(p);
43 }
44
45 return "redirect:/persons";
46
47 }
48
49 @RequestMapping("/remove/{id}")
50 public String removePerson(@PathVariable("id") int id){
51
52 this.personService.removePerson(id);
53 return "redirect:/persons";
54 }
55
56 @RequestMapping("/edit/{id}")
57 public String editPerson(@PathVariable("id") int id, Model model){
58 model.addAttribute("person", this.personService.getPersonById(id));
59 model.addAttribute("listPersons", this.personService.listPersons());
60 return "person";
61 }
62
63}
请注意,我正在使用@Controller注释,所以春季框架将把它当作一个控制器类来处理客户端请求。我也在使用@Autowired和@Qualifier注释来注入PersonService,我们也可以在春季背景xml文件中这样做。
Spring Bean 配置
我们的服务已经准备好了,我们只需要通过春豆配置进行线索。我们的 root-context.xml 文件是空的,所以我们只会查看 servlet-context.xml 文件。
1<?xml version="1.0" encoding="UTF-8"?>
2<beans:beans xmlns="https://www.springframework.org/schema/mvc"
3 xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:beans="https://www.springframework.org/schema/beans"
4 xmlns:context="https://www.springframework.org/schema/context" xmlns:tx="https://www.springframework.org/schema/tx"
5 xsi:schemaLocation="https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
6 https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
7 https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
8 https://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
9
10 <!-- DispatcherServlet Context: defines this servlet's request-processing
11 infrastructure -->
12
13 <!-- Enables the Spring MVC @Controller programming model -->
14 <annotation-driven />
15
16 <!-- Handles HTTP GET requests for /resources/** by efficiently serving
17 up static resources in the ${webappRoot}/resources directory -->
18 <resources mapping="/resources/**" location="/resources/" />
19
20 <!-- Resolves views selected for rendering by @Controllers to .jsp resources
21 in the /WEB-INF/views directory -->
22 <beans:bean
23 class="org.springframework.web.servlet.view.InternalResourceViewResolver">
24 <beans:property name="prefix" value="/WEB-INF/views/" />
25 <beans:property name="suffix" value=".jsp" />
26 </beans:bean>
27
28 <beans:bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
29 destroy-method="close">
30 <beans:property name="driverClassName" value="com.mysql.jdbc.Driver" />
31 <beans:property name="url"
32 value="jdbc:mysql://localhost:3306/TestDB" />
33 <beans:property name="username" value="pankaj" />
34 <beans:property name="password" value="pankaj123" />
35 </beans:bean>
36
37 <!-- Hibernate 4 SessionFactory Bean definition -->
38 <beans:bean id="hibernate4AnnotatedSessionFactory"
39 class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
40 <beans:property name="dataSource" ref="dataSource" />
41 <beans:property name="annotatedClasses">
42 <beans:list>
43 <beans:value>com.journaldev.spring.model.Person</beans:value>
44 </beans:list>
45 </beans:property>
46 <beans:property name="hibernateProperties">
47 <beans:props>
48 <beans:prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect
49 </beans:prop>
50 <beans:prop key="hibernate.show_sql">true</beans:prop>
51 </beans:props>
52 </beans:property>
53 </beans:bean>
54
55 <beans:bean id="personDAO" class="com.journaldev.spring.dao.PersonDAOImpl">
56 <beans:property name="sessionFactory" ref="hibernate4AnnotatedSessionFactory" />
57 </beans:bean>
58 <beans:bean id="personService" class="com.journaldev.spring.service.PersonServiceImpl">
59 <beans:property name="personDAO" ref="personDAO"></beans:property>
60 </beans:bean>
61 <context:component-scan base-package="com.journaldev.spring" />
62
63 <tx:annotation-driven transaction-manager="transactionManager"/>
64
65 <beans:bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
66 <beans:property name="sessionFactory" ref="hibernate4AnnotatedSessionFactory" />
67 </beans:bean>
68
69</beans:beans>
data source豆被定义为"org.apache.commons.dbcp. BasicData source"类用于基本连接集合. org.springframework.orm.hibernate4. 当地会议FactoryBean'豆用于Hibernate 4 SessionFactory。 对于Hibernate 3,您可找到与org.springframework.orm.hibernate3. 当地会议FactoryBean'和org.springframework.orm.hibernate3. 通知会议FactoryBean'相似的类。 一个重要的要点是,当我们依赖Spring框架来管理Hibernate会话时,我们不应定义hibernate.current_session_context_class',否则,你会得到许多与会话交易有关的问题。 ** personDAO和 person Service** 豆被自己理解. ** 交易经理** org.springframework.orm.hibernate4.Hibernate TransactionManager'是Spring ORM需要用于支持休眠会话交易管理的豆名定义. 对于 Hibernate 3, 你会发现类似 org. springframework.orm.hibernate3. 的类 。 Spring 使用 AOP 进行交易管理, 您现在可以将其与 QQ 交易的注释连接 。 ** 建议读取**:[春季AOP](/社区/专注会/春季-op-example-troduction-spect-avice-point-joinpoint-Notements]) "Spring AOP实例教程-外观,建议,点剪接,结合点,说明,XML配置")和[Spring AOP 交易管理](/community/tures/spring-transaction-management-jdbc-example).带有JDBC的春季交易管理示例`
查看页面
我们的应用程序的最后一部分是视图页面,注意在控制器处理方法中添加到模型的属性,我们将使用它们来创建我们的视图页面,我们还将使用 JSTL 标签,春季核心和春季表格标签。
1<%@ taglib uri="https://java.sun.com/jsp/jstl/core" prefix="c" %>
2<%@ taglib uri="https://www.springframework.org/tags" prefix="spring" %>
3<%@ taglib uri="https://www.springframework.org/tags/form" prefix="form" %>
4<%@ page session="false" %>
5<html>
6<head>
7 <title>Person Page</title>
8 <style type="text/css">
9 .tg {border-collapse:collapse;border-spacing:0;border-color:#ccc;}
10 .tg td{font-family:Arial, sans-serif;font-size:14px;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:#ccc;color:#333;background-color:#fff;}
11 .tg th{font-family:Arial, sans-serif;font-size:14px;font-weight:normal;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:#ccc;color:#333;background-color:#f0f0f0;}
12 .tg .tg-4eph{background-color:#f9f9f9}
13 </style>
14</head>
15<body>
16<h1>
17 Add a Person
18</h1>
19
20<c:url var="addAction" value="/person/add" ></c:url>
21
22<form:form action="${addAction}" commandName="person">
23<table>
24 <c:if test="${!empty person.name}">
25 <tr>
26 <td>
27 <form:label path="id">
28 <spring:message text="ID"/>
29 </form:label>
30 </td>
31 <td>
32 <form:input path="id" readonly="true" size="8" disabled="true" />
33 <form:hidden path="id" />
34 </td>
35 </tr>
36 </c:if>
37 <tr>
38 <td>
39 <form:label path="name">
40 <spring:message text="Name"/>
41 </form:label>
42 </td>
43 <td>
44 <form:input path="name" />
45 </td>
46 </tr>
47 <tr>
48 <td>
49 <form:label path="country">
50 <spring:message text="Country"/>
51 </form:label>
52 </td>
53 <td>
54 <form:input path="country" />
55 </td>
56 </tr>
57 <tr>
58 <td colspan="2">
59 <c:if test="${!empty person.name}">
60 <input type="submit"
61 value="<spring:message text="Edit Person"/>" />
62 </c:if>
63 <c:if test="${empty person.name}">
64 <input type="submit"
65 value="<spring:message text="Add Person"/>" />
66 </c:if>
67 </td>
68 </tr>
69</table>
70</form:form>
71<br>
72<h3>Persons List</h3>
73<c:if test="${!empty listPersons}">
74 <table class="tg">
75 <tr>
76 <th width="80">Person ID</th>
77 <th width="120">Person Name</th>
78 <th width="120">Person Country</th>
79 <th width="60">Edit</th>
80 <th width="60">Delete</th>
81 </tr>
82 <c:forEach items="${listPersons}" var="person">
83 <tr>
84 <td>${person.id}</td>
85 <td>${person.name}</td>
86 <td>${person.country}</td>
87 <td><a href="<c:url value='/edit/${person.id}' />" >Edit</a></td>
88 <td><a href="<c:url value='/remove/${person.id}' />" >Delete</a></td>
89 </tr>
90 </c:forEach>
91 </table>
92</c:if>
93</body>
94</html>
春季MVC Hibernate应用测试
Just build and deploy the project into any servlet container of your choice, for example, Tomcat. Below screenshots shows the view pages for our application. 
You will also find similar logs in the server log file.
1Hibernate: insert into PERSON (country, name) values (?, ?)
2INFO : com.journaldev.spring.dao.PersonDAOImpl - Person saved successfully, Person Details=id=15, name=Pankaj, country=USA
3Hibernate: select person0_.id as id1_0_, person0_.country as country2_0_, person0_.name as name3_0_ from PERSON person0_
4INFO : com.journaldev.spring.dao.PersonDAOImpl - Person List::id=10, name=Raman, country=UK2
5INFO : com.journaldev.spring.dao.PersonDAOImpl - Person List::id=11, name=Lisa, country=France
6INFO : com.journaldev.spring.dao.PersonDAOImpl - Person List::id=15, name=Pankaj, country=USA
摘要
本教程旨在为您提供足够的详细信息,以便您开始使用 Spring MVC 和 Hibernate 集成,我希望您会觉得有用。
您也可以从我们的 GitHub 存储库中检查该项目。