|
|
Open Source Persistence Frameworks in Java
| Hibernate is a powerful, ultra-high performance object/relational persistence and query service for Java. Hibernate lets you develop persistent objects following common Java idiom - including association, inheritance, polymorphism, composition and the Java collections framework. Extremely fine-grained, richly typed object models are possible. The Hibernate Query Language, designed as a \"minimal\" object-oriented extension to SQL, provides an elegant bridge between the object and relational worlds. Hibernate is now the most popular ORM solution for Java. |
Go To Hibernate
| ObJectRelationalBridge (OJB) is an Object/Relational mapping tool that allows transparent persistence for Java Objects against relational databases. |
Go To OJB
| Torque is a persistence layer. Torque includes a generator to generate all the database resources required by your application and includes a runtime environment to run the generated classes. |
Go To Torque
| Castor is an open source data binding framework for Javatm?. It's basically the shortest path between Java objects, XML documents and SQL tables. Castor provides Java to XML binding, Java to SQL persistence, and then some more. |
Go To Castor
| Cayenne is a powerful, full-featured Java Object Relational Mapping framework. It is open source and completely free. One of the main Cayenne distinctions is that it comes with cross-platform modeling GUI tools. This places Cayenne in the league of its own, making it a very attractive choice over both closed source commerical products and traditional \"edit your own XML\" open source solutions. |
Go To Cayenne
| TriActive JDO (TJDO) is an open source implementation of Sun's JDO specification (JSR 12), designed to support transparent persistence using any JDBC-compliant database. TJDO has been deployed and running successfully in many commercial installations since 2001. |
Go To TJDO
| Jaxor is a code-generating OR mapping tool which takes information defined in XML relating to the relational entities to be mapped and generates classes, interfaces and finder objects which can be used from any Java application (including JFC/Swing, J2EE and command-line tools). The actual code generation is handled by Velocity templates rather than by fixed mechanisms within the tool. This flexability allows easy tailoring and modification to the formatting or even the code that gets generated. |
Go To Jaxor
| JDBM is a transactional persistence engine for Java. It aims to be for Java what GDBM is for other languages (C/C++, Python, Perl, etc.): a fast, simple persistence engine. You can use it to store a mix of objects and BLOBs, and all updates are done in a transactionally safe manner. JDBM also provides scalable data structures, such as HTree and B+Tree, to support persistence of large object collections. |
Go To JDBM
| pBeans is a Java based persistence framework and an Object/Relational (O/R) database mapping layer. It is designed to be simple to use and completely automated. |
Go To pBeans
| SimpleORM is Java Object Relational Mapping open source project (Apache style licence). It provides a simple but effective implementation of object/relational mapping on top of JDBC at low cost and low overhead. Not even an XML file to configure! |
Go To SimpleORM
| A small (less then 50KB) persistence framework. |
Go To Java Ultra-Lite Persistence
| Prevayler is the free-software Prevalence layer for Java.
Ridiculously simple, Prevalence is by far the fastest and most transparent persistence, fault-tolerance and load-balancing architecture for Plain Old Java Objects (POJOs). |
Go To Prevayler
| JPOX is a full compliant implementation of Java Data Objects (JDO) API. The JDO API is a standard interface-based Java model abstraction of persistence. JPOX is free and released under an OpenSource license, and so the source code is available for download along with the JDO implementation. |
Go To JPOX Java Persistent Objects
| The SQL Maps framework will help to significantly reduce the amount of Java code that is normally needed to access a relational database. This framework maps JavaBeans to SQL statements using a very simple XML descriptor. Simplicity is the biggest advantage of SQL Maps over other frameworks and object relational mapping tools. To use SQL Maps you need only be familiar with JavaBeans, XML and SQL. There is very little else to learn. There is no complex scheme required to join tables or execute complex queries. Using SQL Maps you have the full power of real SQL at your fingertips. The SQL Maps framework can map nearly any database to any object model and is very tolerant of legacy designs, or even bad designs. This is all achieved without special database tables, peer objects or code generation. |
Go To Ibatis SQL Maps
| Simple data storage API to help developers to focus on their applications instead of writing JDBC code. |
Go To Smyle
| Speedo is an open source implementation of the JDO (TM) specification. |
Go To Speedo
| XORM is an extensible object-relational mapping layer for Java applications |
Go To XORM
| Space4J (or S4J, for short) is a free prevalence implementation in Java. Prevalence is a concept started by Klaus Wuestefeld on how to store data in a real object oriented way, using only memory snapshots, transaction logs and serialization. In addition to the basic functionality it offers transparent support for clustering, passivation and indexing. |
Go To Space4J
| JDBCPersistence is yet another OR mapping layer. It differs from its peers in both implementation and API. Using bytecode generation at its core the framework generates classes that implement JDBC Logic which is specific to a table/bean pair. JDBCPersistence generates persistor classes at runtime on demand incurring no noticeable overhead on the development process. The entire framework configuration is done via API, which significantly improves start-up time and reduces library size. |
Go To JDBCPersistence
| A lightweight persistence framework for Java (JDK5.0 or later). Extremely simple to use, works whith annotations, does not require any configuration/mapping file, runs whith any JDBC compliant database (no SQL dialects to configure) and supports multi-device persistence. |
Go To Ammentos
| O/R Broker is a convenience framework for applications that use JDBC. It allows you to externalize your SQL statements into individual files, for readability and easy manipulation, and it allows declarative mapping from tables to objects. Not just JavaBeans objects, but any arbitrary POJO. This is the strength of O/R Broker compared to other similar persistence tools. It allows the developer to design proper object-oriented classes for persistence, without having to be forced to use JavaBeans only, and it has full support for inheritance hierarchies and circular references.
One of the design goal for O/R Broker was simplicity, which means that there are only 4 public classes, and an XML Schema file for validation of the very simple XML configuration file.
In short, O/R Broker is a JDBC framework that does not dictate domain class design, whether that be having to conform to the JavaBeans spec, having to extend a superclass or implement an interface, but allows persistence independence and proper object-oriented class design. |
Go To O/R Broker
| PAT stands for \"Persistent Applications Toolkit\". Like many other software it simplifies developing of persistence layers of business applications. It does it by providing object-oriented environment for persistence of your objects: POJOs
And.. it really does it.
PAT provides almost transparent data layer for a business application. It employs state-of-the-art techniques to achieve it. These are OO, AOP (JBossAOP), Java, Prevayler, Ant, JUnit, Log4j, @@annotations and others. It cooperates well with web applications: Struts (and possibly other web frameworks), Tomcat, JBoss AS.
(AOP term: persistence aspect) |
Go To PAT
| QLOR (Q-LOGIC Object Relational Mapping Framework) is a performant Object/Relational Mapping and persistence/query framework for Java. It's easy to use and deploy with other technologies. It is heightly structured and designed.
Features:
* O2O, O2M and M2M database mappings.
* Multiple primary keys without modifying the class
diagram.
* Cascading primary keys on associations.
* Easy inheritance and multi inheritance mapping.
* Programmatic mappings.
* Multi-files project mapping.
* Declarative database encryption function.
* Multi-database support.
* Clean and easy to read persistence layer log and more...
|
Go To QLOR
| Daozero reduces DAO codes based on Spring & iBatis. The old way is to write codes and invoke iBatis API explicitly, but daozero implements DAO interfaces in runtime, invokes iBatis API for developers atuomaticaly. Replace old DAOs with it directly. |
Go To Daozero
| JGrinder is a framework for mapping Objects in Java to various persistent stores. These include relational databases, in memory 'storage', and flat files. The architecture allows additional persistent stores to be supported (such as storing objects over a messaging middleware). |
Go To JGrinder
| Velosurf is a database mapping layer library for the Apache Velocity template engine. It provides automatic database mapping of tables and relationships without any code generation. It is a lightweight placeholder to heavy persistence systems. |
Go To Velosurf
| ODAL is database persistence framework with emphasis on maintainability and performance. Features include query API, ORM, data validation/conversion, stored procedure support, code generation. Minimal dependencies. Short startup time. |
Go To ODAL
| Persist is a minimalist Java ORM/DAO library designed for high performance and ease of use. Unlike most ORM tools, Persist does not aim to completely isolate application code from relational databases. Instead, it intends to minimize the effort to handle data stored in a RDBMS through JDBC, without making compromises on performance and flexibility. |
Go To Persist
| It is a feature-rich implementation of the persistence part of Enterprise Java Beans 3.0, also known as the Java Persistence API (JPA), and is available under the terms of the Apache Software License. OpenJPA can be used as a stand-alone POJO persistence layer, or it can be integrated into any EJB3.0 compliant container and many lightweight frameworks. |
Go To Apache OpenJPA
| jPersist is an extremely powerful object-relational database persistence API that manages to avoid the need for configuration and annotation; mapping is automatic. It uses JDBC, and can work with any relational database and any type of connection resource. It uses information obtained from the database to handle mapping between the database and Java objects, so mapping configuration is not needed, and annotation is not needed. In fact, there is no configuration needed at all. |
Go To jPersist
| Super CSV is a CSV package for processing CSV files. Super CSV is designed around solid Object-oriented principles, and thus aims to leverage your Object-oriented code, making it easier to write and maintain.
Super CSV offers the following features:
* The ability to read/write POJO beans, Maps and String lists.
* The ability to easily convert input/output to integers, dates, trimming strings, etc...
* The ability to easily verify data conforms to some specification, such as number ranges, string sizes, uniqueness and even optional columns.
* The ability to read/write data from anywhere in any encoding. As long as you provide a Reader or a Writer.
* Support for Windows, MAC and Linux line breaks.
* Configurable separation character, space character end end of line character (for writing files)
* Correctly handling of characters such as \" and ,
* Operates on streams rather than filenames, enabling you to read/write CSV files e.g. over a network connection
|
Go To Super CSV
| Mr. Persister is an object persistence API, that makes it possible to read and write objects of any size to and from relational databases.
The implemented/planned features includes easier JDBC operations via JDBC templates (Spring style), automatic connection / transaction handling, object relational mapping, dynamic reports, connection pooling, caching, replication, debugging and more. |
Go To Mr. Persister
| SeQuaLite is a data access framework over jdbc. Features include CRUD operations, Lazy-Load, Cascading, Paging, on-the-fly SQL generation. It helps reduce development time effectively. |
Go To SeQuaLite
| NetMind BeanKeeper is an O/R (object/relation) mapping library. Its task is to map java objects to a relational database, and to offer a powerful query service to retrieve them.
|
Go To BeanKeeper
| Athena Framework is a full fledged enterprise object-relational mapping (ORM) framework that employs metadata as mapping configuration. It greatly simplifies Java web application development by removing the requirement of manual mapping and manual database schema updating. In addition to features like Java object persistence, powerful EJBQL querying execution and comprehensive code generation, Athena has built-in support for multi-tenancy which enables developers to build cloud applications easily. Athena can be easily integrated with other libraries like Struts or Spring to provide full stacks of service.
As a solid ORM framework with built-in support for cloud applications, Athena offers many other distinguished features.
* Metadata as the Single Source of Truth
* Implementing Change at the Speed of Your Thought
* Gaining Total Control of EJBQL Querying
* Fine-Grained Query Specific Partial Attribute Loading
* Developing Multi-Tenancy Cloud SaaS Applications With Ease
* Switching Between Soft Deletion and Hard Deletion Quickly
* The Ultimate Solution to Database Versioning and Migration
|
Go To Athena Framework for Java
| Ebean is Object Relational Mapping Persistence Layer.
Ebean is designed to be easy to learn and use. It follows the mapping specification of JPA with annotations such as @Entity, @OneToOne, @OneToMany etc.
Ebean also has a relational api when you want to bypass ORM in favour of using your own SQL for fetching, updating and calling stored procedures. |
Go To Ebean ORM
| The Eclipse Persistence Services Project (EclipseLink) delivers a comprehensive open-source Java persistence solution. EclipseLink focuses on standards with advanced features, performance and scalability for enterprise software developers across data sources, formats, and containers. |
Go To EclipseLink
| jOOQ is a fluent API for typesafe SQL query construction and execution. It combines these essential features:
* Code Generation: jOOQ generates a simple Java representation of your database schema. Every table, view, stored procedure, enum, UDT is a class.
* Active records: jOOQ implements an easy-to-use active record pattern. It is NOT an OR-mapper, but provides a 1:1 mapping between tables/views and classes. Between columns and members.
* Typesafe SQL: jOOQ allows for writing compile-time typesafe querying using its built-in fluent API.
* SQL standard: jOOQ supports all standard SQL language features including the more complex UNION's, nested SELECTs, joins, aliasing
* Vendor-specific feature support: jOOQ encourages the use of vendor-specific extensions such as stored procedures, UDT's and ARRAY's, recursive queries, and many more. |
Go To jOOQ
| LML is a small (82Kb) but reliable persistence engine based in annotations and reflection. It has no dependencies and can be used for standalone and web applications.
It's a clean and easy to use library for developers to forget worrying about database communication. |
Go To LightweightModelLayer
| MyBatis is the new name of the former project Ibatis SQL Maps. At the same time, the code has been moved from Apache Software Foundation to Google Code. Moreover, nothing has been changed.
It is still a java persistence framework with support for custom SQL, stored procedures and advanced mappings. MyBatis minimizes the need of JDBC code, manual setting of parameters and retrieval of results. The framework can map primitives, Map interfaces and Java POJOs to database record, using XML or Annotations for configuration. |
Go To MyBatis
| The package provides simple but powerful functionality for persisting Java objects to SQL databases while avoiding the complexity and overhead of more standard ORM packages. All you need to do is simply add Java annotations to your classes. It comes with powerful abstract DAO classes so your database read/write classes can be 5 lines long. Includes a flexible QueryBuilder to easily construct simple and complex queries. Supports MySQL, Postgres, Microsoft SQL Server, H2, Derby, HSQLDB, and Sqlite and can be extended to additional databases relatively easily. |
Go To ORM Lite
| Object Relational Mapping Lite (ORM Lite) provides some simple, easy, and basic functionality for persisting Java objects to SQL databases while avoiding the complexity and overhead of more standard ORM packages.
ORMLite supports natively MySQL, Postgres, Microsoft SQL Server, H2, Derby, HSQLDB, and Sqlite and can be extended to additional ones relatively easily. |
Go To ORMLite
| Persistence4j is a very simple library which can be used to persist data into Relational databases.This library frees you from writing the Data transfer objects. Just create a POJO and simply save it using this library.I have also integrate Java transaction API with this library
The library is written 100% in the Java language and minimum Java 1.6 is required. |
Go To Persistence4J
| The open-source ORM framework was designed for the rapid Java development based on a relation database and the framework provides a type-safe API for database queries so the most of typing errors are detected before running the application. Developer can take an advantage of a code-completion in their favorite IDE at coding time. |
Go To Ujorm
|
|
