Table of Contents. I. Pre-Requisites A. Audience B. Pre-Requisites. II. Introduction A. The Problem B. Overview C. History

Size: px

Start display at page:

Download "Table of Contents. I. Pre-Requisites A. Audience B. Pre-Requisites. II. Introduction A. The Problem B. Overview C. History"

Britton Bradley
5 years ago
Views:

1 Table of Contents I. Pre-Requisites A. Audience B. Pre-Requisites II. Introduction A. The Problem B. Overview C. History II. JPA A. Introduction B. ORM Frameworks C. Dealing with JPA D. Conclusion III. Hibernate Tutorial A. Introduction B. Development Environment C. Hibernate.cfg.xml D. Creating A Table E. Add To A Table F. Transient Field G. Auto-Generate Primary Key H. Mapping Inheritance IV. Sources

2 Pre-Requisites This document will be discussing the JPA and the Hibernate implementation of JPA and is written for Java developers who are looking at persisting Java objects using a relational database. In order to have a good understanding of this document's content there will be a few pre-requisites that are necessary. Please read the following. 1. A high-level understanding of JAVA is highly recommended. This document will work with many basic JAVA terms and ideas that will not be taught. As a COM S student at Iowa State University, having taken COM S 228 would be adequate. 2. A basic-level understanding of Relational Databases is highly recommended. Having common knowledge and understanding basic terms of relational databases will ensure that the wording is not lost. There will be many relational database principles that will be assumed as common knowledge. 3. Please download the JAVA JDK. Here is a link for the download Please have Eclipse downloaded and installed on your computer. Here is a link for the download Please have some sort of database downloaded and installed on your computer. This document will be using Derby, here is a link for the download. db.apache.org/derby/releases/release cgi. 6. Please download the latest version of Hibernate. Here is a link for the download.

3 Introduction The Problem: JPA (Java Persistence API) and Hibernate together solve the problem of accessing, persisting, and managing data between JAVA objects/ classes and relational databases. It simplifies the process immensely, and provides a clear and fast way to persist objects. There are a plethora of problems when dealing with persisting objects to relational databases that JPA and Hibernate take care of. There are objects when working with JAVA, but there are not objects in relational databases, there are just columns of data. In order to map an object to a relational database, each object needs to be converted into a SQL query for saving, and another SQL query will be needed to retrieve an object from the relational database. This is not only a lot of code, but brings up problems that need handled by the programmer How to map member variables to columns? 2. How to map relationships between objects? 3. How to handle object data types (booleans)? 4. How to manage changes to object states?...the JPA & Hibernate solve these annoying problems for the developer, allowing them to use their time to code more valuable parts of their software. Overview: JPA is not a tool, but a specification. This is very important to realize right away. It is the latest standard in the industry as an approach for Object to Relational Mapping (ORM). Hibernate is an open-source ORM tool that implements the JPA. It is commonly used in industry and has copious amounts of support online. History: In the past, there have been many attempts to try and solve this problem. The first was the OMG persistence service JAVA binding, which did not succeed. Then there was EJB 1.0 CMP Entity Beans, which was very successful, but had a small loathing due to its complexity and overhead. Later came EJB 2.0, which tried reducing the complexity, but introduced new problems and overall not reducing complexity by much.

JPA Introduction: The Java Persistence API is a set of interfaces that created an accepted approach for ORM. JPA standardized the ORM persistence technology for JAVA developers in the industry.

4 JPA Introduction: The Java Persistence API is a set of interfaces that created an accepted approach for ORM. JPA standardized the ORM persistence technology for JAVA developers in the industry. The advantage of a standardized interface is that it creates an ORM framework independence, allowing compatibility between different ORM implementations. There are many frameworks that implement the JPA, including Hibernate, TopLink, and Open JPA. Later in this document, a tutorial on how to use Hibernate will be discussed. ORM Frameworks: When using JPA, there is basic knowledge that needs to be known. JPA is a specification, and not a product. In order to persist JAVA objects, an ORM implementation is needed. The flow chart below (fig. 1.1) shows the separation between your application, JPA, and the ORM framework. Dealing with JPA: There are two ways to deal with JPA, an XML file and with annotations. It is possible to mix the two, but the common trend is to centralize and not deal with both. In this document, we will be dealing with annotations and not XML. In order to implement a JPA-compliant program, there are three artifacts that are needed. 1. A no parameter constructor in your entity class 2. Annotations

5 3. A database to persist to Conclusion: JPA is a new standard that allows ORM Frameworks to persist objects to relational databases. Even though multiple ORM Frameworks are implementing JPA, it allows a very portable software due to the ORM Framework independence. In order to implement JPA, the entity class will need a default constructor (no parameters), annotations will need to be put in place to allow mapping of entities, and a database is needed to persist objects to.

6 Hibernate Tutorial Introduction: In this tutorial, Hibernate will be explained through concepts and step-by-step guides. It will go over creating a simple table, creating a schema, saving to a table, and much more. As we will see, Hibernate does a great job removing the complexity out of ORM, while keeping the overhead down. Development Environment: It is important to set-up the development environment correctly now, so problems do not arise in the future. This tutorial will be using Eclipse, Derby, and Hibernate. Please download and install all three (links provided in pre-requisite), and run the Derby database (bin/startnetworkserver.bat). Once that is complete, create a new database connection (window-> open perspective -> database development) and add a new database. To import all of the jar files, create a user library with all of the database and hibernate jar files. Once all of this is done, hibernate is ready! Hibernate.cfg.xml: The Hibernate configuration file is a configuration file that is put in the project's root directory and establishes the connection to the database (and more). This sets up the link between Hibernate and the database, allowing communication between the application and the database. Here is an example of a configuration file, fig Notice that there is a dedicated section for the "Database Connection Settings". This is where all of your database properties will be defined. Another important aspect of the configuration file, is the SQL dialect. Because Hibernate is talking to a Derby database,

Java EE Application Assembly & Deployment Packaging Applications, Java EE modules. Model View Controller (MVC)2 Architecture & Packaging EJB Module

Java EE Application Assembly & Deployment Packaging Applications, Java EE modules. Model View Controller (MVC)2 Architecture & Packaging EJB Module Java Platform, Enterprise Edition 5 (Java EE 5) Core Java EE Java EE 5 Platform Overview Java EE Platform Distributed Multi tiered Applications Java EE Web & Business Components Java EE Containers services