| |
1. Understanding Object/Relational Persistence
Discover persistent data management in the context of object-oriented
applications as well as the relationship of SQL, JDBC, and Java, specifically
the underlying technologies and standards that Hibernate is built upon. Define
the software development challenges that embody the "object/relational
paradigm mismatch", and explore additional generic problems encountered
when creating object-oriented software clients to relational databases. Learn
how the transparent and automatic object/relational mapping capabilities
provided by JPA and Hibernate can be used to overcome the object/relational
paradigm mismatch problem.
2. Getting Started with Hibernate
Get the information necessary to begin a Hibernate project as you're guided
through selecting a development process, setting up a project, authoring the
necessary configuration files and java classes, and running and testing the
application. Once the basic skills are mastered, work with realistic use cases
such as writing a hibernate client to an existing legacy database. Explore the
Hibernate reverse engineering tools, and learn to use JPA/Hibernate annotations
and the JPA/Hibernate EntityManager.
3. Domain Models and Metadata Options
Discover the online auction application, CaveatEmptor, which will be used
throughout the course lecture and the course labs to provide realistic JPA and
Hibernate use cases. Walk through implementing the domain model, and learn sound
design patterns and development practices for persistent classes. Learn how to
address the leakage of concerns, implement transparent and automated
persistence, use established design patterns when working with plain
ordinary/old, Java objects (POJOs) as business objects, value objects, and
entities, and implement POJO associations. Conclude with the object/relational
mapping metadata. Metadata will be presented as XML and as annotation-based.
Check out useful technologies and skills such as XDoclet, handling global
metadata, and manipulating metadata at runtime.
4. Mapping Persistent Classes
In this section, focus on mapping entities with XML and annotations,
fine-grained property and component mappings, and inheritance mapping
strategies. Discover the essential distinction between entities and value types
and how an individual should approach the object/relation mapping of a given
domain model. Learn fundamental mapping options to show how classes and
properties are mapped to tables and columns. Learn how to handle database
identity and primary keys and how to use metadata settings to influence the
loading and storing of objects. Mapping examples are presented in both
Hibernate's native XML format and with JPA annotations and XML descriptors.
Examine fine-grained domain models and see how properties and embedded
components are mapped. Receive guidelines for choosing the appropriate
inheritance mapping strategy when mapping object inheritance hierarchies.
5. Collections and Associations
Most developers new to object/relational mapping techniques have their first
experience working with collections and entity associations with the mapping of
a parent/child relationship. For this reason, many examples of such a
relationship exist in the CaveatEmptor domain, and this association is the focus
of this module. Learn how to map "one" and "many"-valued
relationships between entity classes. The ability for other classes to have an
association to the same target class (not only a single entity class) and the
fact that each entity target instance has its own identity and independent state
complicates what is initially perceived as a "simple" relationship
mapping. You will be guided through these issues (which includes bidirectional
associations and cascading parent to child state) step by step.
6. Working with Objects
Learn greater detail about the life cycle and states of objects, the
Hibernate persistence manager API, EJB3, and the Java Persistence API, and data
filtering and interception. Discover how an object becomes persistent and how it
stops being considered persistent or, more specifically, the method calls and
other actions that trigger these transitions. As the Hibernate persistence
manager is responsible for managing object state, you'll be exposed to this API
first. The main Java Persistence interface in EJB 3.0 is called EntityManager
and, due to its close resemblance to Hibernate API, the EM API is taught in
concert with the Hibernate API. Discuss data filtering and interception. Both of
these capabilities offer transparent "hooks" into the loading and
storing process inside the Hibernate engine. Learn how to influence or
participate in the life cycle of Hibernate and JPA objects without writing
complex application code or without binding the domain model to the persistence
mechanism.
7. Transactions
A comprehensive treatment of transactions. Learn to create and control units
of work in an application and how transactions work at the database level. Work
with transactions in an application based on native Hibernate, Java Persistence,
or the EJB container. Demarcate a transaction boundary to define a unit of work,
and explore concurrency and how concurrent data access can be controlled in an
application with pessimistic and optimistic strategies.
8. Efficient Storing and Loading
Explore transitive state changes, batch and bulk processing, and applying
global fetching strategies. Learn techniques for efficient object storing and
loading. Learn how to optimize and reduce the amount of code that is necessary
to store objects and how to identify the most efficient data retrieval and
processing options. See how transitive persistence can facilitate working with
complex object networks. Discover how enabling cascading options in Hibernate
and Java Persistence applications will significantly reduce the amount of code
that is needed to insert, update, or delete several objects at a time. Address
object retrieval in detail and discuss how large datasets are best handled with
application-oriented batch operations or with bulk operations that execute
directly on the database. Explore fetching strategies and how their use can
optimize loading object networks when an application navigates from one object
to another object.
9. Querying
Learn to work with the various query options available via the Hiberate and
JPA APIs. Write and execute HQL and EJB-QL queries, and explore the Criteria and
Example APIs. Learn to embed native SQL and stored procedures in a query.
10. Application Design and Architecture
Create layered applications with or without the use of managed components and
services, and learn recommended testing practices for applications with
persistence. Learn common Java architectures to illustrate how Hibernate can be
integrated into various scenarios. Explore domain modeling and application
layering as creating layers may affect persistence-related code. Persistence in
rich clients and desktop applications is briefly addressed. View many generic
patterns and strategies that can be implemented in any framework as well as
simple JSE. Discover JEE services and EJBs to show how managed components can
facilitate and reduce the amount of infrastructure coding. The simplicity of the
new EJB 3.0 specification, in particular, allows the developer to benefit
greatly from a container environment. Test layered applications with or without
managed components. Unit, functional, and integration |
|