Cayenne is a powerful, full-featured Java Object Relational Mapping framework. It is open source and completely free. One of the 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.
Apache Open JPA
It is a feature-rich implementation of the persistence part of Enterprise Java Beans 3.0, also known as the Java Persistence API (JPA), 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.
Ibatis SQL Maps
The SQL Maps framework will help to significantly reduce the amount of Java code that is normally needed to access a relational 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.
Hibernate is a powerful, ultra-high performance object/relational persistence and query service for Java. Hibernate lets you develop 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.
ObJectRelationalBridge (OJB) is an Object/Relational mapping tool that allows transparent persistence for Java Objects against relational that allows transparent persistence for Java Objects against relational databases.
Torque is a persistence layer. Torque includes a generator to generate all the database resources required by your application and generate all the database resources required by your application and includes a runtime environment to run the generated classes.
Castor is an open source data binding framework for Javatm?. Its basically the shortest path between Java objects, XML documents and SQL 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.
TriActive JDO (TJDO) is an open source implementation of Suns JDO specification (JSR 12), designed to support transparent persistence 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.
JDBM is a transactional persistence engine for Java. It aims to be for Java what GDBM is for other languages (C/C++, Python, Perl, 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.
Prevayler is the free-software Prevalence layer for Java. Ridiculously simple, Prevalence is by far the fastest and most Ridiculously simple, Prevalence is by far the fastest and most transparent persistence, fault-tolerance and load-balancing architecture for Plain Old Java Objects (POJOs).
JPOX Java Persistance Objects
JPOX is a full compliant implementation of Java Data Objects (JDO) API. The JDO API is a standard interface-based Java model (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.
Speedo is an open source implementation of the JDO (TM) specification. specification.
Jaxor is a code-generating OR mapping tool which takes information defined in XML relating to the relational entities to be 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.
pBeans is a Java based persistence framework and an Object/Relational (O/R) database mapping layer. It is designed to be Object/Relational (O/R) database mapping layer. It is designed to be simple to use and completely automated.
SimpleORM is Java Object Relational Mapping open source project (Apache style licence). It provides a simple but effective (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!
Simple data storage API to help developers to focus on their applications instead of writing JDBC code. applications instead of writing JDBC code.
XORM is an extensible object-relational mapping layer for Java applications applications
A lightweight persistence framework for Java (JDK5.0 or later). Extremely simple to use, works whith annotations, does not require any 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.
Super CSV is a CSV package for processing CSV files. Super CSV is designed around solid Object-oriented principles, and thus aims to 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 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
ODAL is database persistence framework with emphasis on maintainability and performance. Features include query API, ORM, data maintainability and performance. Features include query API, ORM, data validation/conversion, stored procedure support, code generation. Minimal dependencies. Short startup time.
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 Its task is to map java objects to a relational database, and to offer a powerful query service to retrieve them.
Persist is a minimalist Java ORM/DAO library designed for high performance and ease of use. Unlike most ORM tools, Persist does not aim 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.
Ebean is Object Relational Mapping Persistence Layer. Ebean is designed to be easy to learn and use. It follows the mapping 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.
Space4J (or S4J, for short) is a free prevalence implementation in Java. Prevalence is a concept started by Klaus Wuestefeld on how to 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.
JDBCPersistence is yet another OR mapping layer. It differs from its peers in both implementation and API. Using bytecode generation at 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.
O/R Broker is a convenience framework for applications that use JDBC. It allows you to externalize your SQL statements into individual 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.
JGrinder is a framework for mapping Objects in Java to various persistent stores. These include relational databases, in memory 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).
Velosurf is a database mapping layer library for the Apache Velocity template engine. It provides automatic database mapping of 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.
jPersist is an extremely powerful object-relational database persistence API that manages to avoid the need for configuration and 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.
Java Ultra Lite Persistence
A small (less then 50KB) persistence framework.
Persistent Applications Toolki
PAT stands for Persistent Applications Toolkit. Like many other software it simplifies developing of persistence layers of business 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)
QLOR (Q-LOGIC Object Relational Mapping Framework) is a performant Object/Relational Mapping and persistence/query framework for performant Object/Relational Mapping and persistence/query framework for Java. Its easy to use and deploy with other technologies. It is heightly structured and designed. Features: * O2O, O2M and M2M database mappings. * 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...
Daozero reduces DAO codes based on Spring & iBatis. The old way is to write codes and invoke iBatis API explicitly, but daozero 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.
SeQuaLite is a data access framework over jdbc. Features include CRUD operations, Lazy-Load, Cascading, Paging, on-the-fly SQL CRUD operations, Lazy-Load, Cascading, Paging, on-the-fly SQL generation. It helps reduce development time effectively.
Mr. Persister is an object persistence API, that makes it possible to read and write objects of any size to and from relational 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