Trong bài hướng dẫn trước, chúng ta đã tìm hiểu cách sử dụng Spring và Hibernate. Hôm nay, chúng ta sẽ tiếp tục tích hợp Spring MVC, Hibernate, và MySQL thông qua một ví dụ CRUD trong ứng dụng web. Cấu trúc project cuối cùng của chúng ta có dạng như dưới đây.

Trong bài viết này chúng ta sẽ đi qua từng thành phần một. Lưu ý rằng bài này sử dụng phiên bản Spring 4.0.3.Release và Hibernate 4.3.5.Final. Nó cũng tương thích với Spring 4 và Hibernate 3, tuy nhiên bạn cần thực hiện một vài thay đổi nhỏ trong file cấu hình Spring bean như đã được đề cập ở tutorial trước.

Để chạy thử ví dụ này, trước hết hãy tải code của ví dụ về từ repo GitHub này.

Các dependency Maven

Hãy cùng xem xét tất cả các dependency Maven cần cho việc dùng Hibernate với Spring MVC.

	4.0.0
	com.journaldev.spring
	SpringMVCHibernate
	SpringMVCHibernate
	war
	1.0.0-BUILD-SNAPSHOT
	
		1.6
		4.0.3.RELEASE
		1.7.4
		1.7.5
		4.3.5.Final
	
	
		
		
			org.springframework
			spring-context
			${org.springframework-version}
			
				
				
					commons-logging
					commons-logging
				 
			
		
		
			org.springframework
			spring-webmvc
			${org.springframework-version}
		
		
			org.springframework
			spring-tx
			${org.springframework-version}
		
		
		
		
			org.hibernate
			hibernate-core
			${hibernate.version}
		
		
			org.hibernate
			hibernate-entitymanager
			${hibernate.version}
		
		
		
		
			commons-dbcp
			commons-dbcp
			1.4
		
		
		
			org.springframework
			spring-orm
			${org.springframework-version}
		
				
		
		
			org.aspectj
			aspectjrt
			${org.aspectj-version}
			
		
		
		
			org.slf4j
			slf4j-api
			${org.slf4j-version}
		
		
			org.slf4j
			jcl-over-slf4j
			${org.slf4j-version}
			runtime
		
		
			org.slf4j
			slf4j-log4j12
			${org.slf4j-version}
			runtime
		
		
			log4j
			log4j
			1.2.15
			
				
					javax.mail
					mail
				
				
					javax.jms
					jms
				
				
					com.sun.jdmk
					jmxtools
				
				
					com.sun.jmx
					jmxri
				
			
			runtime
		

		
		
			javax.inject
			javax.inject
			1
		
				
		
		
			javax.servlet
			servlet-api
			2.5
			provided
		
		
			javax.servlet.jsp
			jsp-api
			2.1
			provided
		
		
			javax.servlet
			jstl
			1.2
		
	
		
		
			junit
			junit
			4.7
			test
		

	
    
        
            
                maven-eclipse-plugin
                2.9
                
                    
                        org.springframework.ide.eclipse.core.springnature
                    
                    
                        org.springframework.ide.eclipse.core.springbuilder
                    
                    true
                    true
                
            
            
                org.apache.maven.plugins
                maven-compiler-plugin
                2.5.1
                
                    1.6
                    1.6
                    -Xlint:all
                    true
                    true
                
            
            
                org.codehaus.mojo
                exec-maven-plugin
                1.2.1
                
                    org.test.int1.Main
                
            
        
        ${project.artifactId}
    

Một số dependency ở trên được STS (Spring Tool Suite) tự động thêm vào khi tạo project Spring MVC. Các dependency quan trọng bao gồm spring-context, spring-webmvc, spring-tx, hibernate-core, hibernate-entitymanager và spring-orm.

Ở đây ta đang sử dụng Apache Commons DBCP cho connection pooling. Nhưng trong thực tế, thường thì container sẽ đảm nhiệm connection pooling và chúng ta chỉ cần cung cấp thông tin tham chiếu JNDI để sử dụng.

