Beruflich Dokumente
Kultur Dokumente
http://www.codejava.net/frameworks/spring/sprin...
Print M Email
In enterprise Java application development, perhaps Spring and Hibernate integration is one of the most-demanded topic which most
programmers are looking for and are facing with. Spring is the leading enterprise application framework, and Hibernate is the leading ORM
framework so combination of these two guys would be a preferable choice in order to develop robust enterprise applications.
This is a step-by-step tutorial that helps you build a Spring-Hibernate application easily in a clear and concise way. In this first part, we
demonstrate how to code a simple Spring MVC application that displays a list of users from MySQL database. The DAO implementation
uses Hibernates SessionFactory to query against the database, instead of using JdbcTemplate.
The following configuration approaches are used in the demo application:
Spring MVC: Annotations for controller and XML for bean definitions.
Hibernate: XML mapping for model class.
Web Application: using web.xml deployment descriptor file.
The following technologies and pieces of software are used throughout this tutorial:
Java 7
Spring framework 4.0.3.RELEASED
Hibernate ORM 4.3.5.Final
Spring Tool Suite IDE 3.5.1
Maven 3
Tomcat 7
1.
Basically, in order to support Hibernate integration, Spring provides two key beans available in the
org.springframework.orm.hibernate4 package:
LocalSessionFactoryBean: creates a Hibernates SessionFactory which is injected into Hibernate-based DAO classes.
HibernateTransactionManager: provides transaction support code for a SessionFactory. Programmers can use
@Transactional annotation in DAO methods to avoid writing boiler-plate transaction code explicitly.
Lets see how these concepts are implemented in a real project.
1 de 9
02/08/15 23:07
SpringSetting
4 and Hibernate
Integration Tutorial Par...
2.
up4 Project
http://www.codejava.net/frameworks/spring/sprin...
Lets create a Spring MVC project using Spring Tool Suite IDE (See example: Spring MVC beginner tutorial with Spring Tool Suite IDE),
name it as SpringMvcHibernateXML.
Setting up Database
Execute the following MySQL script in order to create a database named usersdb with a table named users:
1
2
3
4
5
6
7
8
9
Project Structure
The following screenshot shows final structure of the project:
NOTE: After completing this tutorial, you will create a project structure looks like the above.
Maven Dependencies
Declare versions for Java and Spring framework:
1
2
3
4
<properties>
<java-version>1.7</java-version>
<org.springframework-version>4.0.3.RELEASE</org.springframework-version>
</properties>
2 de 9
02/08/15 23:07
<dependency>
Spring14 and
Hibernate 4 Integration Tutorial Par...
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
http://www.codejava.net/frameworks/spring/sprin...
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${org.springframework-version}</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>4.3.5.Final</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.1</version>
<scope>provided</scope>
</dependency>
JSTL dependency:
1
2
3
4
5
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-dbcp2</artifactId>
<version>2.0</version>
</dependency>
3 de 9
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.30</version>
</dependency>
02/08/15 23:07
NOTE:
canHibernate
see the whole
content of pom.xml
file in
the attached project.
Spring You
4 and
4 Integration
Tutorial
Par...
http://www.codejava.net/frameworks/spring/sprin...
This book: Getting started with Spring Framework helps you master all major concepts like Spring core modules, dependency injection,
Spring AOP, annotation-driven development, and more.
3.
Create a new class named User.java in the package net.codejava.spring.model with the following source code:
1
2
3
4
5
6
7
8
9
10
11
package net.codejava.spring.model;
public class User {
private int id;
private String username;
private String password;
private String email;
// getters and setters are removed for brevity
}
This model class is used to map the table users and the database to a plain-old Java object (POJO).
NOTE: For more information about Hibernate XML mapping, see: Hibernate One-to-Many XML Mapping Example.
Creating Hibernate XML Configuration File
Create hibernate.cfg.xml file under the root of classpath (right in src directory in the project) with the following XML code:
1
2
3
4
5
6
7
8
9
10
11
4 de
9
This
Hibernate
configuration file declares which resources need to be mapped (the User.hbm.xml file in this case).
02/08/15 23:07
4.
http://www.codejava.net/frameworks/spring/sprin...
Create a very simple DAO interface for the User class as the following UserDAO.java class:
1
2
3
4
5
6
7
8
9
package net.codejava.spring.dao;
import java.util.List;
import net.codejava.spring.model.User;
public interface UserDAO {
public List<User> list();
}
This interface declares only one method list() that retrieves all users from the database.
package net.codejava.spring.dao;
import java.util.List;
import net.codejava.spring.model.User;
import org.hibernate.Criteria;
import org.hibernate.SessionFactory;
import org.springframework.transaction.annotation.Transactional;
public class UserDAOImpl implements UserDAO {
private SessionFactory sessionFactory;
public UserDAOImpl(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
@Override
@Transactional
public List<User> list() {
@SuppressWarnings("unchecked")
List<User> listUser = (List<User>) sessionFactory.getCurrentSession()
.createCriteria(User.class)
.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).list();
}
return listUser;
Notice in this class, a Hibernates SessionFactory object is injected via constructor by Spring. The list() method simply obtains the
current session from the SessionFactory and queries for a list of all users in the database.
Pay attention to the @Transactional annotation provided by Spring - when a method is annotated by this annotation, Spring will inject
transaction support code into the method - thus we dont have two write any code to handle transaction explicitly.
5 de 9
02/08/15 23:07
SpringConfiguring
4 and Hibernate 4 Integration
Tutorial
Par...
http://www.codejava.net/frameworks/spring/sprin...
5.
Spring
Application
Context
Now, we come to the most important part that wires Spring and Hibernate together through some XML configuration. Open the servletcontext.xml file under src/main/webapp/WEB-INF/spring/appServlet and update its content as follows.
<mvc:annotation-driven />
<mvc:resources mapping="/resources/**" location="/resources/" />
<context:component-scan base-package="net.codejava.spring" />
The following declaration for a common view resolver that converts logical view names to actual JSP pages:
1
2
3
4
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/" />
<property name="suffix" value=".jsp" />
</bean>
NOTE: Change database URL, username and password according to values in your environment. This data source will be injected to a
SessionFactory bean below.
<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="configLocation" value="classpath:hibernate.cfg.xml" />
</bean>
Note that this LocalSessionFactoryBean requires a DataSource bean which is declared previously. The configLocation
property specifies where Hibernate configuration file will be searched for. In this case, it is the hibernate.cfg.xml file in the classpath.
<tx:annotation-driven />
<bean id="transactionManager"
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
As mentioned in the UserDAOImpl class, we can specify transaction support by using the @Transactional annotation for
transaction-aware methods.
02/08/15 23:07
1
<bean
class="net.codejava.spring.dao.UserDAOImpl">
Spring
4 and id="userDao"
Hibernate 4 Integration
Tutorial Par...
http://www.codejava.net/frameworks/spring/sprin...
2
3
4
5
<constructor-arg>
<ref bean="sessionFactory" />
</constructor-arg>
</bean>
This bean will be then injected to a Spring MVC controller class which is described below.
NOTE: For the whole content of Spring application context configuration file, see the corresponding file in the attached project.
This book: Spring Integration in Action help you learn more about enterprise integration and messaging using the Spring Integration
framework.
6.
Write our Spring MVC controller class (HomeController.java) under the net.codejava.spring package with the following code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package net.codejava.spring;
import java.util.List;
import net.codejava.spring.dao.UserDAO;
import net.codejava.spring.model.User;
import
import
import
import
org.springframework.beans.factory.annotation.Autowired;
org.springframework.stereotype.Controller;
org.springframework.web.bind.annotation.RequestMapping;
org.springframework.web.servlet.ModelAndView;
/**
* Handles requests for the application home page.
*/
@Controller
public class HomeController {
@Autowired
private UserDAO userDao;
@RequestMapping(value="/")
public ModelAndView home() {
List<User> listUsers = userDao.list();
ModelAndView model = new ModelAndView("home");
model.addObject("userList", listUsers);
return model;
}
}
Here, an implementation of the UserDAO is injected automatically by Spring (because @Autowired annotation is used). Remember the
UserDAOImpl bean we declared in the Spring application context configuration file previously? It is injected to this controller automatically
so that the handling method home() can use it to list all users from the database. And eventually, the home() method returns a view
named home which is resolved an actual JSP page which is described below.
7.
Create a home.jsp under the src/main/webapp/WEB-INF/views directory with the following content:
7 de 9
02/08/15 23:07
1
<%@page
contentType="text/html"
pageEncoding="UTF-8"%>
Spring
4
and Hibernate
4 Integration Tutorial
Par...
http://www.codejava.net/frameworks/spring/sprin...
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Home</title>
</head>
<body>
<div align="center">
<h1>Contact List</h1>
<table border="1">
<th>No</th>
<th>Username</th>
<th>Email</th>
<c:forEach var="user" items="${userList}" varStatus="status">
<tr>
<td>${status.index + 1}</td>
<td>${user.username}</td>
<td>${user.email}</td>
</tr>
</c:forEach>
</table>
</div>
</body>
</html>
This JSP page simply displays a list of users which is passed by the controller, by using JSTL tags.
This book: Spring in Practice covers 66 Spring development techniques that help you solve practical issues you will encounter when
using Spring framework.
8.
Deploy the SpringMvcHibernateXML application on Tomcat server and access its default page via the following URL:
http://localhost:8080/SpringMvcHibernateXML
If everything is going fine, you would see the following result:
Congratulations! You have completed our first part of Spring-Hibernate Integration series. You can download the attached project and
experiment
8 de 9 yourself. A deployable WAR file is also provided for your convenience.
02/08/15 23:07
Part 2: Spring 4 and Hibernate 4 Integration Tutorial Part 2: Java-based Configuration
http://www.codejava.net/frameworks/spring/sprin...
References:
Object Relational Mapping (ORM) Data Access
This video tutorial: The Java Spring Tutorial help you discover how to master the Spring framework instantly.
Do you want to be expert in Java programming? If you do, why not join our mailing list to get advices from the professionals everyday?
Just click here: http://newsletter.codejava.net - It's FREE, Quick and Awesome!
Attachments:
SpringMvcHibernateXML.war [Deploy-read WAR]
SpringMvcHibernateXML.zip [Eclipse-Maven Project]
9 de 9
12699 kB
30 kB
02/08/15 23:07