- \n
- MySQL<\/li>\n
- MySQL Workbench<\/li>\n
- MySQL connector<\/li>\n
- Hibernate 3.6 or higher (earlier versions should be ok)<\/li>\n
- Eclipse (any recent verion)<\/li>\n
- log4j<\/li>\n<\/ul>\n
Directory and project setup<\/span><\/p>\n
Create a new project in eclipse (whatever name you like) and add the following jar files to the project<\/p>\n
<\/a><\/a>
![\"\"](\"http:\/\/www.alphastar.net.au\/blog\/wp-content\/uploads\/2011\/09\/jars2.jpg\" "\\"jars\\"")
<\/a><\/p>\nCreate a package for the model (alphastar.model). The POJOs will reside here.
\nCreate a package for the code (alphastar.main).\u00c2\u00a0\u00c2\u00a0The program logic goes here<\/p>\n<\/a><\/p>\n
<\/a><\/p>\n
In this small application, I will model a Stock-market portfolio.<\/p>\n
The following schema will apply:<\/p>\n
<\/a>
![\"\"](\"http:\/\/www.alphastar.net.au\/blog\/wp-content\/uploads\/2011\/09\/Diagram11.jpg\" "\\"Diagram1\\"")
<\/a><\/p>\nThis diagram specifies that a Person may own 1 or more stock codes (ie. unique stocks) and that each unique stock code may be owned by one or more\u00c2\u00a0Persons (lets consider this possibility even though it may not be 100% real world).\u00c2\u00a0Essentially we are modelling a many-to-many scenario here.<\/p>\n
Additionally, each stock code may have a number of stock “events” associated to it. By this I mean a buy or sell action performed on a stock. For instance, a buy for stock code ABC, buy\/sell on stock code XYZ. This is modelling a one-to-many scenario. One stock may have a number of purchasing events associated to it.<\/p>\n
Address is being modelled as a value type. A value type is always associated to it’s owning class and does not have an indentity outside of it’s owning class. In hibermate, value types are coalesced into the table of the owning class (they do not reside in a seperate table ).<\/p>\n
Hibernate has the concept of a persistence context. The persistence context knows the state of all objects within the transaction, and can automatically\u00c2\u00a0generate the correct update and insert statements based on the modifications made to objects. Objects that aren’t known to the persistence manager are known as transient (ie. when you create a new object). Also objects that are modified after a persistence context is closed are known as detached. When objects are in those 2 states, Hibernate does not know about them and there will be no database updates.<\/p>\n
<\/p>\n
Back to the application.<\/p>\n
First of all we want to create the Hibernate configuration file<\/p>\n
[code lang=”xml”]<\/p>\n
com.mysql.jdbc.Driver jdbc:mysql:\/\/localhost\/stocks root (pass) org.hibernate.dialect.HSQLDialect 1 org.hibernate.dialect.MySQLDialect thread org.hibernate.cache.NoCacheProvider true update true true<\/p>\n
[\/code]<\/p>\n
This is a pretty standard config file. The POJO classes that we have annotated are included in the mapping tag.<\/p>\n
Next we want to create a helper class that calls the Hibernate sessionFactory. This will instansiate a Hibernate session for us. Note that only one session from the factory is ever instansiated.
\nCreate a file called HibernateUtil.java and place it in the alphatar.main package\/directory.<\/p>\n[code lang=”java”]<\/p>\n
package alphastar.main;<\/p>\n
import org.hibernate.SessionFactory;
\nimport org.hibernate.cfg.Configuration;<\/p>\npublic class HibernateUtil {
\nprivate static final SessionFactory sessionFactory = buildSessionFactory();
\nprivate static SessionFactory buildSessionFactory() {
\ntry {
\nreturn new Configuration().configure().buildSessionFactory();
\n}
\ncatch (Throwable e) {
\nSystem.out.println(“Error:” + e);
\nthrow new ExceptionInInitializerError(e);
\n}
\n}
\npublic static SessionFactory getSessionFactory() {
\nreturn sessionFactory;
\n}
\n}<\/p>\n[\/code]<\/p>\n
POJO’s<\/strong><\/p>\n
There are a number of POJOs (Plain old Java Objects) that store data from the database.<\/p>\n
Person<\/span><\/p>\n
[code lang=”Java”]
\npackage alphastar.model;<\/p>\nimport java.util.HashSet;
\nimport java.util.Set;<\/p>\nimport javax.persistence.*;<\/p>\n
@Entity
\n@Table (name=”Person”)
\npublic class Person {<\/p>\nint personId;
\nprivate String name;
\nAddress address;<\/p>\nprivate Set stocksHeld = new HashSet();<\/p>\n
@Id
\n@GeneratedValue(strategy = GenerationType.AUTO)
\n@Column(name = “idperson”)
\npublic int getPersonId() {
\nreturn personId;
\n}
\npublic void setPersonId(int personId) {
\nthis.personId = personId;
\n}<\/p>\n@Column(name = “name”)
\npublic String getName() {
\nreturn name;
\n}
\npublic void setName(String name) {
\nthis.name = name;
\n}<\/p>\n@Embedded
\npublic Address getAddress() {
\nreturn address;
\n}
\npublic void setAddress(Address address) {
\nthis.address = address;
\n}<\/p>\n@ManyToMany
\n@JoinTable(
\nname=”PersonStockJoinTable”,
\njoinColumns = {@JoinColumn(name= “idperson”)},
\ninverseJoinColumns = {@JoinColumn(name = “idstock”)}
\n)
\n@org.hibernate.annotations.IndexColumn(name = “DISPLAY_POSITION”)
\npublic Set getStocksHeld() {
\nreturn stocksHeld;
\n}
\npublic void setStocksHeld(Set stocksHeld) {
\nthis.stocksHeld = stocksHeld;
\n}<\/p>\n\/\/ ASSOCIATION SETTERS
\npublic void addStock(Stock aStock) {
\nstocksHeld.add(aStock);
\n}
\n}<\/p>\n[\/code]<\/p>\n
As this is a many to many association, a 3rd intermediary table is needed to map foreign keys from either table. I have named this “PersonStockJoinTable”.<\/p>\n
Address is an embedded value-type. It is like a 1-1 association, except that it is completely dependant on the owning object and has no identity outside of the owning object (ie shared references aren’t possible). Also, as the data for Address is so closely associated with\u00c2\u00a0the Person object, the data for both are stored together in one table.<\/p>\n
Address<\/span>
\n[code lang=”Java”]
\npackage alphastar.model;<\/p>\nimport javax.persistence.Column;
\nimport javax.persistence.Embeddable;
\nimport javax.persistence.Table;<\/p>\n@Embeddable
\n@Table (name=”address”)
\npublic class Address {<\/p>\nprivate String addressLine1;
\nprivate String addressLine2;
\nint postCode;
\nString city;<\/p>\n@Column(name = “addressline1”, nullable=false)
\npublic String getAddressLine1() {
\nreturn addressLine1;
\n}
\npublic void setAddressLine1(String addressLine1) {
\nthis.addressLine1 = addressLine1;
\n}<\/p>\n@Column(name = “addressline2”, nullable=true)
\npublic String getAddressLine2() {
\nreturn addressLine2;
\n}
\npublic void setAddressLine2(String addressLine2) {
\nthis.addressLine2 = addressLine2;
\n}<\/p>\n@Column(name = “zipcode”, nullable=false)
\npublic int getPostCode() {
\nreturn postCode;
\n}
\npublic void setPostCode(int postCode) {
\nthis.postCode = postCode;
\n}<\/p>\n@Column(name = “city”, nullable=false)
\npublic String getCity() {
\nreturn city;
\n}
\npublic void setCity(String city) {
\nthis.city = city;
\n}<\/p>\n}<\/p>\n
[\/code]<\/p>\n
The Address value type, set as an embeddable object within Person<\/p>\n
Stock<\/span>
\n[code lang=”Java”]
\npackage alphastar.model;<\/p>\nimport java.util.HashSet;
\nimport java.util.Set;<\/p>\nimport javax.persistence.*;<\/p>\n
@Entity
\n@Table (name=”stock”)
\n\/\/@org.hibernate.annotations.AccessType(“field”)
\npublic class Stock {<\/p>\npublic int idstock;<\/p>\n
private Set stockEvents = new HashSet(0);<\/p>\n
public String code;<\/p>\n
public String name;<\/p>\n
public void addStockEvent(StockEvent se) {
\n\/\/ save associations to both ends
\nse.setStock(this);
\nstockEvents.add(se);
\n}<\/p>\nprivate Set
\npersons = new HashSet();<\/p>\n\/\/ ASSOCIATION SETTERS<\/p>\n
public void addPerson(Person aPerson) {
\npersons.add(aPerson);
\n}<\/p>\n\/\/ GETTERS<\/p>\n
@Id
\n@GeneratedValue(strategy = GenerationType.AUTO)
\n@Column(name = “idstock”)
\npublic int getIdstock() {
\nreturn idstock;
\n}<\/p>\n\/\/ when a parent is saved, so is its children
\n@OneToMany( cascade={CascadeType.PERSIST, CascadeType.MERGE}, mappedBy=”stock”)
\n@org.hibernate.annotations.Cascade({
\norg.hibernate.annotations.CascadeType.SAVE_UPDATE
\n})
\npublic Set getStockEvents() {
\nreturn stockEvents;
\n}<\/p>\n@Column(name = “code”)
\npublic String getCode() {
\nreturn code;
\n}<\/p>\n@Column(name = “name”)
\npublic String getName() {
\nreturn name;
\n}<\/p>\n@ManyToMany(mappedBy=”stocksHeld”)
\n\/*
\n@JoinTable(
\nname=”PersonStockJoinTable”,
\njoinColumns = {@JoinColumn(name= “idstock”)},
\ninverseJoinColumns = {@JoinColumn(name = “idperson”)}
\n)
\n@org.hibernate.annotations.IndexColumn(name = “DISPLAY_POSITION”)
\n*\/
\npublic Set
\ngetPersons() {
\nreturn persons;
\n}<\/p>\n\/\/ SETTERS<\/p>\n
public void setIdstock(int idstock) {
\nthis.idstock = idstock;
\n}<\/p>\npublic void setStockEvents(Set stockEvents) {
\nthis.stockEvents = stockEvents;
\n}<\/p>\npublic void setCode(String code) {
\nthis.code = code;
\n}<\/p>\npublic void setName(String name) {
\nthis.name = name;
\n}<\/p>\npublic void setPersons(Set
\npersons) {
\nthis.persons = persons;
\n}
\n}<\/p>\n[\/code]<\/p>\n
One thing to note, is that we use a mappedBy attribute to specify that this is the inverse part of the may-to-many relationship. This is due to an idiosnycracy with the way bi-directional associations work in Hibernate. If there are associations to both classes,\u00c2\u00a0Hibernate will try to add the same key twice in the join table. To counteract this, need to set one side as the inverse of the many-to-many by using mappedBy and specifying the variable. Basically it says these 2 things go\u00c2\u00a0together.<\/p>\n
If there was no bi-directional association in the code (i.e. Person referenced Stock only), the commented out code would work fine.<\/p>\n
StockEvent<\/span>
\n[code lang=”Java”]
\npackage alphastar.model;<\/p>\nimport java.math.BigDecimal;
\nimport javax.persistence.*;<\/p>\n@Entity
\n@Table(name=”stockevent”)
\npublic class StockEvent {<\/p>\npublic int idStockEvent;
\npublic Stock stock;
\npublic BigDecimal buyPrice;
\npublic java.util.Date buyDate;
\npublic BigDecimal soldPrice;
\npublic java.util.Date soldDate;<\/p>\n@Id
\n@GeneratedValue(strategy = GenerationType.AUTO)
\n@Column(name = “idstockevent”)
\npublic int getIdStockEvent() {
\nreturn idStockEvent;
\n}<\/p>\npublic void setIdStockEvent(int idStockEvent) {
\nthis.idStockEvent = idStockEvent;
\n}<\/p>\n@Column(name = “buyprice”)
\npublic BigDecimal getBuyPrice() {
\nreturn buyPrice;
\n}<\/p>\npublic void setBuyPrice(BigDecimal buyPrice) {
\nthis.buyPrice = buyPrice;
\n}<\/p>\n@Column(name = “buydate”)
\npublic java.util.Date getBuyDate() {
\nreturn buyDate;
\n}<\/p>\npublic void setBuyDate(java.util.Date buyDate) {
\nthis.buyDate = buyDate;
\n}<\/p>\n@Column(name = “soldprice”)
\npublic BigDecimal getSoldPrice() {
\nreturn soldPrice;
\n}<\/p>\npublic void setSoldPrice(BigDecimal soldPrice) {
\nthis.soldPrice = soldPrice;
\n}<\/p>\n@Column(name = “solddate”)
\npublic java.util.Date getSoldDate() {
\nreturn soldDate;
\n}<\/p>\npublic void setSoldDate(java.util.Date soldDate) {
\nthis.soldDate = soldDate;
\n}<\/p>\n@ManyToOne (targetEntity = alphastar.model.Stock.class)
\n@JoinColumn (name=”idstock”, nullable=false)
\npublic Stock getStock() {
\nreturn stock;
\n}
\npublic void setStock(Stock stk) {
\nstock = stk;
\n}
\n}<\/p>\n[\/code]<\/p>\n
Database<\/strong><\/p>\n
MySQL is the database vendor I am using for this project. Open MySQL Workbench and create a database called “stocks” and set it as the default database. Important note: We don’t need to create the database schema as Hibernate will create it automatically when we run the project! It will also choose the appropriate SQL database types based on the data types in the Java classes, which is very nice!<\/p>\n
These tables should have been created after you ran the project<\/p>\n
Project Layout<\/strong><\/p>\n
![<\/a>](\"http:\/\/www.alphastar.net.au\/wordpress\/wp-content\/uploads\/2011\/09\/jars1.jpg\"){kind=link}
![<\/a>](\"http:\/\/www.alphastar.net.au\/wordpress\/wp-content\/uploads\/2011\/09\/jars.jpg\"){kind=link}
![<\/a>](\"http:\/\/www.alphastar.net.au\/wordpress\/wp-content\/uploads\/2011\/09\/Diagram1.jpg\"){kind=link}