AR for Java; ActiveObjects is an intuitive, pure-Java ORM. AO is designed from the ground up to be extremely simple and easy to use from an API standpoint. AO can be used with either an existing database schema, or it can auto-generate the database schema from the user-specified entity interfaces. ActiveObjects also supports Rails-style database migrations, allowing incremental changes and refactoring of the database schema without data loss.AO can perform better than data mapper ORMs due to its natural use of lazy-loading coupled with sophisticated caching mechanisms. However, performance is not the primary design goal of the project. Rather, the intention is to create an ORM which is powerful and yet extremely natural to use and integrate into your project. This design has lead to certain performance benefits (such as lazy-loading), but on the whole, data mapper ORMs are inherently slightly more performant than AO
Very interesting approach!
"Apache Empire-db is an Open Source relational data persistence component which allows database vendor independent dynamic query definition as well as safe and simple data retrieval and updating. Compared to most other solutions like e.g. Hibernate, TopLink, iBATIS or JPA implementations, Empire-db takes a considerably different approach, with a special focus on compile-time safety, reduced redundancies and improved developer productivity."
Hattori is a Java framework that simplifies Data Transfer Object population in n-tier web applications by using Java 5 annotations.
The framework is meant to be used at service layer and presentation layer. Given a domain object graph, a DTO object model subset is populated by Hattori which becomes available for modification which will could be later taken to the original domain object graph. Normally, the DTOs are populated at the service layer and sent to the presentation layer for that modification.
The population process is done by evaluating each Data Transfer Object annotated with the ObjectPopulation annotation, identifying operations to be executed on each one using one of these options: implicit rules, annotation rules or your own specific per-object defined java code.
The DataNucleus project provides products for the management of application data in a Java environment. Our aim is to provide good quality open source products to handle data in all of its forms, wherever it is stored. This goes from persistence of data into heterogeneous datastores, to providing methods of retrieval using a range of query languages, and eventually on to the analysis of data and tools for managing data quality. Your use of DataNucleus products will mean that you don't need to take significant time in learning the oddities of particular datastores, or query languages and instead use a single common interface for all of your data, and instead your team can concentrate their application development time on adding business logic and let DataNucleus take care of data management issues.
The Eclipse Persistence Services Project (EclipseLink) project's goal is to provide a complete persistence framework that is both comprehensive and universal. It will run in any Java environment and read and write objects to virtually any type of data source, including relational databases, XML, or EIS systems. EclipseLink will focus on providing leading edge support, including advanced feature extensions, for the dominant persistence standards for each target data source; Java Persistence API (JPA) for relational databases, Java Architecture for XML Binding (JAXB) for XML, J2EE Connector Architecture (JCA) for EIS and other types of legacy systems, and Service Data Objects (SDO).
The goal of Autofetch is reduce the modularity penalty and programmer burden of specifying associations which should be loaded with an object query. These specifications are sometimes are called fetch profiles, prefetch directives, or joins. These specifications are an important performance optimization because they reduce the number of round-trips to a persistence store whether that be a relational database, object database, or flat file. Autofetch is a library which integrates with object persistence tools and automatically handles prefetching data. Using dynamic program profiling, Autofetch determines the right prefetch directives for each query a program executes.
What is Ebean?
Ebean is a Object Relational Mapping Persistence Layer written in Java (Open Source LGPL license).
* Providing the features of EJB3's JPA (and more)
* No container required
* JPA compatible ORM mapping (@Entity, @OneToMany, ...)
Why use Ebean?
Ebean provides a simpler approach to Object Relational Mapping. It does this by not requiring session objects such as JPA EntityManager, JDO PersistenceManager, Hibernate Session, Toplink ClientSession.
jLynx is a simple, lite, hi-performance layer over the JDBC API. Persist and retrieve POJO and Map objects directly. Designed for developer productivity. Simpler, easy to learn, easy to configure as compared to Hibernate, JPA, etc.
jLynx generates JavaBean objects based on your database schema. For example if you have 24 tables and views in your database, jLynx will create 24 objects with properties that map to the field names in each table. The jLynx Generator creates the objects and compiles them. You can also use the generated source instead if you prefer to customize the objects. Using the API to persist objects is trivial.
jLynx Framework implements the Relational interface, which has all necessary methods to persist objects and fetch entire collections of objects.
jLynx leverages the strengths of SQL and the strengths of Java without having to write/maintain J2EE code. It is truly the best of both worlds.
Hibernate is a powerful, high performance object/relational persistence and query service. Hibernate lets you develop persistent classes following object-oriented idiom - including association, inheritance, polymorphism, composition, and collections. Hibernate allows you to express queries in its own portable SQL extension (HQL), as well as in native SQL, or with an object-oriented Criteria and Example API.
Simple Persistence for Java is an open source object-relational persistence library that uses a custom query language and built-in database support to simplify object persistence in Java applications.
JPOX is a free and fully compliant implementation of the JDO1, JDO2 specifications, providing transparent persistence of Java objects. It supports persistence to all of the major RDBMS on the market today, persistence to the DB4O object datastore, supporting all of the main Object-Relational Mapping (ORM) patterns demanded by today's applications, allows querying using either JDOQL, SQL, or JPQL, and comes with its own byte-code enhancer. JPOX is available under the Open Source Apache 2 license, allowing access to not just a top quality Java persistence implementation but also to the source code, allowing you to contribute to the success story of the principal standards-compliant Open Source persistence implementation in the world today.
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
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 sinc
Cayenne is a powerful, full-featured Java Object Relational Mapping framework. It is open source and completely free. Cayenne cross-platform modeling GUI tools place it in the league of its own, making it a very attractive choice over both closed source c