Enterprise Development with JPA (part 2)

By Patrick Linskey and Mike Keith - Posted on Dec 16, 2006 07:27

Currently 2.9659755/5 1 2 3 4 5

Rating: 2.97/5 (10,081 votes)

1. Intro [image]

2. Agenda [image]

3. Access Type [image]

4. Use FIELD access [image]

5. Inheritance [image]

6. Mapped Superclass [image]

7. Abstract Entity [image]

8. Inheritance Mapping [image]

9. Object Model [image]

10. Data Models [image]

11. Persistence Unit [image]

12. Example [image]

13. Persistence Contexts - 1 [image]

14. Persistence Contexts - 2 [image]

15. Persistence Contexts - 3 [image]

16. PC Propagation [image]

17. Entity Caching [image]

18. Advanced Caching - 1 [image]

19. Advanced Caching - 2 [image]

20. Detaching Entities [image]

21. Detached Entities [image]

22. Transactions [image]

23. Optimistic Locking [image]

24. Configuration [image]

25. Component Packaging - 1 [image]

26. Component Packaging - 2 [image]

27. Adding the Entities - 1 [image]

28. Adding the Entities - 2 [image]

29. Adding the Entities - 3 [image]

30. Adding the Entities - 4 [image]

31. Adding the Entities - 5 [image]

32. Adding the Entities - 6 [image]

33. Packaging Options - 1 [image]

34. Packaging Options - 2 [image]

35. Packaging Options - 3 [image]

36. Packaging Options - 4 [image]

37. More Information [image]

The recently-released EJB 3.0 specification has perhaps been one of the most talked-about technologies that has emerged from JCP for some time. At the centre of attention is the Java Persistence API, a lightweight persistence model that acts as a point of convergence for the dominant persistence products currently on the market.

Standardization of persistence inside of the Java EE platform, as well as in the SE environment, will finally provide enterprise applications with the ability to write to one API and be able to run on the vendor of their choice. This talk covers best practices and common usage patterns of the Java Persistence API in conjunction with a Java EE application server.

Some of the topics discussed in this talk:

Enterprise entity models EntityManagers and persistence context propagation Entity caching Detaching and merging entities Entities in enterprise transactions Packaging and deploying

We will address the following common design questions:

Should I use field or property access type? How often should I detach / merge? What sorts of restrictions should I follow when I design my entity object model? Can I put behavior in my entities? What transactional guarantees can I rely on?

Mike Keith is the co-specification lead of EJB 3.0 (JSR 220) and a member of the Java EE 5 expert group (JSR 244). He has 15 years of teaching, research and practical experience in object-oriented and distributed systems, specializing in object persistence. His expertise has stemmed from designing and implementing numerous persistent object systems for Fortune 100 corporations. He has been involved in EJB since its initial release and other forms of persistence since long before EJB. He is an architect for Oracle TopLink and the Oracle OC4J Java EE Container and is a popular speaker at numerous conferences and events. Mike co-authored the book "Pro EJB 3: Java Persistence API".

Patrick Linskey has been working with O/R mapping for over six years. He is an active member of both the JDO 2.0 and EJB 3.0 expert groups, and is on the JAOO Conference Program Committee.

As the founder and CTO of SolarMetric, Patrick drove the technical direction of the company. Now at BEA, he leads the EJB team in designing and implementation of the WebLogic Server EJB solution.

He has been the face of standards-based persistence, having evangelized JDO and EJB Persistence in hundreds of talks throughout the world. Under Patrick's leadership, Kodo has become the market leading JDO implementation with over 350 customers throughout the world spanning all industries, and is now the basis for the WebLogic Server EJB persistence provider.

Java Persistence 2.0 — One of the key outcomes of Java EE 5 / EJB 3.0 was the introduction of the Java Persistence API. JPA is a new standard API for Java persistence and object/relational mapping that supports use in both Java EE and Java SE environments.

JSR 318 - Enterprise JavaBeans 3.1 — Enterprise JavaBeans is an architecture for the development and deployment of component-based business applications. Applications written using the Enterprise JavaBeans architecture are scalable, transactional, and multi-user secure.

Advanced Topics in JPA — In this talk we will introduce a few of the common features and use them as a platform on which we can discuss some of the higher order JPA topics. As part of this discussion we will show how to use multiple persistence units, define and tune identifier generators, create and invoke native queries, and use XML mapping files for overriding annotation metadata. We will also show how JPA can be used in Java SE and Spring environments.

Writing JPA applications — In this session Patrick explores the new Java Persistence API, and examine some common practices for how to write Spring applications that use JPA. Patrick will focus more on API usage than on mapping configuration, and will look at the bootstrapping and runtime behavior of JPA applications. You will learn about JPA's optimistic locking semantics, including the benefits of optimistic read locks. Patrick looks at when it's appropriate to use the different facilities of the Java Persistence Query Language (JPQL), and also discusses common extensions to the spec, including performance caching, pessimistic locking, and fetch strategies.

Java EE 5 Blueprints (JPA) — The Java BluePrints projects presents the programming model, guidelines and examples for designing enterprise quality applications and web services using Java technologies. Some of the areas covered are Ajax-enabled Web 2.0 applications, Persistence, JavaServer Faces, SOA with BPEL, and WS-Security. This talk will focus on the Java Persistence API.

Share + Bookmark Talk

+dZone +Reddit +Del.icio.us +Fark +Blink It +Ma.gnolia +Newsvine +RawSugar +YahooWeb