Lecture 9 - Java Persistence, JPA 2

Java Persistence, JPA 2

Fahad R. Golra

ECE Paris Ecole d'Ingénieurs - FRANCE

Lecture 8 - Java Persistence, JPA 2

• Introduction to Persistence • Entity Beans • Life cycle of Entity Beans • Associations • Entity Beans: Query Language

2 JEE - Java Persistence, JPA 2.x

Introduction to Entity Beans

• Entity Bean • Persistent objects stored in the database

• Persistence • by serialization • by object - relational database mapping

• Serialization • Saving the state of an object in the form of bytes • An object can be reconstructed once serialized • No complex queries, hard to maintain


Persistence by mapping objects to relational databases

• State of the object is store in a database • For example: a book object has the attributes

names and isbn. We map them to a table which has two columns: name and isbn.

• Every object is decomposed into multiple variables, and their values are then stored in one or more tables.

• Allows complex queries

• SQL is hard to test/debug


Persistence by mapping objects to relational databases

5

Object Databases

• Object databases (also known as object-oriented database management systems) can store the objects directly to databases.

• No mapping !!!

• Object Query Language (OQL) can be used to manipulate objects

• Easy to use, but not scalable.


Persistence through JPA 2

• JPA 2 proposes a standard model of persistence through the use of Entity Beans

• Tools that ensure this persistence are integrated with the application servers and must be compatible to JPA 2 standard • e.g. Toplink, Hibernate, EclipseLink

• Java EE permits the use of dependency injection through annotations on all the layers.


What is an Entity Bean?

• An object that is mapped to a database • It uses the persistence mechanisms

• It serves to represent the data placed in the database as objects • An object = one or more rows in one or more tables

in the database

• Example • A student entity is represented by a row of data in

student table of a database


Why an Entity Bean?

• Easy to manipulate by programs • Instance of Account entity

• A compact view of grouped data in an object • Account object gives access to all public variables

• Associating methods to manipulate the data • methods can be written to add behavior to Account

• The data in the database will be updated automatically

• Instance of an entity bean is a view in memory of physical data


Entity Bean

• Entity Bean is a POJO with attributes, getters & setters. • These attributes are mapped to database tables

• We use annotations to define the mapping to attributes • Primary Key, is a serializable object • Attributes of annotations to customize the mapping


Persistent Fields and Properties

• Java primitive types

• java.lang.String

• Other serializable types, including:

• Wrappers of Java primitive types

• java.math.BigInteger

• java.math.BigDecimal

• java.util.Date

• java.util.Calendar

• java.sql.Date

• java.sql.Time

11

• java.sql.TimeStamp

• User-defined serializable types

• byte[]

• Byte[]

• char[]

• Character[]

• Enumerated types

• Other entities and/or collections of entities

• Embeddable classes

Example: Entity Bean (Book)

