Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
The Java Persistence API ©SoftMoore Consulting Slide 1 The Java Persistence API • The Java Persistence API (JPA) is a Java programming language framework that allows developers to manage relational data in Java development environments. Provides a higher-level framework than JDBC for managing persistent objects • Background – originated within the Enterprise JavaBeans 3.0 (JSR 220) expert group, but a Java EE application server is not required – merged expertise from TopLink, Hibernate, JDO, EJB vendors, and individuals – first released in May 2006 as part of Java EE 5 ©SoftMoore Consulting Slide 2 JPA Implementations • GlassFish (Java EE application server) – reference implementation – called “TopLink Essentials” (derived from Oracle TopLink) – https://glassfish.dev.java.net/javaee5/persistence/ • • • Eclipse Persistence Services Project (EclipseLink) JBoss Hibernate Apache OpenJPA ©SoftMoore Consulting Slide 3 JPA Major Components • The API – defined in the javax.persistence package • The Java Persistence Query Language (JPQL) – used to make queries against entities stored in a relational database – resembles SQL but operates against entity objects rather than database tables • Object/Relational Metadata – can be specified directly in the entity class using annotations or in a separate XML descriptor file ©SoftMoore Consulting Slide 4 JPA Overview • JPA provides persistence for “Plain Old Java Object” (POJO) entities. • Entities can be defined using annotations or an XML mapping file. • An entity typically represents a table in a relational database, and each object of the class corresponds to a row in that table. • Primary keys and relationships are also indicated by appropriate annotations on the entity class or entries in the XML mapping file. • Entities are managed by an entity manager. ©SoftMoore Consulting Slide 5 Requirements for Entity Classes • Must be annotated with javax.persistence.Entity • Must have a public or protected, no-argument constructor (may have other constructors) • Must not be declared final. Also, no methods or persistent instance variables must be declared final. • Must have persistent instance variables declared as private, protected, or package-private – entity’s state accessed through accessor (get) methods • May need to implement the Serializable interface (if passed by value in a remote call) ©SoftMoore Consulting Slide 6 Persistent Fields and Properties • The persistent state of an entity can be accessed either through the entity’s instance variables or through JavaBeans-style properties. – If the mapping annotations are applied to the entity’s instance variables, the entity uses persistent fields. – If the mapping annotations are applied to the entity’s getter methods for JavaBeans-style properties, the entity uses persistent properties. • You cannot apply mapping annotations to both fields and properties in a single entity. ©SoftMoore Consulting Slide 7 Java Types for Persistent Fields/Properties • Primitive types • String • Enumerated types • Other entities and/or collections of entities – – – – • java.util.Collection java.util.Set java.util.List java.util.Map Embeddable classes ©SoftMoore Consulting • Other serializable types: – – – – – – – – – – – – – Wrappers classes java.math.BigInteger java.math.BigDecimal java.util.Date java.util.Calendar java.sql.Date java.sql.Time java.sql.TimeStamp User-defined serializable types byte[] Byte[] char[] Character[] Slide 8 The Minimal Entity • Must be annotated as an Entity • Must have a persistent identifier (primary key) • Example using annotations @Entity public class Employee { @Id private int id; public int getId() { return id; } public void setId(int id) { this.id = id; } } ©SoftMoore Consulting Slide 9 The Minimal Entity (continued) • Example Entity entry in XML mapping file </xml version="1.0" encoding="UTF-8"?> <entity-mappings xmlns=...> <entity class="com.acme.Employee"> <attributes> <id name="id"/> </attributes> </entity> </entity-mappings> ©SoftMoore Consulting Slide 10 Persistent Identity • Identifier in entity, primary key in database • Uniquely identifies entity in memory and in database • Examples – Simple id – single field/property @Id int id; – Compound id – multiple fields/properties @Id int id; @Id String name; – Embedded id – single field of PK class type @EmbeddedId EmployeePK id; Uses PK class Identifier Generation • Identifiers can be generated in the database by specifying @GeneratedValue on the identifier • Three pre-defined generation strategies: – IDENTITY – SEQUENCE – TABLE • Specifying strategy of AUTO indicates that the provider will choose a strategy @Id @GeneratedValue int id; Persistence Context • Abstraction representing a set of “managed” entity instances – Entities keyed by their persistent identity – Only one entity with a given persistent identity may exist in the persistence context – Entities are added to the persistence context, but are not individually removable (“detached”) • Controlled and managed by EntityManager – Contents of persistent context change as a result of operations on EntityManager API Persistence Context Persistence Context Application EntityManager MyEntity A MyEntity C MyEntity a MyEntity B MyEntity b Entities Entity state Entity Manager • Client-visible artifact for operating on entities – API for all the basic persistence operations • Can think of it as a proxy to a persistence context – May access multiple different persistence contexts throughout its lifetime • Multi-dimensionality leads to different aspects of EntityManager (and persistence context) naming – Transaction type, life cycle EntityManager Methods • • • • persist() - insert the entity into the database • • • • • • find() - execute a simple primary key query remove() - delete the entity from the database refresh() - reload the entity state from the database merge() - synchronize state of detached entity with the persistence context createQuery() - create query instance using dynamic JPQL createNamedQuery() - create instance for a predefined query createNativeQuery() - create instance for an SQL query contains() - true if entity is managed by persistence context flush() - force synchronization of persistence context to database Method persist() • Insert a new entity instance into the database • Save the persistent state of the entity and any owned relationship references • Entity instance becomes managed • Example public Customer createCustomer(int id, String name) { Customer cust = new Customer(id, name); entityManager.persist(cust); return cust; } Method find() • Obtains a managed entity instance with a given persistent identity – returns null if not found • Example public void removeCustomer(Long custId) { Customer cust = entityManager.find(Customer.class, custId); entityManager.remove(cust); } Queries • Dynamic or statically defined (named queries) • Criteria using JPQL • Native SQL support when required • Named parameters bound at execution time • Pagination and ability to restrict size of result • Single/multiple-entity results • Bulk update and delete operation on an entity • Standard hooks for vendor-specific hints Queries • Query instances are obtained from factory methods on EntityManager • Query methods – – – – – getResultList() - execute query returning multiple results getSingleResult() - execute query returning single result executeUpdate() - execute bulk update or delete setFirstResult() - set the first result to retrieve setMaxResults() - set the maximum number of results to retrieve – setHint() - apply a vendor-specific hint to the query – setFlushMode() - apply a flush mode to the query when it gets run Dynamic Queries • Use createQuery() factory method at runtime and pass in the JPQL query string • Use correct execution method – getResultList() – getSingleResult() – executeUpdate() • Query may be compiled/checked at creation time or when executed • Maximal flexibility for query definition and execution Example: Dynamic Queries public List findAll(String entityName) { return entityManager.createQuery( "select e from " + entityName + " e") .setMaxResults(100).getResultList(); } Named Queries • Use createNamedQuery() factory method at runtime and pass in the query name • Query must have already been statically defined either in an annotation or XML • • Query names are “globally” scoped • Can include parameters and hints in static query definition Provider has opportunity to precompile the queries and return errors at deployment time Example: Named Queries @NamedQuery(name="Sale.findByCustId", query="select s from Sale s where s.customer.id = :custId order by s.salesDate") /** * Returns all sales for a given customer */ public List findSalesByCustomer(Customer cust) { return entityManager.createNamedQuery("Sale.findByCustId") .setParameter("custId", cust.getId()) .getResultList(); } Object/Relational Mapping • Map persistent object state to relational database • Map relationships to other entities • Metadata may be annotations or XML (or both) • Annotations – Logical: object model (e.g. @OneToMany) – Physical: database tables and columns (e.g. @Table) • XML can additionally specify scoped settings or defaults • Standard rules for default database table/column names Object/Relational Mapping (continued) • State or relationships may be loaded or “fetched” as EAGER or LAZY – LAZY - hint to defer loading until the field or property is accessed – EAGER - requires that the field or relationship be loaded when the referencing entity is loaded • Cascading of entity operations to related entities – Setting may be defined per relationship – Configurable globally in mapping file for persistence-by-reachability Simple Mappings • Direct mappings of fields/properties to columns • Maps any of the common simple Java types – primitives – enumerated – etc. • • – wrappers – serializable Used in conjunction with @Column Defaults to the type deemed most appropriate if no mapping annotation is present • Can override any of the defaults Simple Mappings @Entity public class Customer { @Id private int id; private String name; @Column(name="CREDIT") private int creditRating; @Lob private Image photo; } CUSTOMER ID NAME CREDIT PHOTO Relationship Mappings • Common relationship mappings supported – @ManyToOne, @OneToOne (single entity) – @OneToMany, @ManyToMany (collection of entities) • • Unidirectional or bidirectional • Owning side specifies the physical mapping Owning and inverse sides of every bidirectional relationship – @JoinColumn to specify foreign key column – @JoinTable decouples physical relationship mappings from entity tables Many-to-One Mapping @Entity public class Sale { @Id private int id; SALE ID . . . CUST_ID ... CUSTOMER @ManyToOne private Customer cust; } ID ... OneToMany Mapping @Entity public class Customer { @Id private int id; ... @OneToMany(mappedBy="cust") private Set<Sale> sales; } @Entity public class Sale { @Id private int id; ... @ManyToOne private Customer cust; } CUSTOMER ID ... SALE ID ... CUST_ID Persistence in Java SE • No deployment phase – Application must use a “Bootstrap API” to obtain an EntityManagerFactory • Application uses a local EntityTransaction obtained from the EntityManager – begin() – rollback() • – – commit() isActive() New application-managed persistence context for every EntityManager – No propagation of persistence contexts Bootstrap Classes • javax.persistence.Persistence – root class for bootstrapping an EntityManager – used to obtain an EntityManagerFactory • javax.persistence.EntityManagerFactory – creates EntityManager objects for a named persistence unit or configuration Example public class PersistenceProgram { public static void main(String[] args) { EntityManagerFactory emf = Persistence .createEntityManagerFactory("SomePUnit"); EntityManager em = emf.createEntityManager(); em.getTransaction().begin(); // Perform finds, execute queries, // update entities, etc. em.getTransaction().commit(); em.close(); emf.close(); } } References • The Java EE Tutorial, Part VIII: Persistence. https://docs.oracle.com/javaee/7/tutorial/index.html • Pro EJB 3: Java Persistence API by Mike Keith and Merrick Schincariol, Apress, 2006, ISBN: 978-1590596456. ©SoftMoore Consulting Slide 35