Lưu ý: Một số bạn đã gặp vấn đề về kết nối database. Lưu ý rằng trong file pom.xml của chúng tôi không có database driver trong đó. Tuy vậy, nó vẫn hoạt động được vì đã có driver MySQL trong thư mục lib của Tomcat và một số cấu hình DataSource connection sử dụng nó.

Nếu bạn gặp vấn đề với kết nối database, hãy thử đặt database driver vào thư mục lib của container hoặc khai báo nó trong dependency của file pom.xml.

Deployment Descriptor

Để tích hợp Spring vào một ứng dụng web, chúng ta cần cấu hình DispatcherServlet của Spring làm front controller. File web.xml của chúng ta trông như sau.

	
	
		contextConfigLocation
		/WEB-INF/spring/root-context.xml
	
	
	
	
		org.springframework.web.context.ContextLoaderListener
	

	
	
		appServlet
		org.springframework.web.servlet.DispatcherServlet
		
			contextConfigLocation
			/WEB-INF/spring/appServlet/servlet-context.xml
		
		1
	
		
	
		appServlet
		/
	

Phần lớn nội dung trên là boilerplate code. Phần quan trọng nhất là vị trí của file Spring context, nơi chúng ta sẽ cấu hình các Spring bean và service. Bạn có thể thay đổi chúng tùy theo yêu cầu của project.

Hibernate Entity Bean

Chúng ta đang sử dụng JPA annotation trong class entity bean, tuy nhiên, chúng ta cũng có thể dùng một Java bean đơn giản và định nghĩa thông tin mapping trong file XML. Trong trường hợp đó, chúng ta cần cung cấp đường dẫn đến file mapping khi cấu hình Hibernate SessionFactory trong phần cấu hình Spring bean.

package com.journaldev.spring.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * Entity bean with JPA annotations
 * Hibernate provides JPA implementation
 * @author pankaj
 *
 */
@Entity
@Table(name="PERSON")
public class Person {

	@Id
	@Column(name="id")
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private int id;
	
	private String name;
	
	private String country;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getCountry() {
		return country;
	}

	public void setCountry(String country) {
		this.country = country;
	}
	
	@Override
	public String toString(){
		return "id="+id+", name="+name+", country="+country;
	}
}

Entity bean của chúng ta map với bảng PERSON trong database MySQL. Lưu ý rằng ta không dùng annotation @Column cho các trường “name” và “country” vì tên trường và tên cột là giống nhau.

Script SQL dưới đây diễn tả chi tiết hơn về bảng đó:

CREATE TABLE `Person` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL DEFAULT '',
  `country` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

Triển khai Hibernate DAO

Chúng ta sẽ tạo interface PersonDAO để khai báo các phương thức sẽ sử dụng trong project. Tiếp theo, chúng ta sẽ cung cấp phần triển khai cụ thể bằng Hibernate cho interface này.

package com.journaldev.spring.dao;

import java.util.List;

import com.journaldev.spring.model.Person;

public interface PersonDAO {

	public void addPerson(Person p);
	public void updatePerson(Person p);
	public List listPersons();
	public Person getPersonById(int id);
	public void removePerson(int id);
}

Phần triển khai DAO bằng Hibernate trông như sau.

package com.journaldev.spring.dao;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;

import com.journaldev.spring.model.Person;

@Repository
public class PersonDAOImpl implements PersonDAO {
	
	private static final Logger logger = LoggerFactory.getLogger(PersonDAOImpl.class);

	private SessionFactory sessionFactory;
	
	public void setSessionFactory(SessionFactory sf){
		this.sessionFactory = sf;
	}

	@Override
	public void addPerson(Person p) {
		Session session = this.sessionFactory.getCurrentSession();
		session.persist(p);
		logger.info("Person saved successfully, Person Details="+p);
	}

	@Override
	public void updatePerson(Person p) {
		Session session = this.sessionFactory.getCurrentSession();
		session.update(p);
		logger.info("Person updated successfully, Person Details="+p);
	}

