Transparent Persistence Manager for J2EE Data Separation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current J2EE environments face challenges in efficiently managing persistent data across multiple server nodes and databases, leading to increased complexity in application development, database coding, and data coherence issues, while also affecting application portability and extensibility.
Innovation Solution
The implementation of a persistence management layer that separates business processing objects from persistent data objects, using a persistence manager to handle database operations through in-memory representations and state transitions, along with techniques like lazy object creation and transaction reordering to optimize data loading and processing.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If entity beans directly manage persistent data through object-relational mapping, then data access is simplified, but application portability and extensibility deteriorate
Solution Approach 1:
The patent introduces a persistence manager as an intermediary layer between entity beans and persistent data. This persistence manager handles database operations, object creation, and state management transparently, allowing entity beans to focus on business logic while maintaining portability across different database systems and deployment environments.
2Ease of manufacture
If persistent data objects are tightly coupled with business processing objects, then data manipulation is straightforward, but device complexity increases
Solution Approach 1:
The patent segments the system into distinct components: business processing objects (entity beans) that handle business logic, and persistent data objects managed by a persistence manager that handles data operations. This segmentation allows each component to be developed, maintained, and modified independently, reducing overall system complexity despite the added layer of abstraction.
3Speed
If all persistent data objects are loaded into memory immediately, then data access speed is improved, but server load increases
Solution Approach 1:
The patent employs lazy object creation where persistent data objects are not loaded into memory until they are actually needed. The persistence manager creates and loads objects on-demand based on entity bean requests, reducing initial server load and memory consumption while maintaining fast access speeds for actually used data.
Data Source
AI summary
One embodiment of the invention employs “transparent object persistence” techniques in which persistent data objects (i.e., the objects that represent persistent data from a database) are separated from business processing objects (i.e., the objects that handle the requests, process specific business operations, manipulate the persistent data and respond to clients). Within a Java 2 Enterprise Edition (“J2EE”) environment, the business processing objects are entity beans managed by an Enterprise Java Bean (“EJB”) container. A persistence manager manages the persistent data objects, which provide an in-memory representation of a set of database data. The entity beans manipulate the persistent data by invoking get/set accessor methods on the persistent data objects. In one embodiment, the persistence manager associates a state with each of the persistent data objects which indicates an operation to be performed within tables of a relational database when the modifications to the persistent data objects are committed to the relational database.