@Entitypublic class Book implements Serializable {

private static final long serialVersionUID = 1L;@Id@GeneratedValueprivate Long id;@Column(nullable = false)private String title;private Float price;@Column(length = 2000)private String description;private String isbn;private Integer nbOfPage;private Boolean illustrations;

// Constructors, getters, setters}

12

Example Entity Bean: Book


Entity Manager

• We manipulate the data in the database with the help of Entity Beans and a Entity Manager

• Entity Manager is responsible of access the disks, caches, etc.

• Entity Manager controls when and how we can access the database.

• It generates the SQL.


Example: Client (Inserting a Book)

public class BookHandler {public static void main(String[] args) {

Book book = new Book();book.setTitle("The Hitchhiker's Guide to the Galaxy");book.setPrice(12.5F);book.setDescription("Science fiction comedy book”);// set other fields as well . . . // Get a pointer to entity manager. We don't need to do this in web app!EntityManagerFactory emf = Persistence

.createEntityManagerFactory("chapter02PU");EntityManager em = emf.createEntityManager();

// Persisting the object in a transactionEntityTransaction tx = em.getTransaction();tx.begin();em.persist(book);tx.commit();

em.close();emf.close();

}}15

Session Bean as a Client

• In such a case • Dependency injection can be used • Transactions are started by default

@Stateless@LocalBeanpublic class MySessionBean {

EntityManager em;public Employee createEmployee(int id, String name, long salary) {

Employee emp = new Employee(id);emp.setName(name);…..em.persist(emp);return emp;

}}


Session Bean as a Client

17

@Statelesspublic class BookBean {

@PersistenceContext(unitName = "bookLib")private EntityManager em;

public void createBook() {Book book = new Book();book.setId(1234L);book.setTitle("The Alpha Book");book.setPrice(13.5F);book.setDescription("Description of my book");book.setIsbn("1-465-65465");book.setNbOfPage(230);book.setIllustrations(false);

em.persist(book);

book = em.find(Book.class, 1234L);

System.out.println(book);}}

Why use session beans?

• They are used to implement the business logic

• A session bean can be used to implement Data Access Object (DAO) • DAO offers the functions of creation, searching,

modification and deletion of entity beans.

• Session beans can also be used to implement composite services.


Other Annotations

@Entitypublic class Book implements Serializable {

@Id@GeneratedValue(strategy = GenerationType.AUTO)private Long id;@Column(name = "book_title", nullable = false, updatable = false)private String title;private Float price;@Column(length = 2000)private String description;private String isbn;@Column(name = "nb_of_page", nullable = false)private Integer nbOfPage;@Basic(fetch = FetchType.LAZY)@Lobprivate Boolean illustrations;

// Constructors, getters, setters}

19

Other Annotations

• @Column • allows the preferences for columns • Attributes: name, unique, nullable, insertable,

updatable, length, ….

• @Generated Value • indicates the strategy for the automatic generation

of primary keys • It depends on the database being used, so

automatic is recommended


Other Annotations

• @Lob • indicates “large object” for a BLOB • Often used with @Basic(fetch=FetchType.LAZY) for

indicating that we want this attribute to be loaded only when a get is used on it.

• There are many other annotations. • Java EE 7 specification can be consulted for it.


Example: Persistence.xml

<?xml version="1.0" encoding="UTF-8"?><persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0">

<persistence-unit name="JPA_first"><provider>oracle.toplink.essentials.PersistenceProvider</provider><class>com.ece.jee.entities.Client</class>

<properties><property name="toplink.jdbc.driver" value="com.mysql.jdbc.Driver" /

><property name="toplink.jdbc.url" value="jdbc:mysql://localhost:

3306/ece_db" /><property name="toplink.jdbc.user" value="root" /><property name="toplink.jdbc.password" value="secret" /><property name="toplink.target-database" value="MySQL4" /><property name="toplink.ddl-generation" value="drop-and-create-

tables" /><property name="toplink.ddl-generation.output-mode" value="both" /><property name="toplink.logging.level" value="FINE" />

</properties></persistence-unit>

</persistence>22

Persistence Context

• A persistence context is a set of entity instances in which for every persistent entity identity there is a unique entity instance.

• The entity instances and their lifecycle are managed within the persistence context.

• The EntityManager API is used to create and remove persistent entity instances, to find entities by their primary keys, and to query over entities.


Life cycle of Entity Bean



• New: The bean exists in the memory but is not mapped to DB yet. It is not yet mapped to persistence context (via entity manager)

• Managed: The bean is mapped to the DB. The changes effect the data in DB.

• Detached: The bean is not mapped to the persistence context anymore.

• Removed: The bean is still mapped to the persistence context and the DB, but it is programmed to be deleted.



• remove(): To delete the data

• set(), get(): If the bean is in managed state, these methods (of the entity bean) are used to access or modify the data.

• persist(): To create the data. The bean goes to managed state.

• merge(): To take a bean from detached state to a managed state.


Entity Manager example methods

public Account openAccount(String ownerName) {Account account = new Account();account.ownerNamer = ownerName;em.persist(account); // attach the bean & persistreturn account; // copy is detached

}

public void update(Account detachedAccount) {Account managedAccount = em.merge(detachedAccount);

}

public void delete(Account detachedAccount) {Account managedAccount = em.merge(detachedAccount);em.remove(managedAccount);

}

public void findAccount(int id) {return em.find(Account.class, Integer.valueOf(id));

}

27

Entity Manager (other principal methods)

Object find(Class cl, Object key) : • Find an EntityBean by its id

boolean contains(Object entity) : • True if the entity is attached to the EntityManager

Query createQuery(String sqlString) : • Creating a query in EJB-QL

Query createNamedQuery(String name) : • Creating a named query

Query createNativeQuery(String sqlQuery) : • Creating an SQL query

void refresh(Object entity) : • Recharging the bean from the DB


Using composite columns

• Fields of two classes into one table

@Embeddablepublic class Address {

private String street;private int postalCode;

}

@Entitypublic class User {

private String name;@Embeddedprivate Address address;

}

29

Composite Primary Key

• Instead of using @Embedded we use @EmbeddedId for composite primary keys

@Embeddablepublic class CompositeId {

private String name;private String email;

}

@Entitypublic class Dependent {

@EmbeddedIdCompositeId id;@ManyToOneEmployee emp;

}

30

Associations

• Cardinality • 1 - 1 (one to one): one employee has one address • 1 - n (one to many): one employee has multiple addresses • n - 1 (many to one): multiple employees have one address • n - n (many to many): multiple employees have multiple

addresses

• Direction (navigability) • Unidirectional:

• we can go from bean A to bean B only • Bi-directional:

• we can go from bean A to bean B & vice-versa


Unidirectional: OneToOne

• Employee entity -> ︎Employee table

• Address entity -> ︎Address table with address_Id as PK • Employee table owns a foreign key to Address, address

@Entitypublic class Employee {

private Address address;@OneToOnepublic Address getAddress() {

return address;}public void setAddress(Address ad) {

this.address = ad;}

}

32

@Entitypublic class Address {…}

Employee Address1 1

adress

Unidirectional: ManyToOne


• Address entity -> ︎Address table with address_Id as PK • Employee table owns a foreign key to Address, address


private Address address;@ManyToOnepublic Address getAddress() {

return address;}public void setAddress(Address ad) {

this.address = ad;}

}

33


Employee Address0..* 1

adress

Unidirectional: OneToMany


• Address entity -> ︎Address table with address_Id as PK • Creation of a join table Employee_Address with two columns (i.e.

Employee_Pkemployee & Address_PKAddress, each column represents a PK to each table


private Collection<Address> addresses;@OneToManypublic Collection<Address> getAddresses() {

return addresses;}public void setAddresses(Collection<Address> addresses) {

this.addresses = addresses;}

}34


Employee Address1 0..*

adresses

Unidirectional: ManyToMany


• Address entity -> ︎Address table with address_Id as PK • Creation of a join table Employee_Address with two columns (i.e.

Employee_Pkemployee & Address_PKAddress, each column represents a PK to each table


private Collection<Address> addresses;@ManyToManypublic Collection<Address> getAddresses() {

return addresses;}public void setAddresses(Collection<Address> addresses) {

this.addresses = addresses;}

}35


Employee Address0..* 0..*

adresses

Bi-directional: OneToOne


• Cashier entity -> ︎Cashier table with myCashier_Id as PK • Employee table owns a foreign key to Cashier, myCashier

(note: Cashier will not have a foreign key to Employee)

36

@Entitypublic class Cashier {

private Employee myEmployee;@OneToOne(mappedBy = "myCashier")public Employee getMyEmployee() {

return myEmployee;}public void setMyEmploye(Employee e) {

this.myEmployee = e;}

}


private Cashier myCashier;@OneToOnepublic Cashier getMyCashier() {

return myCashier;}public void setMyCashier(Cashier c) {

this.myCashier = c;}

}

Employee Cashier1 1

myCashiermyEmployee

Bi-directional: ManyToOne/OneToMany


• Cashier entity -> ︎Cashier table with myCashier_Id as PK • Employee table owns a foreign key to Cashier, myCashier

(note: Cashier will not have a foreign key to Employee)

37

@Entitypublic class Cashier {

private Collection<Employee> myEmployees;@OneToMany(mappedBy = "myCashier")public Collection<Employee>

getMyEmployees() {return myEmployees;

}public void

setMyEmployees(Collection<Employee> e) {this.myEmployees = e;

}}


private Cashier myCashier;@ManyToOnepublic Cashier getMyCashier() {

return myCashier;}public void setMyCashier(Cashier c) {

this.myCashier = c;}

}

