Introduction
In this tutorial we'll explore how to implement a one-to-many association using Hibernate Annotations and Spring MVC 3. We will use @OneToMany annotation to specify the relationship between our objects. We will not specify Cascade types or Fetch strategies, but instead rely on @OneToMany's default settings.If you want to see how to implement this project using @ManyToOne annotation instead, see Spring - Hibernate: Many-To-One Association.
Spring MVC 3 and Hibernate Tutorials Series
Spring - Hibernate: Many-To-One Association - Explicitly Specify Join Table, Cascade, and Fetch
Spring - Hibernate: One-To-Many Association - Explicitly Specify Join Table, Cascade, and Fetch
Spring - Hibernate: Many-To-One Association
Spring - Hibernate: One-To-Many Association
Spring MVC 3, Hibernate Annotations, MySQL Integration Tutorial
Spring MVC 3, Hibernate Annotations, HSQLDB Integration Tutorial
What is One-To-Many Association?
One-to-many relationships occur when each record in TableA may have many linked records in TableB but each record in TableB may have only one corresponding record in TableA.
Source: http://databases.about.com/od/specificproducts/g/onetomany.htm
Specification
Our application is simple CRUD system for managing a list of records. Each record corresponds to a single person containing personal information and credit card details. Each person can own zero or more credit cards. Moreover, a person's person information is edited separately from his credit card details.Below are sample screenshots from the application:
Domain Objects
Based on the specs, we have two domain objects: Person and Credit Card.A Person object has the following properties:
- id
- first name
- last name
- money
- credit cards
Whereas a Credit Card object has the following properties:
- id
- type
- number
Notice each Person can have multiple Credit Cards hence, the one-to-many relationship. We can of course look at this relationship the other way around: many-to-one relationship. But that topic is for another tutorial.
Development
We'll split our development in three layers: Domain, Service, and Controller. Then we'll declare the configuration files. Let's start with the Domain layer.Domain Layer
As discussed earlier, we have two domain objects: Person and Credit Card. Consequently, we'll declare two POJOs to represent our domain. Each POJO will be annotated with @Entity so that we can persist them to a database.Person.java
package org.krams.tutorial.domain; import java.io.Serializable; import java.util.Set; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.OneToMany; import javax.persistence.Table; /** * Represents a person entity * * @author Krams at {@link http://krams915@blogspot.com} */ @Entity @Table(name = "PERSON") public class Person implements Serializable { private static final long serialVersionUID = -5527566248002296042L; @Id @Column(name = "ID") @GeneratedValue private Integer id; @Column(name = "FIRST_NAME") private String firstName; @Column(name = "LAST_NAME") private String lastName; @Column(name = "MONEY") private Double money; @OneToMany private Set<CreditCard> creditCards; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getLastName() { return lastName; } public void setLastName(String lastName) { this.lastName = lastName; } public Double getMoney() { return money; } public void setMoney(Double money) { this.money = money; } public Set<CreditCard> getCreditCards() { return creditCards; } public void setCreditCards(Set<CreditCard> creditCards) { this.creditCards = creditCards; } }
Person object has been mapped to the PERSON table. The table that gets auto-generated looks as follows:
Notice the @OneToMany annotation for the field creditCards. We did not specify any Cascade type or Fetch strategy for this field. Instead, we rely on the annotation's default settings. Later we'll discover some issues for not specifying them.
@Entity @Table(name = "PERSON") public class Person implements Serializable { ... @OneToMany private Set<CreditCard> creditCards; ... }
CreditCard.java
package org.krams.tutorial.domain; import java.io.Serializable; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.Table; /** * Represents a credit card entity * * @author Krams at {@link http://krams915@blogspot.com} */ @Entity @Table(name = "CREDIT_CARD") public class CreditCard implements Serializable { private static final long serialVersionUID = 5924361831551833717L; @Id @Column(name = "ID") @GeneratedValue private Integer id; @Column(name = "TYPE") private String type; @Column(name = "NUMBER") private String number; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getType() { return type; } public void setType(String type) { this.type = type; } public String getNumber() { return number; } public void setNumber(String number) { this.number = number; } }
CreditCard object has been mapped to the CREDIT_CARD table. The table that gets auto-generated looks as follows:
Using phpymyadmin's database designer, the Hibernate auto-generated relationship between Person and CreditCard looks as follows:
Again using phpymyadmin, the auto-generated tables looks as follows:
We only declared two entities: a Person entity and a CreditCard entity. We expect two tables in the database; however, we have three tables in the database instead. Why? The default behavior of @OneToMany is it will create a third table acting as the join table.
Here's a quote from the Hibernate Annotations Reference guide:
Without describing any physical mapping, a unidirectional one to many with join table is used. The table name is the concatenation of the owner table name, _, and the other side table name. The foreign key name(s) referencing the owner table is the concatenation of the owner table, _, and the owner primary key column(s) name. The foreign key name(s) referencing the other side is the concatenation of the owner property name, _, and the other side primary key column(s) name. A unique constraint is added to the foreign key referencing the other side table to reflect the one to many.
The Hibernate Annotations Reference is stating the behavior in terms of the database structure. Later we'll discuss some issues when relying on the default settings, especially in the Service layer.
Service Layer
After declaring the Domain objects, we'll now proceed with the Service layer which contains two services: a PersonService and a CreditCardService.PersonService
PersonService is responsible for handling CRUD operations for Person entities. Each method is eventually delegated to a Hibernate Session object.
PersonService.java
package org.krams.tutorial.service; import java.util.List; import java.util.Set; import javax.annotation.Resource; import org.apache.log4j.Logger; import org.hibernate.Query; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.krams.tutorial.domain.CreditCard; import org.krams.tutorial.domain.Person; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; /** * Service for processing Persons * * @author Krams at {@link http://krams915@blogspot.com */ @Service("personService") @Transactional public class PersonService { protected static Logger logger = Logger.getLogger("service"); @Resource(name="sessionFactory") private SessionFactory sessionFactory; /** * Retrieves all persons * * @return a list of persons */ public List<Person> getAll() { logger.debug("Retrieving all persons"); // Retrieve session from Hibernate Session session = sessionFactory.getCurrentSession(); // Create a Hibernate query (HQL) Query query = session.createQuery("FROM Person"); // Retrieve all return query.list(); } /** * Retrieves a single person */ public Person get( Integer id ) { // Retrieve session from Hibernate Session session = sessionFactory.getCurrentSession(); // Retrieve existing person // Create a Hibernate query (HQL) Query query = session.createQuery("FROM Person as p LEFT JOIN FETCH p.creditCards WHERE p.id="+id); return (Person) query.uniqueResult(); } /** * Adds a new person */ public void add(Person person) { logger.debug("Adding new person"); // Retrieve session from Hibernate Session session = sessionFactory.getCurrentSession(); // Persists to db session.save(person); } /** * Deletes an existing person * @param id the id of the existing person */ public void delete(Integer id) { logger.debug("Deleting existing person"); // Retrieve session from Hibernate Session session = sessionFactory.getCurrentSession(); // Create a Hibernate query (HQL) Query query = session.createQuery("FROM Person as p LEFT JOIN FETCH p.creditCards WHERE p.id="+id); // Retrieve record Person person = (Person) query.uniqueResult(); Set<CreditCard> creditCards =person.getCreditCards(); // Delete person session.delete(person); // Delete associated credit cards for (CreditCard creditCard: creditCards) { session.delete(creditCard); } } /** * Edits an existing person */ public void edit(Person person) { logger.debug("Editing existing person"); // Retrieve session from Hibernate Session session = sessionFactory.getCurrentSession(); // Retrieve existing person via id Person existingPerson = (Person) session.get(Person.class, person.getId()); // Assign updated values to this person existingPerson.setFirstName(person.getFirstName()); existingPerson.setLastName(person.getLastName()); existingPerson.setMoney(person.getMoney()); // Save updates session.save(existingPerson); } }
PersonService deceptively looks simple; however it solves two main issues that deserves special attention:
Issue #1: Fetch Strategy
Retrieving a Person record (owner) doesn't load its associated CreditCard records (owned entities).
The following query retrieves a Person based on its id.
Query query = session.createQuery("FROM Person WHERE p.id="+id);
The problem with the previous query is it doesn't load the associated CreditCards. This is because we did not specify a Fetch strategy when we declared the @OneToMany annotation. To fix that we use the following query instead:
Query query = session.createQuery("FROM Person as p LEFT JOIN FETCH p.creditCards WHERE p.id="+id);
Issue #2: Cascade Type
Deleting a Person record doesn't delete its associated CreditCard records.
The following query deletes a Person record:
session.delete(person);
The problem with the previous query is it doesn't delete the associated CreditCards. This is because we did not specify a Cascade type when we declared the @OneToMany annotation. That means we have to implement our own strategy for deleting the CreditCard records.
To resolve the issue we first make a FETCH query. Retrieve the CreditCard objects and assigned them to a temporary object. We then delete the Person record. Afterwards, we loop each credit card record, and delete them one by one.
// Create a Hibernate query (HQL) Query query = session.createQuery("FROM Person as p LEFT JOIN FETCH p.creditCards WHERE p.id="+id); // Retrieve record Person person = (Person) query.uniqueResult(); Set<CreditCard> creditCards =person.getCreditCards(); // Delete person session.delete(person); // Delete associated credit cards for (CreditCard creditCard: creditCards) { session.delete(creditCard); }
CreditCardService
CreditCardService is responsible for handling CRUD operations for CreditCard entities. Each method is eventually delegated to a Hibernate Session object.
CreditCardService.java
package org.krams.tutorial.service; import java.util.ArrayList; import java.util.List; import javax.annotation.Resource; import org.apache.log4j.Logger; import org.hibernate.Query; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.krams.tutorial.domain.CreditCard; import org.krams.tutorial.domain.Person; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; /** * Service for processing Credit Cards * * @author Krams at {@link http://krams915@blogspot.com */ @Service("creditCardService") @Transactional public class CreditCardService { protected static Logger logger = Logger.getLogger("service"); @Resource(name="sessionFactory") private SessionFactory sessionFactory; /** * Retrieves all credit cards */ public List<CreditCard> getAll(Integer personId) { logger.debug("Retrieving all credit cards"); // Retrieve session from Hibernate Session session = sessionFactory.getCurrentSession(); // Create a Hibernate query (HQL) Query query = session.createQuery("FROM Person as p LEFT JOIN FETCH p.creditCards WHERE p.id="+personId); Person person = (Person) query.uniqueResult(); // Retrieve all return new ArrayList<CreditCard>(person.getCreditCards()); } /** * Retrieves all credit cards */ public List<CreditCard> getAll() { logger.debug("Retrieving all credit cards"); // Retrieve session from Hibernate Session session = sessionFactory.getCurrentSession(); // Create a Hibernate query (HQL) Query query = session.createQuery("FROM CreditCard"); // Retrieve all return query.list(); } /** * Retrieves a single credit card */ public CreditCard get( Integer id ) { // Retrieve session from Hibernate Session session = sessionFactory.getCurrentSession(); // Retrieve existing credit card CreditCard creditCard = (CreditCard) session.get(CreditCard.class, id); // Persists to db return creditCard; } /** * Adds a new credit card */ public void add(Integer personId, CreditCard creditCard) { logger.debug("Adding new credit card"); // Retrieve session from Hibernate Session session = sessionFactory.getCurrentSession(); // Persists to db session.save(creditCard); // Add to person as well // Retrieve existing person via id Person existingPerson = (Person) session.get(Person.class, personId); // Assign updated values to this person existingPerson.getCreditCards().add(creditCard); // Save updates session.save(existingPerson); } /** * Deletes an existing credit card */ public void delete(Integer id) { logger.debug("Deleting existing credit card"); // Retrieve session from Hibernate Session session = sessionFactory.getCurrentSession(); // Delete reference to foreign key credit card first // We need a SQL query instead of HQL query here to access the third table Query query = session.createSQLQuery("DELETE FROM PERSON_CREDIT_CARD " + "WHERE creditCards_ID="+id); query.executeUpdate(); // Retrieve existing credit card CreditCard creditCard = (CreditCard) session.get(CreditCard.class, id); // Delete session.delete(creditCard); } /** * Edits an existing credit card */ public void edit(CreditCard creditCard) { logger.debug("Editing existing creditCard"); // Retrieve session from Hibernate Session session = sessionFactory.getCurrentSession(); // Retrieve existing credit card via id CreditCard existingCreditCard = (CreditCard) session.get(CreditCard.class, creditCard.getId()); // Assign updated values to this credit card existingCreditCard.setNumber(creditCard.getNumber()); existingCreditCard.setType(creditCard.getType()); // Save updates session.save(existingCreditCard); } }
CreditCardService's delete() method deserves extra attention:
public void delete(Integer id) { logger.debug("Deleting existing credit card"); // Retrieve session from Hibernate Session session = sessionFactory.getCurrentSession(); // Delete reference to foreign key credit card first // We need a SQL query instead of HQL query here to access the third table Query query = session.createSQLQuery("DELETE FROM PERSON_CREDIT_CARD " + "WHERE creditCards_ID="+id); query.executeUpdate(); // Retrieve existing credit card CreditCard creditCard = (CreditCard) session.get(CreditCard.class, id); // Delete session.delete(creditCard); }To delete a CreditCard entity, we have to delete it first from the PERSON_CREDIT_CARD table using the following SQL query:
Query query = session.createSQLQuery("DELETE FROM PERSON_CREDIT_CARD " + "WHERE creditCards_ID="+id);Notice PERSON_CREDIT_CARD is the join table created by Hibernate and the query is a SQL not HQL.
After running the SQL statement, we delete the CreditCard entity from the CREDIT_CARD table using
session.delete(creditCard).
Why do we need to undergo such process? Can't we just run session.delete(creditCard) directly? We can't because there's a foreign key constraint under PERSON_CREDIT_CARD join table.
Controller Layer
After declaring the Domain and Service objects, we'll now proceed with the Controller layer.We'll declare two controllers: MainController and CreditCardController.
MainController
MainController is responsible for handling request for Person records. Each CRUD request is ultimately delegated to the PersonService and then returns an appropriate JSP page.
MainController.java
package org.krams.tutorial.controller; import java.util.ArrayList; import java.util.List; import javax.annotation.Resource; import org.apache.log4j.Logger; import org.krams.tutorial.domain.Person; import org.krams.tutorial.dto.PersonDTO; import org.krams.tutorial.service.CreditCardService; import org.krams.tutorial.service.PersonService; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.ModelAttribute; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RequestParam; /** * Handles person request * * @author Krams at {@link http://krams915@blogspot.com */ @Controller @RequestMapping("/main/record") public class MainController { protected static Logger logger = Logger.getLogger("controller"); @Resource(name="personService") private PersonService personService; @Resource(name="creditCardService") private CreditCardService creditCardService; /** * Retrieves the "Records" page */ @RequestMapping(value = "/list", method = RequestMethod.GET) public String getRecords(Model model) { logger.debug("Received request to show records page"); // Retrieve all persons List<Person> persons = personService.getAll(); // Prepare model object List<PersonDTO> personsDTO = new ArrayList<PersonDTO>(); for (Person person: persons) { // Create new data transfer object PersonDTO dto = new PersonDTO(); dto.setId(person.getId()); dto.setFirstName(person.getFirstName()); dto.setLastName(person.getLastName()); dto.setMoney(person.getMoney()); dto.setCreditCards(creditCardService.getAll(person.getId())); // Add to model list personsDTO.add(dto); } // Add to model model.addAttribute("persons", personsDTO); // This will resolve to /WEB-INF/jsp/records.jsp return "records"; } /** * Retrieves the "Add New Record" page */ @RequestMapping(value = "/add", method = RequestMethod.GET) public String getAdd(Model model) { logger.debug("Received request to show add page"); // Create new Person and add to model model.addAttribute("personAttribute", new Person()); // This will resolve to /WEB-INF/jsp/add-record.jsp return "add-record"; } /** * Adds a new record */ @RequestMapping(value = "/add", method = RequestMethod.POST) public String postAdd(@ModelAttribute("personAttribute") Person person) { logger.debug("Received request to add new record"); // Delegate to service personService.add(person); // Redirect to url return "redirect:/krams/main/record/list"; } /** * Deletes a record including all the associated credit cards */ @RequestMapping(value = "/delete", method = RequestMethod.GET) public String getDelete(@RequestParam("id") Integer personId) { logger.debug("Received request to delete record"); // Delete person personService.delete(personId); // Redirect to url return "redirect:/krams/main/record/list"; } /** * Retrieves the "Edit Existing Record" page */ @RequestMapping(value = "/edit", method = RequestMethod.GET) public String getEdit(@RequestParam("id") Integer personId, Model model) { logger.debug("Received request to show edit page"); // Retrieve person by id Person existingPerson = personService.get(personId); // Add to model model.addAttribute("personAttribute", existingPerson); // This will resolve to /WEB-INF/jsp/edit-record.jsp return "edit-record"; } /** * Edits an existing record */ @RequestMapping(value = "/edit", method = RequestMethod.POST) public String postEdit(@RequestParam("id") Integer personId, @ModelAttribute("personAttribute") Person person) { logger.debug("Received request to edit existing person"); // Assign id person.setId(personId); // Delegate to service personService.edit(person); // Redirect to url return "redirect:/krams/main/record/list"; } }
Notice the getRecords() method maps the Person and CreditCard records to a data transfer object: PersonDTO
/** * Retrieves the "Records" page */ @RequestMapping(value = "/list", method = RequestMethod.GET) public String getRecords(Model model) { logger.debug("Received request to show records page"); // Retrieve all persons List<Person> persons = personService.getAll(); // Prepare model object List<PersonDTO> personsDTO = new ArrayList<PersonDTO>(); for (Person person: persons) { // Create new data transfer object PersonDTO dto = new PersonDTO(); dto.setId(person.getId()); dto.setFirstName(person.getFirstName()); dto.setLastName(person.getLastName()); dto.setMoney(person.getMoney()); dto.setCreditCards(creditCardService.getAll(person.getId())); // Add to model list personsDTO.add(dto); } // Add to model model.addAttribute("persons", personsDTO); // This will resolve to /WEB-INF/jsp/records.jsp return "records"; }
PersonDTO acts as a data model for the records.jsp view.
PersonDTO.java
package org.krams.tutorial.dto; import java.util.List; import org.krams.tutorial.domain.CreditCard; /** * Data Transfer Object for displaying purposes */ public class PersonDTO { private Integer id; private String firstName; private String lastName; private Double money; private List<CreditCard> creditCards; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getLastName() { return lastName; } public void setLastName(String lastName) { this.lastName = lastName; } public Double getMoney() { return money; } public void setMoney(Double money) { this.money = money; } public List<CreditCard> getCreditCards() { return creditCards; } public void setCreditCards(List<CreditCard> creditCards) { this.creditCards = creditCards; } }
CreditCardController
CreditCardController is responsible for handling request for credit card records. We won't be using all methods available in this controller. They had been added for the sake of completeness.
CreditCardController.java
package org.krams.tutorial.controller; import javax.annotation.Resource; import org.apache.log4j.Logger; import org.krams.tutorial.domain.CreditCard; import org.krams.tutorial.service.CreditCardService; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.ModelAttribute; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RequestParam; /** * Handles credit card requests * * @author Krams at {@link http://krams915@blogspot.com */ @Controller @RequestMapping("/main/creditcard") public class CreditCardController { protected static Logger logger = Logger.getLogger("controller"); @Resource(name="creditCardService") private CreditCardService creditCardService; /** * Retrieves the "Add New Credit Card" page */ @RequestMapping(value = "/add", method = RequestMethod.GET) public String getAdd(@RequestParam("id") Integer personId, Model model) { logger.debug("Received request to show add page"); // Prepare model object CreditCard creditCard = new CreditCard(); // Add to model model.addAttribute("personId", personId); model.addAttribute("creditCardAttribute", creditCard); // This will resolve to /WEB-INF/jsp/add-credit-card.jsp return "add-credit-card"; } /** * Adds a new credit card */ @RequestMapping(value = "/add", method = RequestMethod.POST) public String postAdd(@RequestParam("id") Integer personId, @ModelAttribute("creditCardAttribute") CreditCard creditCard) { logger.debug("Received request to add new credit card"); // Delegate to service creditCardService.add(personId, creditCard); // Redirect to url return "redirect:/krams/main/record/list"; } /** * Deletes a credit card */ @RequestMapping(value = "/delete", method = RequestMethod.GET) public String getDelete(@RequestParam("id") Integer creditCardId) { logger.debug("Received request to delete credit card"); // Delegate to service creditCardService.delete(creditCardId); // Redirect to url return "redirect:/krams/main/record/list"; } /** * Retrieves the "Edit Existing Credit Card" page */ @RequestMapping(value = "/edit", method = RequestMethod.GET) public String getEdit(@RequestParam("pid") Integer personId, @RequestParam("cid") Integer creditCardId, Model model) { logger.debug("Received request to show edit page"); // Retrieve credit card by id CreditCard existingCreditCard = creditCardService.get(creditCardId); // Add to model model.addAttribute("personId", personId); model.addAttribute("creditCardAttribute", existingCreditCard); // This will resolve to /WEB-INF/jsp/edit-credit-card.jsp return "edit-credit-card"; } /** * Edits an existing credit card */ @RequestMapping(value = "/edit", method = RequestMethod.POST) public String postEdit(@RequestParam("id") Integer creditCardId, @ModelAttribute("creditCardAttribute") CreditCard creditCard) { logger.debug("Received request to add new credit card"); // Assign id creditCard.setId(creditCardId); // Delegate to service creditCardService.edit(creditCard); // Redirect to url return "redirect:/krams/main/record/list"; } }
View Layer
After discussing the Domain, Service, and Controller layers, we'll now turn our focus to the View layer. Our views are primarily composed of JSP pages. Here are the JSPs:Show all records
records.jsp
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Insert title here</title> </head> <body> <h1>Records</h1> <c:url var="editImgUrl" value="/resources/img/edit.png" /> <c:url var="deleteImgUrl" value="/resources/img/delete.png" /> <c:url var="addUrl" value="/krams/main/record/add" /> <table style="border: 1px solid; width: 100%; text-align:center"> <thead style="background:#d3dce3"> <tr> <th>Id</th> <th>First Name</th> <th>Last Name</th> <th>Money</th> <th colspan="2"></th> <th>CC Type</th> <th>CC Number</th> <th colspan="3"></th> </tr> </thead> <tbody style="background:#ccc"> <c:forEach items="${persons}" var="person"> <c:url var="editUrl" value="/krams/main/record/edit?id=${person.id}" /> <c:url var="deleteUrl" value="/krams/main/record/delete?id=${person.id}" /> <c:if test="${!empty person.creditCards}"> <c:forEach items="${person.creditCards}" var="creditCard"> <tr> <td><c:out value="${person.id}" /></td> <td><c:out value="${person.firstName}" /></td> <td><c:out value="${person.lastName}" /></td> <td><c:out value="${person.money}" /></td> <td><a href="${editUrl}"><img src="${editImgUrl}"></img></a></td> <td><a href="${deleteUrl}"><img src="${deleteImgUrl}"></img></a></td> <td><c:out value="${creditCard.type}" /></td> <td><c:out value="${creditCard.number}" /></td> <c:url var="addCcUrl" value="/krams/main/creditcard/add?id=${person.id}" /> <c:url var="editCcUrl" value="/krams/main/creditcard/edit?pid=${person.id}&cid=${creditCard.id}" /> <c:url var="deleteCcUrl" value="/krams/main/creditcard/delete?id=${creditCard.id}" /> <td><a href="${addCcUrl}">+</a></td> <td><a href="${editCcUrl}"><img src="${editImgUrl}"></img></a></td> <td><a href="${deleteCcUrl}"><img src="${deleteImgUrl}"></img></a></td> </tr> </c:forEach> </c:if> <c:if test="${empty person.creditCards}"> <tr> <td><c:out value="${person.id}" /></td> <td><c:out value="${person.firstName}" /></td> <td><c:out value="${person.lastName}" /></td> <td><c:out value="${person.money}" /></td> <td><a href="${editUrl}"><img src="${editImgUrl}"></img></a></td> <td><a href="${deleteUrl}"><img src="${deleteImgUrl}"></img></a></td> <td>N/A</td> <td>N/A</td> <c:url var="addCcUrl" value="/krams/main/creditcard/add?id=${person.id}" /> <td><a href="${addCcUrl}">+</a></td> <td></td> <td></td> </tr> </c:if> </c:forEach> </tbody> </table> <c:if test="${empty persons}"> No records found. </c:if> <p><a href="${addUrl}">Create new record</a></p> </body> </html>
Add new record
add-record.jsp
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <%@ taglib uri="http://www.springframework.org/tags/form" prefix="form" %> <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Insert title here</title> </head> <body> <h1>Create New Record</h1> <c:url var="saveUrl" value="/krams/main/record/add" /> <form:form modelAttribute="personAttribute" method="POST" action="${saveUrl}"> <table> <tr> <td><form:label path="firstName">First Name:</form:label></td> <td><form:input path="firstName"/></td> </tr> <tr> <td><form:label path="lastName">Last Name</form:label></td> <td><form:input path="lastName"/></td> </tr> <tr> <td><form:label path="money">Money</form:label></td> <td><form:input path="money"/></td> </tr> </table> <input type="submit" value="Save" /> </form:form> </body> </html>
Edit existing record
edit-record.jsp
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <%@ taglib uri="http://www.springframework.org/tags/form" prefix="form" %> <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Insert title here</title> </head> <body> <h1>Edit Existing Record</h1> <c:url var="saveUrl" value="/krams/main/record/edit?id=${personAttribute.id}" /> <form:form modelAttribute="personAttribute" method="POST" action="${saveUrl}"> <table> <tr> <td><form:label path="id">Id:</form:label></td> <td><form:input path="id" disabled="true"/></td> </tr> <tr> <td><form:label path="firstName">First Name:</form:label></td> <td><form:input path="firstName"/></td> </tr> <tr> <td><form:label path="lastName">Last Name</form:label></td> <td><form:input path="lastName"/></td> </tr> <tr> <td><form:label path="money">Money</form:label></td> <td><form:input path="money"/></td> </tr> </table> <input type="submit" value="Save" /> </form:form> </body> </html>
Add new credit card
add-credit-card.jsp
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <%@ taglib uri="http://www.springframework.org/tags/form" prefix="form" %> <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Insert title here</title> </head> <body> <h1>Add New Credit Card</h1> <c:url var="saveUrl" value="/krams/main/creditcard/add?id=${personId}" /> <form:form modelAttribute="creditCardAttribute" method="POST" action="${saveUrl}"> <table> <tr> <td>Person Id:</td> <td><input type="text" value="${personId}" disabled="true"/> </tr> <tr> <td><form:label path="type">Type:</form:label></td> <td><form:input path="type"/></td> </tr> <tr> <td><form:label path="number">Number:</form:label></td> <td><form:input path="number"/></td> </tr> </table> <input type="submit" value="Save" /> </form:form> </body> </html>
Edit existing credit card
edit-credit-card.jsp
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <%@ taglib uri="http://www.springframework.org/tags/form" prefix="form" %> <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Insert title here</title> </head> <body> <h1>Edit Existing Credit Card</h1> <c:url var="saveUrl" value="/krams/main/creditcard/edit?id=${creditCardAttribute.id}" /> <form:form modelAttribute="creditCardAttribute" method="POST" action="${saveUrl}"> <table> <tr> <td>Person Id:</td> <td><input type="text" value="${personId}" disabled="true"/> </tr> <tr> <td><form:label path="type">Type:</form:label></td> <td><form:input path="type"/></td> </tr> <tr> <td><form:label path="number">Number:</form:label></td> <td><form:input path="number"/></td> </tr> </table> <input type="submit" value="Save" /> </form:form> </body> </html>
Configuration
We have completed the necessary Java classes. Our next step is to declare the necessary configuration files:web.xml
<?xml version="1.0" encoding="UTF-8"?> <web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <servlet> <servlet-name>spring</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>spring</servlet-name> <url-pattern>/krams/*</url-pattern> </servlet-mapping> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> </web-app>
spring-servlet.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <!-- Declare a view resolver --> <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver" p:prefix="/WEB-INF/jsp/" p:suffix=".jsp" /> </beans>
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"> <!-- Activates various annotations to be detected in bean classes --> <context:annotation-config /> <!-- Scans the classpath for annotated components that will be auto-registered as Spring beans. For example @Controller and @Service. Make sure to set the correct base-package--> <context:component-scan base-package="org.krams.tutorial" /> <!-- Configures the annotation-driven Spring MVC Controller programming model. Note that, with Spring 3.0, this tag works in Servlet MVC only! --> <mvc:annotation-driven /> <!-- Load Hibernate related configuration --> <import resource="hibernate-context.xml" /> </beans>
hibernate-context.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd "> <context:property-placeholder location="/WEB-INF/spring.properties" /> <!-- Enable annotation style of managing transactions --> <tx:annotation-driven transaction-manager="transactionManager" /> <!-- Declare the Hibernate SessionFactory for retrieving Hibernate sessions --> <!-- See http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/orm/hibernate3/annotation/AnnotationSessionFactoryBean.html --> <!-- See http://docs.jboss.org/hibernate/stable/core/api/index.html?org/hibernate/SessionFactory.html --> <!-- See http://docs.jboss.org/hibernate/stable/core/api/index.html?org/hibernate/Session.html --> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean" p:dataSource-ref="dataSource" p:configLocation="${hibernate.config}" p:packagesToScan="org.krams.tutorial"/> <!-- Declare a datasource that has pooling capabilities--> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close" p:driverClass="${app.jdbc.driverClassName}" p:jdbcUrl="${app.jdbc.url}" p:user="${app.jdbc.username}" p:password="${app.jdbc.password}" p:acquireIncrement="5" p:idleConnectionTestPeriod="60" p:maxPoolSize="100" p:maxStatements="50" p:minPoolSize="10" /> <!-- Declare a transaction manager--> <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager" p:sessionFactory-ref="sessionFactory" /> </beans>
hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <!-- We're using MySQL database so the dialect needs to MySQL as well--> <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property> <!-- Enable this to see the SQL statements in the logs--> <property name="show_sql">true</property> <!-- This will drop our existing database and re-create a new one. Existing data will be deleted! --> <property name="hbm2ddl.auto">create</property> </session-factory> </hibernate-configuration>
spring.properties
# database properties app.jdbc.driverClassName=com.mysql.jdbc.Driver app.jdbc.url=jdbc:mysql://localhost/mydatabase app.jdbc.username=root app.jdbc.password= #hibernate properties hibernate.config=/WEB-INF/hibernate.cfg.xml
Run the Application
Setup the database
Our application uses MySQL as its database. To run the application, make sure to setup the database first.To create the database, follow these steps.
1. Open phpmyadmin (or any tool you prefer with)
2. Create a new database named mydatabase
3. Run the application to automatically create the database schema.
To populate the database with sample data, import the mydatabase.sql SQL script which is located under the WEB-INF folder of the application:
Access the main application
To access the main application, use the following URL:http://localhost:8080/spring-hibernate-one-to-many-default/krams/main/record/list
You should see the following application:
Conclusion
That's it. We've successfully created a Spring MVC application and implemented a one-to-many association in Hibernate using annotations. We've also discussed issues and solutions when using default settings of @OneToMany annotation.Download the project
You can access the project site at Google's Project Hosting at http://code.google.com/p/spring-mvc-hibernate-annotations-integration-tutorial/
You can download the project as a Maven build. Look for the spring-hibernate-one-to-many-default.zip in the Download sections.
You can run the project directly using an embedded server via Maven.
For Tomcat: mvn tomcat:run
For Jetty: mvn jetty:run
If you want to learn more about Spring MVC and integration with other technologies, feel free to read my other tutorials in the Tutorials section.
Share the joy:
|
Subscribe by reader Subscribe by email Share
Thanks for you sharing your knowledge. Keep posting more. Thanks
ReplyDeleteThanks for all
ReplyDeleteI'm glad I found these tutorials; they are very helpful. I thank you very much.
ReplyDeletegr8 work
ReplyDeleteThis blog is very clear,organized,well-explained, and complete. Thanks a lot. I hope more people will find this site. This one gives a lot of enlightenment to coding technology confusions. Godbless to the everyone who contributed.^_^
ReplyDeleteGood blog, thanks for these tutorials, but HOW TO TEST THIS PROJECT with JUNIT ?
ReplyDeleteUse JUnit as you would normally do when testing POJO classes. Your difficulty will come when you need to access services that connect to the db. You have two ways to handle that. 1. You can mock the objects, i.e use Mockito. 2. Use Spring's testing support which will allow you to rollback anything you do with the db.
ReplyDeleteThe rollback does not work wisely even with Spring
DeleteAreg
will you please add Bulk/Batch Insertion,Updation and Deletion operation in this same example..
Deletewill you please add Bulk/Batch Insertion,Updation and Deletion operation in this same example..
DeleteHello I'm a newbee and thank you for the answer about the test.
ReplyDeleteI'm french, sorry for my english.
But how to test a controller ? Can you give us an example please ?
Thanks for all
Very good articles not only for beginners but also for experienced professions. I thank you for writing such a great articles. When I download and run the one to many relationship example , it does not work when on maven tomcat:run . The following details has been displayed on tomcat:run command
ReplyDeleteNov 24, 2011 6:31:21 AM org.apache.catalina.core.StandardContext start
SEVERE: Error listenerStart
Nov 24, 2011 6:31:21 AM org.apache.catalina.core.StandardContext start
SEVERE: Context [/spring-hibernate-jpa-one-to-many-default] startup failed due t
o previous errors
Nov 24, 2011 6:31:21 AM org.apache.catalina.core.ApplicationContext log
INFO: Closing Spring root WebApplicationContext
Nov 24, 2011 6:31:21 AM org.apache.catalina.loader.WebappClassLoader clearRefere
ncesJdbc
SEVERE: The web application [/spring-hibernate-jpa-one-to-many-default] register
ed the JBDC driver [com.mysql.jdbc.Driver] but failed to unregister it when the
web application was stopped. To prevent a memory leak, the JDBC Driver has been
forcibly unregistered.
So please check and correct this problem
HAMID Sorry for my english, See the spring.properties file with correct parameters, and verify your jar file for mysql.
ReplyDeleteWhy isn't there a CreditcardDTO referenced by PersonDTO?
ReplyDelete@Anonymous, there is already the CreditCard.
ReplyDeleteGreat
ReplyDeleteI'm really grateful for these tutorials, they have been extremely helpful to my work!
ReplyDeleteIts very very very useful document. Thank you so much.
ReplyDeleteIf only I had found this yesterday...
ReplyDeleteWell done. I appreciate your work.
very good explanation..my doubt is why there is no DAO classes in your tutorial. Space constraint in blog or any specific reason.
ReplyDeleteI have simialar thread in my blog have a look
ReplyDeletehttp://fundapass.blogspot.in/2012/09/hibernate-one-to-many-mapping.html
thnx for posting this kind of application.i wil tell you one thing why u r not taken any Dao &DaoImpl ,directly taken in the Controller class.
ReplyDeleteThank you! Your tutorials help so much! Hello from Ukraine!
ReplyDeleteThank you so much for this tutorial! i've searched for longtime!
ReplyDeleteHi Krams! I want to send values to both the tables using single jsp.
ReplyDeleteBut in this example two are used. Please suggest me how to do it??
Thanks in Advance
i am not able to run the project ,resource not found
ReplyDeletenice article ...
ReplyDeleteMany thanks, friend! Great job!
ReplyDeletegood job mate !
ReplyDeletethanks for article can you give me how to write junit in this project
ReplyDeletethanks for your great work!
ReplyDeletewhat if Single form contains data of different table, if so how to save it(for one to one relationship) plz reply
ReplyDeletey r u not deleting person_credit table when deleting from person table
ReplyDeleteA ton of thanks!
ReplyDeleteVery good example. So nice the way you make understand everything. Keep it continue. Thanks a lot.
ReplyDeletei need without maveen Project buddy......
ReplyDeleteThis comment has been removed by the author.
ReplyDeleteyour add method not working fine it's not update a record it's create a new record. change save() to saveOrupdate(). now it's work fine getting ur desire O/P.
ReplyDeleteHow can i insert both person and creditcard from one jsp.
ReplyDeleteHTTP Status 404 - /spring-hibernate-one-to-many-jointable/
ReplyDeletefacing this problem
how do i set spring properties in web/inf folder
ReplyDeletethank you very much for this article. this really very helpful to me.
ReplyDeleteError creating bean with name 'creditCardService': Injection of persistence dependencies failed;
ReplyDeletecan any one help me
This comment has been removed by the author.
ReplyDelete
ReplyDeleteGood Post! Thank you so much for sharing this pretty post, it was so good to read and useful to improve my knowledge as updated one about Spring Framework, keep blogging
Java training in chennai | Java training in annanagar | Java training in omr | Java training in porur | Java training in tambaram | Java training in velachery
Effective blog with a lot of information. I just Shared you the link below for Courses .They really provide good level of training and Placement,I just Had Spring Classes in this institute , Just Check This Link You can get it more information about the Spring course.
ReplyDeleteJava training in chennai | Java training in annanagar | Java training in omr | Java training in porur | Java training in tambaram | Java training in velachery
Mua vé máy bay tại Aivivu, tham khảo
ReplyDeletevé máy bay đi Mỹ bao nhiêu tiền
đặt vé máy bay giá rẻ từ mỹ về việt nam
Vé máy bay từ Nhật Bản về Việt Nam
ve may bay tu canada ve viet nam
kd shoes
ReplyDeleteoff white
jordan 4
golden goose outlet
nike sb
yeezy
goyard bag
bape hoodie outlet
bape outlet
bape sta