Overview of JPA (Java Persistence API) v2.0

Rochester JUG: 11-Oct-2011

Bryan Basham – Overview of JPA v2.0 Slide 1

© Copyright 2011, Software Alchemy

Overview of JPA v2.0(Java Persistence API)

Bryan BashamSoftware Alchemy

[email protected]

http://www.linkedin.com/in/SoftwareAlchemist

Containers &Deployment

QueryLanguage

EntityOperations

Entities

In Practice

Overviewof JPA v2.0

mailto:[email protected]

http://www.linkedin.com/in/softwarealchemist




History

● Java v1.1 (1997) included JDBC● J2EE v1.2 (1999) introduced EJB Entity beans● Entity beans sucked, so others did it better

– iBATIS (2001)– Hibernate (2001)– JDO (JSR 12, final in 2002)

● JPA v1.0 (JSR 220) was released in 2006● JPA v2.0 (JSR 317) was released in 2009




Who Needs a Standard?

● JPA provides a flexible standard● Multiple, competing implementations

– DataNucleus – EclipseLink – Hibernate – ObjectDB – OpenJPA

http://en.wikipedia.org/wiki/DataNucleus

http://en.wikipedia.org/wiki/EclipseLink

http://en.wikipedia.org/wiki/Hibernate_(Java)

http://en.wikipedia.org/wiki/ObjectDB

http://en.wikipedia.org/wiki/OpenJPA




Typical Architecture #1

The Java Virtual Machine

Java Lang / JRE JDK

JPA

EclipseLink OpenJPA

Your Standalone Application

Spring(optional)

Hibernate(plus optional libs)




Typical Architecture #2

The Java Virtual Machine

Java Lang / JRE JDK

JPA

Your Enterprise Application

Spring(optional)

Hibernate(plus optional libs)

Java EE(servlets, JSP, JSF, EJB, JNDI, etc.)




Entities


QueryLanguage

EntityOperationsIn Practice

Overviewof JPA v2.0

RelationshipsKeys

Beans &Properties

Inheritance

DB MappingsEntities




Entity Classes

● Any POJO, but should be a Java Bean● Class must not be final; nor methods or

persistence instance variables● May be Serializable and be passed across

remote calls, such as RMI● Entities may exist in a class hierarchy● Queries may be polymorphic




Entity Classes: Example

import javax.persistence.Basic;import javax.persistence.Entity;

@Entity /** Not fully baked */public class Employee {

@Basic(optional=false) private String firstName; @Basic(optional=false) private String lastName; @Basic(optional=false) private Integer age;

public String getFirstName() { return firstName; } public void setFirstName(String name) { this.firstName = name; }

public String getLastName() { return lastName; } public void setLastName(String name) { this.lastName = name; }

public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; }

}

«entity»Employee

firstName : StringlastName : Stringage : Integer




Access Types

● Access to DB fields can be on instance variables or properties

● You can specific the access type with an annotation:

@Entity@Access(AccessType.PROPERTY)public class Employee { /* entity code */ }

● If no access type is defined, then the default type (by usage) applies to the whole entity class hierarchy




Entity Classes: Example #2

// assume all necessary imports from now on