	@SuppressWarnings("unchecked")
	@Override
	public List listPersons() {
		Session session = this.sessionFactory.getCurrentSession();
		List personsList = session.createQuery("from Person").list();
		for(Person p : personsList){
			logger.info("Person List::"+p);
		}
		return personsList;
	}

	@Override
	public Person getPersonById(int id) {
		Session session = this.sessionFactory.getCurrentSession();		
		Person p = (Person) session.load(Person.class, new Integer(id));
		logger.info("Person loaded successfully, Person details="+p);
		return p;
	}

	@Override
	public void removePerson(int id) {
		Session session = this.sessionFactory.getCurrentSession();
		Person p = (Person) session.load(Person.class, new Integer(id));
		if(null != p){
			session.delete(p);
		}
		logger.info("Person deleted successfully, person details="+p);
	}

}

Lưu ý rằng ta không sử dụng Hibernate Transaction, vì việc này sẽ do Spring đảm nhiệm.

Các class Service của Spring

Đây là các class service sử dụng các class Hibernate DAO để làm việc với đối tượng Person.

package com.journaldev.spring.service;

import java.util.List;

import com.journaldev.spring.model.Person;

public interface PersonService {

	public void addPerson(Person p);
	public void updatePerson(Person p);
	public List listPersons();
	public Person getPersonById(int id);
	public void removePerson(int id);
	
}

package com.journaldev.spring.service;

import java.util.List;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.journaldev.spring.dao.PersonDAO;
import com.journaldev.spring.model.Person;

@Service
public class PersonServiceImpl implements PersonService {
	
	private PersonDAO personDAO;

	public void setPersonDAO(PersonDAO personDAO) {
		this.personDAO = personDAO;
	}

	@Override
	@Transactional
	public void addPerson(Person p) {
		this.personDAO.addPerson(p);
	}

	@Override
	@Transactional
	public void updatePerson(Person p) {
		this.personDAO.updatePerson(p);
	}

	@Override
	@Transactional
	public List listPersons() {
		return this.personDAO.listPersons();
	}

	@Override
	@Transactional
	public Person getPersonById(int id) {
		return this.personDAO.getPersonById(id);
	}

	@Override
	@Transactional
	public void removePerson(int id) {
		this.personDAO.removePerson(id);
	}

}

Lưu ý rằng cơ chế quản lý transaction khai báo (declarative transaction) của Spring được áp dụng thông qua annotation @Transactional.

Class Controller của Spring

Ta đã xong với class DAO và Service, giờ là lúc viết class controller. Class này sẽ xử lý các request từ client, sử dụng các class service để thực hiện các thao tác với database, và sau đó trả về các trang view.

package com.journaldev.spring;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.journaldev.spring.model.Person;
import com.journaldev.spring.service.PersonService;

@Controller
public class PersonController {
	
	private PersonService personService;
	
	@Autowired(required=true)
	@Qualifier(value="personService")
	public void setPersonService(PersonService ps){
		this.personService = ps;
	}
	
	@RequestMapping(value = "/persons", method = RequestMethod.GET)
	public String listPersons(Model model) {
		model.addAttribute("person", new Person());
		model.addAttribute("listPersons", this.personService.listPersons());
		return "person";
	}
	
	//For add and update person both
	@RequestMapping(value= "/person/add", method = RequestMethod.POST)
	public String addPerson(@ModelAttribute("person") Person p){
		
		if(p.getId() == 0){
			//new person, add it
			this.personService.addPerson(p);
		}else{
			//existing person, call update
			this.personService.updatePerson(p);
		}
		
		return "redirect:/persons";
		
	}
	
	@RequestMapping("/remove/{id}")
    public String removePerson(@PathVariable("id") int id){
		
        this.personService.removePerson(id);
        return "redirect:/persons";
    }
 
    @RequestMapping("/edit/{id}")
    public String editPerson(@PathVariable("id") int id, Model model){
        model.addAttribute("person", this.personService.getPersonById(id));
        model.addAttribute("listPersons", this.personService.listPersons());
        return "person";
    }
	
}

