JDXA (JDX for Android) is a flexible, non-intrusive, developer-friendly, and lightweight Object-Relational Mapping (ORM) solution for seamlessly bridging the gap between the Java object model and SQL relational model for mobile applications. JDXA increases programmer productivity tremendously by presenting a more intuitive, object-oriented view of relational data and eliminating the need to write endless lines of complex low-level SQL code.
Based on some well thought-out KISS (Keep It Simple and Straightforward) principles, JDXA provides fast, flexible, and easy-to-use ORM functionality in a small footprint. JDXA employs a clean, dynamic, and meta-data driven programming methodology supporting pure domain object models, resulting in simpler and faster applications that are easy to evolve and maintain.
The product comes with Android platform-specific utility classes to facilitate the easy and speedy development of mobile applications that need on-device access to SQLite relational database.
Please click on any of the following features to learn more.
Declarative mapping specification based on simple grammar
- Human-readable and easily comprehensible; no need to struggle with complex XML files.
- Compact; most default mapping is automatically deduced; avoids verbosity.
- Most mapping primitives are orthogonal to each other, avoiding unnecessary tight coupling and enabling easy evolution.
- Allows cross-referencing of classes and collections no matter in which order their mappings have been defined.
- Intuitive and flexible ways of mapping complex object structures.
- Mappings for collections and relationships are defined at the object level, not at the relational level; makes it easier to understand and modify such mappings.
A non-intrusive and dynamic programming model
- Supports POJO (Plain Old Java Object) classes for persistence.
- No requirement to inherit from a special class.
- No generation of complex source code for data access methods.
- Allows easy evolution of object and relational models.
- Supports explicit transactions
Easily handles complex object structures, including class-hierarchies.
- Associative and aggregated relationships.
- 1-to-1, 1-to-many, and many-to-many relationships.
- Aggregated or separated tables options for storing objects in a class-hierarchy.
- Support for persisting JSON objects.
Flexible query options – deep, shallow, and anything in-between
- Supports loading of partial objects.
- Sophisticated query predicates (including path-expressions).
- Powerful object-streaming functionality.
- Polymorphic queries.
- Dynamic data routing.
- Named queries for greater convenience, more flexibility, and better performance.
- No learning of any new query language required.
- Allows mapping of class attributes, which are not explicitly declared in the class definition.
- Enables flexible evolution of object/data modeling in many situations.
- Returns the aggregate value (COUNT, MIN, MAX, AVG, SUM) for the specified attribute of the qualifying objects. Enables easy data analysis.
- Provides super-fast access to business objects from high-performance memory cache.
- Regular and LRU caches.
Flexible Support for Multiple Mappings and Multiple Databases
- An App may easily employ multiple mapping specifications for flexible and modular partitioning of mapping units
- An App may work with multiple Databases simultaneously
Optimistic locking for concurrency control
- Provides a faster and more scalable locking alternative to database. locking. Especially useful for long-running transactions with minimal conflicting update operations.
Lightweight and optimized mapping engine
- Self-healing connection pooling.
- Use of prepared statements.
- Optimized SQL statements.
- Minimal database trips.
- Short code paths.
- Small footprint.
- Accelerates data exchange.
Automatic Schema generation
- JDX automatically creates the database schema (tables, constraints, etc.) as per the Java object model and the object-relational mapping specification.
Nifty components and facilities to simplify development
- Utility components for pooling JDX handles.
- Persistently unique sequence generators.
- Object-viewing facilities.
- Support for instance callback methods.
- Configurable logging destination
Easy-to-learn and easy-to-use
- Clean design – not an over-engineered framework with complex semantics.
- Small set of simple and flexible APIs.
- No learning of new query language required.
- Meaningful error and debug messages.
- A comprehensive manual, many tutorials and working examples.