@Entity@Access(AccessType.PROPERTY)public class Employee {

private String _firstName; private String _lastName; private Integer _age;

@Basic(optional=false) public String getFirstName() { return _firstName; } public void setFirstName(String name) { this._firstName = name; }

@Basic(optional=false) public String getLastName() { return _lastName; } public void setLastName(String name) { this._lastName = name; }

@Basic(optional=false) public Integer getAge() { return _age; } public void setAge(Integer age) { this._age = age; }




Data Types

● A property data type can be:– any Java primitive– any Java primitive wrapper– Strings– Dates– Big integer and decimals– Byte arrays (for BLOBs)– Character arrays (for CLOBs)– Enum values




Enum Types

@Entitypublic class Employee {

public enum Gender { MALE, FEMALE }

@Basic(optional = false) private Gender gender;

@Basic(optional=false) private String firstName;

@Basic(optional=false) private String lastName;

@Basic(optional=false) private Integer age;

«entity»Employee

gender : GenderfirstName : StringlastName : Stringage : Integer

«enumeratedType»Gender

+MALE+FEMALE

Enum ordinal




Derived Properties




@Basic(optional=false) private Date dateOfBirth;

@Transient private Integer age;

public Integer getAge() { if ( this.age == null ) { this.age = DateUtils.dateDiffYears(new Date(), this.dateOfBirth); } return age; }

«entity»Employee

firstName : StringlastName : StringdateOfBirth : Date#age : Integer




Embeddable Properties

● Useful for representing small, non-entity classes

● Thus supports DDD Value Object concepts (well, almost)

● Also supports Composition without the need for cascading deletes (fields are embedded within the owning entity table)

● One Embeddable can embed other Embeddables




Embeddable Properties (2)

@Embeddablepublic class PhoneNumber {

@Basic(optional=false) private String areaCode; // unfortunately, can't make these final @Basic(optional=false) private String localNumber; @Basic(optional=true) private String extension;

public PhoneNumber() { /* no-arg ctor for JPA */ } public PhoneNumber(String areaCode, String localNumber, String extension) { this.areaCode = areaCode; this.localNumber = localNumber; this.extension = extension; }

public String getAreaCode() { return areaCode; } public String getLocalNumber() { return localNumber; } public String getExtension() { return extension; }}





«entity»Employee

firstName : StringlastName : StringdateOfBirth : Date#age : IntegerofficePhone : PhoneNumber

«valueObject»PhoneNumber

areaCode : StringlocalNumber : Stringextension : String

officePhone

1


@Embedded private PhoneNumber officePhone;

Fields of the Embeddableare embedded directly intothe table of the owning Entity.






@Embedded @ElementCollection(fetch = FetchType.LAZY) private Map<String,PhoneNumber> phones = new HashMap<String,PhoneNumber>();

Due to the one-to-manythe embeddables are storedin a separate table.

«entity»Employee

firstName : StringlastName : StringdateOfBirth : Date#age : Integerphones : Map<String, PhoneNumber>



1type

Entity FK Map key




Entity Keys

● Every entity must have a primary key● Key is specified with the @Id annotation● Only one key defined for a given entity class

hierarchy● Keys can be simple or composite● Simple key (or properties of a composite key)

must have a simple data type:– Strings, Java primitives (or wrappers), dates, or

big numbers




Entity Keys: Example


@Id @Basic(optional=false) // SSN must be unique (not a good choice) private String SSN;





«entity»Employee

SSN : StringfirstName : StringlastName : StringdateOfBirth : Date#age : Integer




Entity Keys: Example #2


@Id @GeneratedValue // let the DBMS assign the key on insert private Long id;





«entity»Employee

id : LongfirstName : StringlastName : StringdateOfBirth : Date#age : Integer

MySQL uses autoincrementfor key generation.




Associations

● Entities can be associated to other Entities and Embeddable objects

● Collections (bags), sets, sorted sets, lists, and even maps

● One-to-one, one-to-many, many-to-one, and many-to-many

● Uni- and bi-directional relationships● Lazy and Eager fetching techniques




One-to-One

@Entitypublic class User {

@Id @GeneratedValue private Long id; @Basic(optional=false) private String userName; @Basic(optional=false) private String password;

@Basic(optional=false) @OneToOne(fetch=FetchType.EAGER) private Employee employee;

employee

1«entity»User

id : LonguserName : Stringpassword : Stringemployee : Employee

1 «entity»Employee





One-to-One (2)

private void createExampleUser() { Calendar cal = Calendar.getInstance(); try { em.getTransaction().begin();

Employee emp = new Employee(); emp.setGender(Gender.MALE); emp.setFirstName("Bryan"); emp.setLastName("Basham"); cal.set(1964, 7, 22); emp.setDateOfBirth(cal.getTime()); em.persist(emp); // NOTE: need to persist all entities User u1 = new User(); u1.setUserName("bbasham"); u1.setPassword("guess"); u1.setEmployee(emp); em.persist(u1);

em.getTransaction().commit(); } catch (Exception e) { e.printStackTrace(); em.getTransaction().rollback(); }}




One-to-Many

@Entitypublic class Department {

@Id @GeneratedValue private Long id;

@Basic(optional = false) private String name;

@OneToMany(fetch = FetchType.LAZY) private Set<Employee> staff;

staff

0..*«entity»Department

id : Longname : Stringstaff : Set<Employee>

1 «entity»Employee





Many-to-Many

team

0..*«entity»Project

id : Longname : Stringteam : Set<Employee>

0..* «entity»Employee

id : LongfirstName : StringlastName : StringdateOfBirth : Date#age : Integerprojects : Set<Project>

projects




Many-to-Many (2)



// Skipping basic properties

@ManyToMany(fetch = FetchType.LAZY, mappedTo=”team”) private Set<Project> projects;

@Entitypublic class Project {


@Basic(optional = false) private String name;

@ManyToMany(fetch = FetchType.LAZY) private Set<Employee> team;

The mappedTo valuespecifies that the Project entityis the “owner” of the relationship.




Many-to-Many (3)

Project FK Employee FK




Inheritance

● JPA supports flexible Entity inheritance● A Entity may be an abstract class● An Entity class can extend a non-Entity class● A non-Entity class can extend an Entity class● Queries can be written to any Entity classes● Three DB mapping strategies:

– SINGLE_TABLE (the default)– JOINED – TABLE_PER_CLASS (not required per spec)




Inheritance Example

team11

team21

«entity»Team

game1

1

game2

1

«entity»IntermediateGame

game1 : AbstractGamegame2 : AbstractGame

«entity»StartingTeam

team1 : Teamteam2 : Team

«entity»AbstractGame

id : Longteam1Score : intteam2Score : int

getTeam1() : TeamgetTeam2() : TeamgetWinner() : Team




Single Table Example

@Entity@Inheritance(strategy=InheritanceType.SINGLE_TABLE)@DiscriminatorColumn( name="game_type" )public abstract class AbstractGame { @Id @GeneratedValue private Long id; @Basic(optional=false) private Integer team1Score; @Basic(optional=false) private Integer team2Score;

@Entity@DiscriminatorValue("SG")public class StartingGame extends AbstractGame { @Basic(optional=false) private Team team1; @Basic(optional=false) private Team team2;

@Entity@DiscriminatorValue("IG")public class IntermediateGame extends AbstractGame { @Basic(optional=false) private AbstractGame game1; @Basic(optional=false) private AbstractGame game2;




Single Table Example (2)AbstractGame IntermediateGame

discriminatorfield

StartingGame




Joined Example

@Entity@Inheritance(strategy=InheritanceType.JOINED)public abstract class AbstractGame { @Id @GeneratedValue private Long id; @Basic(optional=false) private Integer team1Score; @Basic(optional=false) private Integer team2Score;

@Entitypublic class StartingGame extends AbstractGame { @Basic(optional=false) private Team team1; @Basic(optional=false) private Team team2;

@Entitypublic class IntermediateGame extends AbstractGame { @Basic(optional=false) private AbstractGame game1; @Basic(optional=false) private AbstractGame game2;




Joined Example (2)IntermediateGame

StartingGame

AbstractGame




Database Mappings

● JPA implementations like Hibernate can dynamically create a DB schema for RAD

● But if you have an existing schema, then you can use annotations to map:

– Entity classes to tables– Entity properties to fields– Join columns of relationships– ...and more




Domain Model Example

«entity»Employee

firstName : StringlastName : StringdateOfBirth : Date#age : Integerphones : Map<>projects : Set<Project>user : Userdepartment : Department



1type

team0..*

«entity»Project

id : Longname : Stringteam : Set<Employee>

0..* projects

staff0..*

«entity»Department

id : Longname : Stringstaff : Set<Employee>

employee

1«entity»User

id : LonguserName : Stringpassword : Stringemployee : Employee

1

department1




ER Diagram«table»USR

SID : BIGINT(20)NAME : VARCHAR(32)PW : VARCHAR(16)EMP_SID : NUMBER(20)

«table»DEPT

SID : BIGINT(20)NAME : VARCHAR(64)

«table»EMP

SID : BIGINT(20)FNAME : VARCHAR(100)LNAME : VARCHAR(100)DOB : DATETIMEGEN_CODE : VARCHAR(6)

«table»PRJ

SID : BIGINT(20)NAME : VARCHAR(64)

«table»PRJ_EMP

PRJ_SID : BIGINT(20)EMP_SID : BIGINT(20)

«table»EMP_PHONE

EMP_SID : BIGINT(20)TYPE : VARCHAR(7)AREA_CODE : CHAR(3)NUMBER : CHAR(4)EXT : CHAR(3)




Basic DB Mappings

@Entity@Table(name="EMP")public class Employee {

@Id @GeneratedValue @Column(name="SID") private Long id;

@Basic(optional = false) @Column(name="GEN_CODE", length=6) @Enumerated(value=EnumType.STRING) private Gender gender;

@Basic(optional=false) @Column(name="FNAME", length=100) private String firstName;

@Basic(optional=false) @Column(name="LNAME", length=100) private String lastName;




Relationship Mappings

@Entity@Table(name="USR")public class User {

@Id @GeneratedValue @Column(name="SID") private Long id

@Basic(optional = false) @Column(name="NAME", length=32, unique=true) private String userName;

@Basic(optional = false) @Column(name="PW", length=16) private String password;

@Basic(optional = false) @OneToOne(fetch = FetchType.EAGER, cascade={CascadeType.ALL}) @JoinColumn(name="EMP_SID") private Employee employee;




Relationship Mappings (2)

@Entity@Table(name = "PRJ")public class Project {

@Id @GeneratedValue @Column(name = "SID") private Long id;

@Basic(optional = false) @Column(name = "NAME", length=64) private String name;

@ManyToMany(fetch = FetchType.EAGER) @JoinTable(name = "PRJ_EMP", joinColumns = { @JoinColumn(name = "PRJ_SID", referencedColumnName = "SID") }, inverseJoinColumns = { @JoinColumn(name = "EMP_SID", referencedColumnName = "SID") }) private Set<Employee> team = new HashSet<Employee>();




Embeddable Mappings

@Entity@Table(name="EMP")public class Employee { @Embedded @ElementCollection(fetch = FetchType.LAZY) @CollectionTable(name="EMP_PHONE", joinColumns={ @JoinColumn(name="EMP_SID", referencedColumnName="SID") }) @MapKeyColumn(name="PHONE_TYPE") private Map<String, PhoneNumber> phones = new HashMap<String, PhoneNumber>();

@Embeddablepublic class PhoneNumber { @Column(name="AREA_CODE", length=3) private String areaCode; @Column(name="NUMBER", length=7) private String localNumber; @Column(name="AREA_CODE", length=3, nullable=true) private String areaCode;





QueryLanguage

In Practice

CRUD OpsEntityManager

Other operations

EntityOperations

RelationshipsKeys

Beans &Properties

Inheritance

DB MappingsEntities

Overviewof JPA v2.0

Entity Operations




Entity Manager

«class»Persistence

{from javax.persistence}

createEntityManager- Factory(String puName) : EMF

META-INF/persistence.xml

....

..

.....

....

«interface»EntityManagerFactory{from javax.persistence}

createEntityManager() : EM

«interface»EntityManager

{from javax.persistence}

persist(entity:Object) : voidfind(eCls:Class<T>, key:Object) : Tmerge(entity:T) : Tremove(entity:Object)




CRUD Operations

● Create:– Just create an Entity POJO with no id– Call em.persist(entity); JPA populates id

● Retrieve:– Employee emp = em.find(Employee.class, 47L);

● Update:– Create POJO with id; call em.merge(entity)

● Delete:– Create POJO with id; call em.remove(entity)




Persisting Relationships

● By default, you must persist all parts by hand– Remember our example:

// Make and persist an employeeEmployee emp = new Employee(); // setters skippedem.persist(emp);// Make and persist a userUser user = new User(); // setters skippeduser.setEmployee(emp);em.persist(user);

● You can tell JPA to persist parts with many relationship annotations




Cascading Operations@Entitypublic class User {

@Id @GeneratedValue private Long id; @Basic(optional=false) private String userName; @Basic(optional=false) private String password;

@Basic(optional=false) @OneToOne(fetch=FetchType.EAGER , cascade={CascadeType.ALL}) private Employee employee;

private void createExampleUser() { em.getTransaction().begin(); // Make an employee Employee emp = new Employee(); // setters skipped // Make a user User user = new User(); // setters skipped user.setEmployee(emp); // Persist the User and the Employee is automatically saved em.persist(user);




Other EM Operations

● flush()

– Saves EM context state to DB● detach(entity)

– Detaches an Entity from EM context● refresh(entity)

– Refreshes the Entity state from the DB● getReference(id):T

– Retrieves a lazy Entity from the DB





In Practice

UPDATE &DELETE

SELECT

Joins

SELECT Clause

Expressions

QueryParameters

QueryLanguage

RelationshipsKeys

Beans &Properties


Other operations

EntityOperations

Inheritance

DB MappingsEntities

Overviewof JPA v2.0

Query Language




SELECT Statements

● Like SQL SELECT statements; except it selects a whole Entity object

● Examples:– SELECT e FROM Employee AS e – SELECT e FROM Employee AS e

JOIN e.projects p WHERE p.name = 'Cobia'

● Code:String statement = "SELECT e FROM Employee AS e";TypedQuery<Employee> query = em.createQuery(statement, Employee.class);List<Employee> list = query.getResultList();




Query Parameters

● Supports JDBC-like indexed parameters:private List<Employee> queryTeam(Project project) { String statement = "SELECT e FROM Employee AS e JOIN e.projects p WHERE p.name=?"; TypedQuery<Employee> query = em.createQuery(statement, Employee.class); query.setParameter(1, project.getName()); return query.getResultList();}

● Also supports named parameters:private List<Employee> queryTeam(Project project) { String statement = "SELECT e FROM Employee AS e JOIN e.projects p WHERE p.name=:PRJ"; TypedQuery<Employee> query = em.createQuery(statement, Employee.class); query.setParameter("PRJ", project.getName()); return query.getResultList();}




Conditional Expressions

● Literals● Functions● Basic Operators● Collection Operators● Path expressions




Literals

● Strings: 'string' and 'string''s'● Boolean: TRUE and FALSE● Numbers: both Java and SQL literals● Dates: {d '2011-10-11'}

– This syntax is handled by the JDBC provider– The JPA provider is not required to mediate

● Enums: org.basham.TestJPA.entities.Gender.MALE – Probably best to just pass in as a parameter




Functions

● Strings: CONCAT, SUBSTRING, TRIM, UPPER, LOWER, LENGTH, LOCATE

● Numeric: ABS, SQRT, MOD, SIZE(collection), INDEX(item in a List)

● Temporal: CURRENT_DATE, CURRENT_TIME, and CURRENT_TIMESTAMP

● CASE statement● Entity Type: TYPE(game) = StartingGame




Basic Operators

● Comparison: <, <=, =, <>, >, >=● Arithmetic: +, -, *, /● Logical: NOT, AND, and OR● Between: x [NOT] BETWEEN y AND z● String matching: x [NOT] LIKE 'B%' ● Null check: x IS [NOT] NULL




Collection Operators

● Fixed membership:– a [NOT] IN (x, y, z, ...)

● Empty:– collection IS [NOT] EMPTY

● Flexible membership:– entity [NOT] MEMBER [OF] collection

private List<Employee> queryTeam(Project project) { String st = "SELECT e FROM Employee e WHERE :PRJ MEMBER OF e.projects"; TypedQuery<Employee> query = em.createQuery(st, Employee.class); query.setParameter("PRJ", project); return query.getResultList();}




Path Expressions

● Allows simple object navigation– OneToOne and ManyToOne relationships– Single Embedded properties (no collections)

● Examples:– How many Employees with short passwords?

SELECT count(e) FROM Employee e WHERE LENGTH(e.user.password) <= 4

– How many Employees with office phones in Rochester?

SELECT count(e) FROM Employee e WHERE e.officePhone.areaCode = '585'




Joins

● Like SQL joins; natural for relationship traversal● Support for outer join● Support for so-called “FETCH JOIN” which

allows the query to specify a Lazy relationship to be pre-fetched.




Join Examples

● Get Employees for a specific project and gender:

SELECT e FROM Employee AS e JOIN e.projects p WHERE p.name=:N AND e.gender=:SEX

● Get Projects with team members from a specific Department:

SELECT p FROM Project p JOIN p.team emp JOIN emp.department dept WHERE dept.name=:DEPT




SELECT Clause

● Select Entity objects (most of what we've seen)– The result is an Entity object

● Select specific attributes (like SQL)– The result is an Object[] result

● Select aggregations (like SQL)– May use a GROUP BY clause

● May construct new Entities from a query● May use DISTINCT; like in SQL




Aggregation Example

● Department stats: # of Emps and youngest age private void queryEmployeeStatsByDept(Department dept) { String statement = "SELECT COUNT(e), MAX(e.dateOfBirth) FROM Employee e JOIN e.department dept WHERE dept.name=:DEPT"; Query query = em.createQuery(statement); query.setParameter("DEPT", dept.getName()); Object[] tuple = (Object[]) query.getSingleResult(); Long numOfEmps = (Long) tuple[0]; Date minDOB = (Date) tuple[1]; System.out.println(String.format("There %d employees in the %s department with the youngest age of %d years.", numOfEmps, dept.getName(), DateUtils.dateDiffYears(new Date(), minDOB))); }

There 5 employees in the IT department with the youngest age of 20 years.




GROUP BY Example

● List # of Emps by Department and Genderprivate void queryDepartmentStats() { String statement = "SELECT dept.name, emp.gender, COUNT(emp) FROM Employee emp JOIN emp.department dept GROUP BY dept.name, emp.gender"; Query query = em.createQuery(statement); List<Object[]> list = (List<Object[]>) query.getResultList(); System.out.println("Department stats:"); for ( Object[] tuple : list ) { String deptName = (String) tuple[0]; Gender gender = (Gender) tuple[1]; Long numOfEmps = (Long) tuple[2]; System.out.println("\t" + deptName + " & " + gender.name() + " : " + numOfEmps + " employees"); }}

Department stats: Exec & FEMALE : 1 employees Exec & MALE : 5 employees HR & FEMALE : 1 employees HR & MALE : 6 employees ... and so on ...




UPDATE and DELETE

● JPA also allows bulk updates and deletes● Syntax:

– UPDATE Entity AS e SET e.prop1=val1, e.prop2=val2, ... WHERE e.property = ?

– DELETE FROM Entity AS e WHERE e.property = ?




UPDATE Example

private void resetPasswordsByDept(Department dept, String newPW) { try { em.getTransaction().begin();

String statement = "UPDATE User u SET u.password=? WHERE u.employee.id IN (SELECT e.id FROM Employee e WHERE e.department=?)"; Query query = em.createQuery(statement); query.setParameter(1, newPW); query.setParameter(2, dept); int howMany = query.executeUpdate(); System.out.println(String.format("%d user's passwords reset for %s", howMany, dept));

em.getTransaction().commit(); } catch (Exception e) { e.printStackTrace(); em.getTransaction().rollback(); } }




In Practice

Packaging PersistenceUnit


RelationshipsKeys

Beans &Properties


Other operations

EntityOperations

Inheritance

DB MappingsEntities

UPDATE &DELETE

SELECT

Joins

SELECT Clause

Expressions

QueryParameters

QueryLanguage

Overviewof JPA v2.0

Containers & Deployment




Persistence Unit

● JPA's configuration– Configuration of the persistence provider, such

as Hibernate– Set of entity classes; and what to exclude– Mapping configuration; if not provided by Entity

class annotations● Lives in the persistence.xml file

– Typically in the META-INF directory of a JAR– Or in the WEB-INF/classes directory of a WAR

Persistence Unit (2)

<?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_2_0.xsd" version="2.0">

<persistence-unit name="unit1" transaction-type="RESOURCE_LOCAL">  </persistence-unit>

<persistence-unit name="unit2" transaction-type="RESOURCE_LOCAL">  </persistence-unit> </persistence>

// code...EntityManagerFactory emf = Persistence.createEntityManagerFactory("unit1");EntityManager em = emf.createEntityManager();em.persist(entity);

http://java.sun.com/xml/ns/persistence

http://www.w3.org/2001/XMLSchema-instance

http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd




Persistence Unit (3)

<persistence ...>

<persistence-unit name="unit1" transaction-type="RESOURCE_LOCAL"> <provider>org.hibernate.ejb.HibernatePersistence</provider> <class>org.basham.TestJPA.mappings.Employee</class> <class>org.basham.TestJPA.mappings.User</class> <class>org.basham.TestJPA.mappings.Department</class> <class>org.basham.TestJPA.mappings.Project</class> <exclude-unlisted-classes /> <properties> <property name="hibernate.hbm2ddl.auto" value="create-drop" /> <property name="hibernate.show_sql" value="true" /> <property name="hibernate.cache.provider_class" value="org.hibernate.cache.HashtableCacheProvider" /> <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect" /> <property name="hibernate.connection.url" value="jdbc:mysql://localhost:8889/TestJPA_mappings" /> <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" /> <property name="hibernate.connection.password" value="root" /> <property name="hibernate.connection.username" value="root" /> </properties> </persistence-unit> </persistence>

PersistenceProvider

configuration

EntityClasses




Packaging a Standalone App

TestJPA.jar

mysql-connector-java-5.1.5.jar

hibernate-entitymanager-3.6.7-Final.jar

hibernate-jpa-2.0-api.jar

jta-1.1.jar

JSR-305.jar

Several other JARs

META-INF/persistence.xml

....

..

.....

....




Building a Standalone w/ Maven

● If you just build a standalone JAR for your app– You must include all of the external JARs by

hand in the classpath during execution– Plus all of their dependencies (this gets complex)

● Or you can use Maven– To manage the transitive dependencies– And build a single executable JAR

Standalone App POM

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>org.basham</groupId> <artifactId>TestJPA</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging>

<repositories> <repository> <id>repository.jboss.org</id> <name>Public JBoss Repository Group</name> <url>https://repository.jboss.org/nexus/content/groups/public-jboss/</url> <layout>default</layout> </repository> </repositories>





</project>

http://www.w3.org/2001/XMLSchema-instance

http://maven.apache.org/xsd/maven-4.0.0.xsd

https://repository.jboss.org/nexus/content/groups/public-jboss/

Standalone App POM (2)

<project ...>

 <build> <plugins> <plugin> <artifactId>maven-assembly-plugin</artifactId> <configuration> <archive> <manifest> <mainClass>org.basham.TestJPA.app.Main</mainClass> </manifest> </archive> <descriptorRefs> <descriptorRef>jar-with-dependencies</descriptorRef> </descriptorRefs> </configuration> </plugin>  </plugins> </build>

</project>

Standalone App POM (3)

<project ...>

 <dependencies> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-entitymanager</artifactId> <version>3.6.7.Final</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.12</version> <scope>runtime</scope> </dependency>  </dependencies>

</project>




Packing a Web App

MyWebApp.war

mysql-connector-java-5.1.5.jar

hibernate-entitymanager-3.6.7-Final.jar

WEB-INF/lib

hibernate-jpa-2.0-api.jar

jta-1.1.jar

JSR-305.jar

Several other JARs

persistence.xml

....

..

.....

....

META-INF/




Building a Web App

● Packing in a webapp is easier because all of the external JARs are placed in WEB-INF/lib

● Again, using Maven makes this really easy




Partialloading

Paging &Ordering

Open ViewPattern

Locking

Caching

In Practice

RelationshipsKeys

Beans &Properties


Other operations

EntityOperations

Paging &Ordering

Inheritance

DB MappingsEntities

UPDATE &DELETE

SELECT

Joins

SELECT Clause

Expressions

QueryParameters

QueryLanguage



Overviewof JPA v2.0

In Practice




Paging and Ordering

● The following example demonstrates the use of paging, searching, and ordering in a real app

● This webapp, UserMgr, uses the following stack:

– GWT and GXT (ExtJS widgets in GWT)– Spring– JPA and Spring DAO utilities– MySQL




UserMgr: Users Table

Table filtered byUserType and Last Name

Ordered bySelected Column




UserMgr: Users Table (2)

Table supports Paging




UserMgr: User Query Stack

MySQL«DAO»

UserDao

«helper»JpaDaoSupport

{from org.spgfrm.orm.jpa.support}

«GWT»UserGrid

«RPC»UserRpc

«service»UserSvc

«valueObject»QueryRequest

start : intpageSize : intsortField : “String”sortDir : {ASC, DESC}

«valueObject»PagedQueryResult

totalCount : intitems : List<T>

T=UserThe UserGrid component on thebrowser sends the request for anew page of Users via the GWTRPC async service which is notshown here.

Server-side code

«create»«create»




UserMgr: UserDaoImpl

public PagedQueryResult<User> retrieveUsers(final UserType userType, final QueryRequest requestInfo) { // Count the number of Users in this user type int totalCount = getJdbcTemplate().queryForInt( "SELECT count(*) FROM user WHERE user_type_id = ?", new Object[] { userType.getId() });

// Create the dynamic query (set the ORDER BY field) String sortField = requestInfo.getSortField(); SortDir sortDir = requestInfo.getSortDirection(); final String queryString = String.format( "SELECT u FROM User u" + " WHERE u.userType = ? and u.deleted = false " + " ORDER BY u.%s %s", // eg) " ORDER BY u.lastName ASC" sortField, sortDir.name());

// Perform the query // SEE NEXT SLIDE

return new PagedQueryResult<User>(totalCount, users); }

Order-bycriteria

Pagingresults




UserMgr: UserDaoImpl (2)

public PagedQueryResult<User> retrieveUsers(final UserType userType, final QueryRequest requestInfo) { final String queryString = // SEE PREVIOUS SLIDE

// Perform the query List<User> users = (List<User>) getJpaTemplate().executeFind( new JpaCallback() { public Object doInJpa(EntityManager em) throws PersistenceException { Query query = em.createQuery(queryString); query.setParameter(1, userType); query.setMaxResults(requestInfo.getPageSize()); query.setFirstResult(requestInfo.getStart()); return query.getResultList(); } });

return new PagedQueryResult<User>(totalCount, users); }

Pagingcriteria




Partial Loading

● Associations can have a FetchType of either:– LAZY : Fetch when requested (aka “lazy loaded”)

● One-to-Many● Many-to-Many

– Or EAGER : Fetch when Entity is retrieved● One-to-One● Many-to-One

● Properties can also be lazy loaded– Default is eager




Partial Loading Poor Example

@Entity@Table(name="USR_TYP")public class UserType {


@Column(name="NAME", length=32, unique=true) private String name;

@OneToMany(fetch = FetchType.EAGER) private Set<User> users;

«entity»UserType

users «entity»User

1..*

type

1

What's wrong withthis relationship?

It depends...




Partial Loading Solution

● In the situation where there could be thousands of Users per UserType:

– Remove the bi-directional association– Provide a Service tier method to query the Users

by type, possibly with paging and filtering

«entity»UserType

«entity»User

type

1

«service»UserTypeService

getUsers(Long typeId) : Set<User>// better yet use// paging & filtering




Partial Loading Example

@Entity@Table(name="USR")public class User {


@Basic(optional = false) @Column(name="NAME", length=32, unique=true) private String userName;

@Basic(optional = false , fetch = FetchType.LAZY) @Column(name="PW", length=16) private String password;

@Basic(optional = false) @OneToOne(fetch = FetchType.LAZY) @JoinColumn(name="EMP_SID") private Employee employee;

Don't want to exposethe user's passwordto the GUI.

Also, the GUI rarelyneeds access to theEmployee record.




«DAO»UserDao

«GWT»UserGrid

«RPC»UserRpc

«service»UserSvc

Typical transaction boundary

«entity»User

«create»

The User object is “managed”within a transactional boundary.Outside that boundary the entitybecomes “detached”.

«entity»User

u.getEmployee().getAge()

But outside of the txn boundaryaccess to the associatedEmployee object fails:LazyInitializationException

Partial Loading Example (2)




Open Session in View Pattern

«DAO»UserDao

«GWT»UserGrid

«RPC»UserRpc

«service»UserSvc

Transaction boundary

«entity»User

u.getEmployee().getAge()

«filter»Open

EntityManagerInViewFilter

● One solution is to move the transaction boundary up the stack (say in Servlet filter):




Optimistic Locking

● Assumed, but code support must be injected● The @Version annotation is used to flag an

Entity attribute as the “version attribute”– @Version long version – @Version Date versionStamp

● An OptimisticLockException is thrown when one session attempts to update the entity after another session has already done so




Pessimistic Locking

● Can lock an individual entity:User user = em.find(User.class, 47L);em.lock(user, LockModeType.PESSIMISTIC_WRITE);// OR simply:User user = em.find(User.class, 47L, LockModeType.PESSIMISTIC_WRITE);

● Can lock all entities returned by a query:String statement = // some limited queryTypedQuery<User> query = em.createQuery(statement, User.class);query.setLockMode(LockModeType.PESSIMISTIC_READ);List<User> users = query.getResultList();




Caching

● The JPA spec supports the use of second-level caching by the persistence provider.

● The developer can mark Entity classes to be cached by the @Cacheable annotation.

● Similarly the developer can mark an Entity class to never be cached using: @Cacheable(false)




Caching Example

@Entity@Cacheable(true)public class Category {


private String title;

@ManyToOne private Category parent;

@Transient private Set<Category> children = new HashSet<Category>();

children0..*

parent

0..1«entity»Category

The Category entity representsa reflexive hierarchy that rarelychanges; thus is a good candidatefor caching.




Overviewof JPA v2.0

RelationshipsKeys

Beans &Properties


Other operations

EntityOperations

Partialloading

Paging &Ordering

Open ViewPattern

Locking

Caching

In Practice

Inheritance

DB MappingsEntities

UPDATE &DELETE

SELECT

Joins

SELECT Clause

Expressions

QueryParameters

QueryLanguage



Q & A




Ten Great Topics Not Covered1) Composite keys; great for mapping to an existing DB schema

2) Primary key generation; eg) hashes or UUID

3) Native SQL queries

4) GROUP BY and HAVING clauses

5) More nuances of Entity relationships

6) More nuances to DB mappings

7) Entity lifecycle events and listeners (could be used for data manipulation or auditing)

8) Bean validation

9) Programmatic query APIs

10) Metamodel APIs




Resources

● JPA v2.0– JSR 317 (click here)– Javadocs (click here)– Tutorials (click here)

● JPA Documentation– Wikipedia (click here)– Wikibooks (click here)

http://jcp.org/en/jsr/detail?id=317

http://download.oracle.com/javaee/6/api/index.html?javax/persistence/package-summary.html

http://download.oracle.com/javaee/6/tutorial/doc/bnbpy.html

http://en.wikipedia.org/wiki/Java_Persistence_API

http://en.wikibooks.org/wiki/Java_Persistence

Overview of JPA (Java Persistence API) v2.0

Software

Transcript of Overview of JPA (Java Persistence API) v2.0