Lưu ý rằng ta sử dụng annotation @Controller, để Spring xem đây là một class Controller xử lý các request từ client. Ta cũng đang dùng annotation @Autowired và @Qualifier để inject PersonService. Chúng ta cũng có thể thực hiện việc này trong file XML của Spring context.

Cấu hình Spring Bean

Các service của chúng ta đã sẵn sàng, giờ chỉ cần kết nối chúng lại thông qua cấu hình Spring bean. File root-context.xml của chúng ta chưa có gì, vì vậy chúng ta sẽ chỉ xem xét file servlet-context.xml.

	

	
	

	
	

	
	
		
		
	

	
		
		
		
		
	

	
	
		
		
			
				com.journaldev.spring.model.Person
			
		
		
			
				org.hibernate.dialect.MySQLDialect
				
				true
			
		
	
	
	
		
	
	
		
	
	
	
	
	
	
		
	

dataSource bean được định nghĩa cho class org.apache.commons.dbcp.BasicDataSource để thực hiện connection pooling cơ bản.

Bean org.springframework.orm.hibernate4.LocalSessionFactoryBean được sử dụng cho SessionFactory của Hibernate 4. Đối với Hibernate 3, bạn sẽ tìm thấy các class tương tự là org.springframework.orm.hibernate3.LocalSessionFactoryBean và org.springframework.orm.hibernate3.AnnotationSessionFactoryBean.

Một điểm quan trọng là khi chúng ta dựa vào Spring framework để quản lý Hibernate Session, chúng ta không nên định nghĩa thuộc tính hibernate.current_session_context_class, nếu không bạn sẽ gặp nhiều vấn đề liên quan đến session transaction.

Các bean personDAO và personService khá dễ hiểu. Cần phải định nghĩa bean transactionManager cho org.springframework.orm.hibernate4.HibernateTransactionManager để Spring ORM hỗ trợ quản lý transaction cho Hibernate session.

Đối với Hibernate 3, bạn sẽ tìm thấy class tương tự là org.springframework.orm.hibernate3.HibernateTransactionManager. Spring sử dụng AOP để quản lý transaction. Bạn có thể liên hệ điều này với annotation @Transactional.

Trang View

Phần cuối cùng của ứng dụng là trang view. Hãy chú ý các attribute được thêm vào Model trong các phương thức xử lý (handler methods) của Controller, chúng ta sẽ sử dụng chúng để tạo trang view. Chúng ta cũng sẽ sử dụng các thẻ JSTL, thẻ Spring core và thẻ Spring form.

<%@ taglib uri="https://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="https://www.springframework.org/tags" prefix="spring" %>
<%@ taglib uri="https://www.springframework.org/tags/form" prefix="form" %>
<%@ page session="false" %>


	
	



	Add a Person






	

	

		

			
				
			
		
		

			
			
		
 
	
	
	

		

			
				
			
		
		

			
		
 
	
	

		

			
				
			
		
		

			
		
	
	

		

			
				" />
			
			
				" />
			
		
	
	



Persons List

	
		

	

		
Person ID
		
Person Name
		
Person Country
		
Edit
		
Delete
	
	

			
${person.id}
			
${person.name}
			
${person.country}
			
Edit
			
Delete
		
	
	

Kiểm thử

Hãy build và deploy project vào bất kỳ servlet container nào bạn thích, ví dụ như Tomcat. Dưới đây là hình ảnh các trang view của ứng dụng.

Ta cũng sẽ tìm thấy các log tương tự trong file log của server.

Hibernate: insert into PERSON (country, name) values (?, ?)
INFO : com.journaldev.spring.dao.PersonDAOImpl - Person saved successfully, Person Details=id=15, name=Pankaj, country=USA
Hibernate: select person0_.id as id1_0_, person0_.country as country2_0_, person0_.name as name3_0_ from PERSON person0_
INFO : com.journaldev.spring.dao.PersonDAOImpl - Person List::id=10, name=Raman, country=UK2
INFO : com.journaldev.spring.dao.PersonDAOImpl - Person List::id=11, name=Lisa, country=France
INFO : com.journaldev.spring.dao.PersonDAOImpl - Person List::id=15, name=Pankaj, country=USA