EclipseLink Persistence Framework

EclipseLink is a comprehensive and universal persistence framework designed to run in any Java environment. It facilitates reading and writing objects to various data sources, including:

• Relational Databases: via Jakarta Persistence (JPA).
• XML: via Jakarta XML Binding (JAXB).
• EIS and Legacy Systems: via Jakarta Connectors.
• Other formats: including JSON and Service Data Objects (SDO).

EclipseLink is an advanced object-persistence and object-transformation framework. It is designed to bridge the gap between object-oriented Java applications and various data sources, allowing developers to focus on domain logic rather than data mapping.

EclipseLink supports the following data types and formats:

• Relational Data: Transactional persistence of Java objects to relational databases via JDBC drivers.
• Object-Relational Data Types: Persistence to structured data source representations optimized for object-relational databases (e.g., Oracle Database).
• Enterprise Information Systems (EIS): Persistence to nonrelational data sources using Java EE Connector architecture (JCA) adapters (including indexed, mapped, or XML records).
• XML: Nontransactional, in-memory conversion between Java objects and XSD-based XML documents using JAXB.

EclipseLink supports EJB 3.0 and the Jakarta Persistence API (JPA) in both Jakarta EE and Java SE environments. It integrates with various application servers, including:

• Oracle WebLogic Server
• Oracle Glassfish Server
• JBoss Web Server
• IBM WebSphere application server
• SAP NetWeaver
• Oracle Containers for Jakarta EE (OC4J)
• Web containers such as Apache Tomcat, Eclipse Gemini, IBM WebSphere CE, and SpringSource tcServer.

When building a persistence layer with EclipseLink, you can choose from several implementation strategies depending on your architectural needs:

• JPA Metadata, Annotations, and XML: Use standard JPA annotations, persistence.xml, and EclipseLink-specific JPA extensions for configuration.
• Metadata Java API: Manually code the project, login, platform, descriptors, and mappings in Java. This is ideal for model-based applications that rely on code generation.
• Method and Direct Field Access: Choose between using getter/setter methods (property access) or accessing fields directly.
• Java Byte-code Weaving: Use weaving to enhance JPA entities or POJOs with features like lazy loading, change tracking, fetch groups, and internal optimizations.

A descriptor is an object that stores all the information required to represent an instance of a particular Java class in a data source (such as a database table or an XML complex type).

Descriptors are primarily managed via the org.eclipse.persistence.descriptors package. A descriptor typically contains:

• The persistent Java class and its corresponding data source mapping.
• A collection of mappings for attributes and relationships.
• Primary key information.
• Query keys (aliases) for field names.
• Sequence number information.
• Optional properties for behavior tailoring (e.g., caching, identity maps, optimistic locking, event management, and query management).

The EclipseLink Workbench is a graphical configuration tool separate from the EclipseLink runtime. It allows developers to define EclipseLink descriptors and mappings without writing code.

Key capabilities include:

• Graphically configuring descriptors and mapping projects.
• Verifying descriptor options.
• Accessing data sources (databases or XML schemas).
• Creating database schemas.

Workbench is primarily intended for development when using the native EclipseLink API, MOXy, or EIS. For JPA development, tools like Eclipse Dali or Oracle JDeveloper are recommended.

Workbench stores project information in a .mwp file, which is used only by the Workbench. To run an EclipseLink-enabled application, you must export the configuration from Workbench into a project.xml file.

Indirection (also known as lazy loading, lazy reading, or just-in-time reading) is a mechanism where EclipseLink uses a placeholder object for a relationship instead of immediately fetching the related data from the database. The dependent object is only read when the specific attribute is accessed.

Benefits:

• Significant performance improvement by avoiding unnecessary data retrieval.
• Optimized persistence unit processing, cache access, and concurrency.
• Essential for maintaining bidirectional relationships.

Important Notes:

• If you are working with collections, you must use Transparent Indirection.
• Indirection implementation is vendor-specific; serializing entities and merging them across different vendors may not be interoperable if lazy properties are used.

Dynamic JAXB/MOXy allows you to bootstrap a JAXBContext from metadata sources (like XML Schemas) without requiring pre-compiled Java domain classes. Instead of using standard POJOs, you work with DynamicEntity objects.

Key Benefits:

• No Recompilation: You can update metadata (XSDs) without regenerating and recompiling Java source code.
• Dynamic Entities: Domain objects are subclasses of DynamicEntity.
• Simple API: Use get(propertyName) and set(propertyName, propertyValue) to manipulate data.
• In-Memory Metadata: An associated DynamicType is generated in-memory when the metadata is parsed, allowing for runtime introspection.