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
Topic : JPA Kaster Nurmukan • Overview of JPA • EntityManager • • • • • O/R Mapping Primary entity annotations EntityManager Entity Relationships Practice Java Persistence API POJO Forward Engineering Database Table Reverse Engineering • Java Persistence API (JPA) – Annotations for object-relational mapping – Data access API – An object-oriented query language JPQL • Hibernate – The most popular Java ORM library – An implementation of JPA • Hibernate without JPA – API: SessionFactory, Transaction Session, Query, – More features • Hibernate with JPA – API: EntityManagerFactory, EntityManager, Query, Transaction – Better portability – Behaviors are better defined and documented • Java classes – Employee.java • JPA configuration file – persistence.xml • Code to access the persistent objects – EmployeeTest.java • (Optional) Logging configuration files – log4j.properties • Plain Java classes (POJOs); however, it is recommended that – Each persistent class has an identity field – Each persistent class implements the Serializable interface – Each persistent field has a pair of getter and setter, which don’t have to be public • • • • @Entity. Mark class as an entity @Id. Define primary key @EmbeddedId. Define composite key @Table(name=“TABLE_NAME”). Define table name for entity class. • @Column. Define column property. • @Transient. Ignored by persistence framework. • @GeneratedValue,@SequenceGenerator. Autopopulate column with sequence generator. • Maintains a cache of instances within a transactional context (persistence context) • We can acquire EntityManager instance using : Dependency Injection EntityManagerFactory JNDI Lookup • Operations : persist(), merge(), remove(), find(), createNamedQuery(), createQuery() • Persistence unit is declared in persistence.xml • @OneToOne. One to One is represented by a singlevalue entity reference at one or both ends of the relationship • @OneToMany. This annotation is added to a Collection relationship field. • @ManyToOne. Indicating that is an entity is part of a Collection • @ManyToMany. This annotation is assigned to a Collection relationship field to indicate the target entity also has a Collection of the source entity type. • Lazy vs Eager Binding • Cascade (ALL, PERSIST, MERGE, REMOVE, REFRESH) javax.persistence.EntityManager • Replaces much of the EJB 2.x “Home” functionality • Handles O/R Mapping of Entities to the database • Provides APIs – inserting objects into database – getting objects from database – synchronizing objects with database – querying database • Provides caching • Coordinates with transactional services (JTA) • Tightly integrated with Java EE and EJB, but v110912 Java Persistence: EntityManager 12 not limited to that environment javax.persistence.EntityManager • Replaces much of the EJB 2.x “Home” functionality • Handles O/R Mapping of Entities to the database • Provides APIs – inserting objects into database – getting objects from database – synchronizing objects with database – querying database • Provides caching • Coordinates with transactional services (JTA) – Tightly integrated with Java EE and EJB, but not13 Java Persistence: EntityManager limited to that environment v110912 Entities • (formerly and sometimes still called Entity Beans) • are now Plain Old Java Objects (POJOs) – nothing special happens when calling new Author author = new Author(); • are not persistent until associated with an EntityManager em.persist(author); v110912 Java Persistence: EntityManager 14 Example Author POJO Entity @javax.persistence.Entity public class Author { private long id; private long version=0; private String firstName; private String lastName; private String subject; private Date publishDate; Warning: Using GeneratedValue without specifying a specific strategy should only be used when you have no intention of controlling how the provider manages primary keys for this object type. This would be rare. public Author() {} public Author(long id) { this.id = id; } ... } v110912 @Id @GeneratedValue public long getId() { return id;} private void setId(long id) { this.id = id; } public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } Java Persistence: EntityManager 15 Creating Entity in Database Author author = new Author(); //primary key will be gen author.setFirstName("dr"); author.setLastName("seuss"); author.setSubject("children"); author.setPublishDate(new Date()); log_.info("creating author:" + author); em.persist(author); log_.info("created author:" + author); //output -creating author:id=0, fn=dr, pdate=Fri Sep 15 11:54:15 EDT -created author:id=50, fn=dr, pdate=Fri Sep 15 11:54:15 EDT v110912 ln=seuss, subject=children, 2006 ln=seuss, subject=children, 2006 Java Persistence: EntityManager 16 Managed and Unmanaged Entities • Unmanaged state (detached) – instance not associated with an EntityManager – state changes are not tracked – can be serialized to client and returned to be synchronized with database – nothing equivalent to this state in EJB 2.1 entity beans • Managed state (attached) – instance associated with an EntityManager – state changes are tracked within a Persistence Context – EJB 2.1 entity Java beans were always managed v110912 Persistence: EntityManager • client interfaced with data through a proxy or state 17 Persistence Context • A set of attached entity instances managed by an EntityManager • All entities become detached once closed • Two types – Transaction-scoped Persistence Contexts • begin/end at transaction boundaries • only made available through container managed persistence contexts – Extended Persistence Contexts • live beyond any single transaction • allow longer-lived interactions with database without lengthy transactions tying up database resources v110912 Java Persistence: EntityManager 18 Persistence Context Examples • Transaction-scoped (inside server container) @PersistenceContext(unitName=”jpaDemo”) EntityManager em; @TransactionAttribute(REQUIRED) public void update(long authorId, String type) { Author author = em.find(Author.class, authorId); author.setType(type); } • Extended (inside or outside server container) EntityManager em = Persistence. createEntityManagerFactory(“jpaDemo”).createEntityManager (); tx.begin(); //tx 1 begins Author author = em.find(Author.class, authorId); tx.commit(); //tx 1 ends, but author remains managed ... tx.begin(); //tx 2 begins author.setType(type); tx.commit(); //tx 2 ends, and author is still managed until close 19 Persistence Unit • A set of classes that are mapped to the database • defined in META-INF/persistence.xml • must have an identity – “” is a valid identity • Classes – may be named in persistence.xml file – may be automatically scanned for in the classpath • orm.xml – optionally provided to augment, provide, or replace class persistence metadata – (more on orm.xml in Core ORM topic) 20 Example Component Layout META-INF/ +---persistence.xml ejava + ---examples +---… +---DAOException.class +---AuthorDAO.class +---jpa | +---JPAAuthorDAO.class | +---JPADAOBase.class +--domain +---Author.class v110912 Java Persistence: EntityManager 21 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="jpaDemo"> referenced by name • global JNDI name by which provider references resource (will be used when deployed within server) • may use properties element in Java SE environments that lack JNDI <jta-data-source>java:/ejavaDS</jta-data-source> <properties> <property name="hibernate.hbm2ddl.auto" value="create"/> <property name="hibernate.show_sql" value="true"/ </properties> </persistence-unit> </persistence> • vendor-specific way to configure persistence provider 22 Another 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="jpaDemo"> <provider>org.hibernate.ejb.HibernatePersistence</provider> <properties> <property name="hibernate.cache.provider_class" value="net.sf.ehcache.hibernate.Provider"/> <property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect"/> <property name="hibernate.connection.url" value="jdbc:hsqldb:hsql://localhost:9001"/> <property name="hibernate.connection.driver_class" value="org.hsqldb.jdbcDriver"/> <property name="hibernate.connection.password" value=""/> <property name="hibernate.connection.username" value="sa"/> <property name="hibernate.show_sql" value="false"/> <property name="hibernate.hbm2ddl.auto" value="create"/> </properties> </persistence-unit> </persistence v110912 Java Persistence: EntityManager 23 persistence.xml elements • • • • • • • • • name – identity to reference Persistence Unit provider – fully qualified name of javax.persistence.PersistenceProvider – not needed if provider found in classpath acceptable mapping-file – resource path to optional mapping file – can be used to specify <class>es or specify/override @Annotation details jta-data-source – vendor-specific reference to data source using JTA transactions non-jta-data-source – vendor-specific reference to data source using RESOURCE_LOCAL transactions jar-file – optional/additional jar file to scan for classes class – specifies entity classes not automatically scanned by provider exclude-unlisted-classes – if set, provider will not automatically scan archive for entity classes properties – may be used to provide vendor-specific properties to configure persistence providers 24 Java SE Steps • Startup – Get EntityManagerFactory • Runtime – Create EntityManager – Start Transaction – Interact with Entity Manager – Commit Transaction – Close EntityManager • Shutdown – Close EntityManagerFactory 25 updating entities • Updates to managed entities automatically get propagated to database according to flush policy public Author update(Author author) { Author dbAuthor = em.find(Author.class,author.getId()); dbAuthor.setFirstName(author.getFirstName()); dbAuthor.setLastName(author.getLastName()); dbAuthor.setSubject(author.getSubject()); dbAuthor.setPublishDate(author.getPublishDate()); return dbAuthor; } – Note that if author passed in was already managed... • the changes have already been queued • the dbAuthor returned from the find() will be the same object as author • the sets are unnecessarily changing the values of the Author to their current values 26 (optional!)Potential Utiltity Class package ejava.examples.dao.jpa; import import import import java.util.HashMap; java.util.Map; javax.persistence.EntityManagerFactory; javax.persistence.Persistence; public class JPAUtil { private static final Map<String, EntityManagerFactory> factories = new HashMap<String, EntityManagerFactory>(); public static EntityManagerFactory getEntityManagerFactory(String puName) { EntityManagerFactory emf = factories.get(puName); if (emf == null) { synchronized(factories) { emf = factories.get(puName); if (emf == null) { emf = Persistence.createEntityManagerFactory(puName); factories.put(puName, emf); } } } return emf; } public static void close() { synchronized(factories) { for(String puName : factories.keySet()) { factories.get(puName).close(); } factories.clear(); } } } v110912 Java Persistence: EntityManager 27 • http://www.oracle.com IndicThreads.com Java Meet June 2006