Employee Cashier0..* 1

myCashiermyEmployees

Bi-directional: ManyToMany


• Cashier entity -> ︎Cashier table

• Creation of a join table Project_Employee with two columns (i.e. myProjects_PKProject & myEmployees_PkEmployee, each column represents a PK to each table

38


private Collection<Project> myProjects;@ManyToMany(mappedBy = "myEmployees")public Collection<Project> getMyProjets()

{return myProjects;

}public void

setMyProjets(Collection<Project> p) {this.myProjects = p;

}}

@Entitypublic class Project {

Collection<Employee> myEmployees;@ManyToManypublic Collection<Employee>

getMesEmployees() {return myEmployees;

}public void

setMesEmployes(Collection<Employee> e) {this.myEmployees = e;

}}

Project Employee0..* 0..*

myEmployeesmyProjects

Entity Bean Inheritance

• Entities support inheritance and polymorphism

• Entities may be concrete or abstract @Entitypublic abstract class Person {@Idprotected String name; …

}

@Entitypublic class Employee extends Person {protected float salary; …

}


Inheritance Strategies

• One Table by classes hierarchy (Default) : @Inheritance(strategy=SINGLE_TABLE)

• Implemented in most tooling solutions • Good support of polymorphism • Columns proper to sub-classes set at null

• One Table by concrete class: @Inheritance(strategy=TABLE_PER_CLASS)

• Some issues remain regarding polymorphism • Join Strategy: • @Inheritance(strategy=JOINED)

• a join between the concrete class and the super class tables • Good support of polymorphism • Not always implemented • Join operation can be costly


Entity Bean Inheritance

• An Entity can inherit a non-entity class and vice-versa • MappedSuperClasses are not accessible to EntityManager

• Not considered as Entity (no table in DB) @MappedSuperclasspublic abstract class Person {

protected Date dob;}

@Entitypublic class Employee extends Person {

@Idprotected int id;protected String name;

}


Entity Bean Compliments

• Fetch: option for loading the graph of objects • FetchType.EAGER : loads all the tree (required if Serializable) ︎ • FetchType.LAZY : only on demand (unusable with Serializable)

• Cascade: transitivity of operations over the beans • CascadeType.ALL: every operation is propagated • CascadeType.MERGE: in case of a merge • CascadeType.PERSIST: When film Entity becomes

persistent, then List<Cinema> too • CascadeType.REFRESH: loading from the DB • ︎CascadeType.REMOVE: delete in cascade


Entity Beans: Query Language

• parameters indicated by :param-name • Request in Query object • Result from Query object

• getResultList() • getSingleResult()


Entity Beans: Named Query

• Named query can be attached to the Entity Bean


Entity Beans: Native Query

• SQL queries can be used using • createNativeQuery(String sqlString) • createNativeQuery(String sqlString, Class resultClass)


Entity Beans: Life cycle interceptors

• Interception of state changes

• Around the creation (em.persist) : ︎ • @PrePersist • @PostPersist

• At loading time from DB (em.find, Query.getResultList) • @PostLoad

• Around updates (modification of a field, em.merge) ︎ • @PreUpdate • @PostUpdate

• Around a remove action (em.remove) ︎ • @PreRemove • @PostRemove

46

References

• Some of the slide contents are take from the slides of • Reda Bendraou, UPMC • Michel Buffa, UNSA


Lecture 9 - Java Persistence, JPA 2

Software

Transcript of Lecture 9 - Java Persistence, JPA 2