Current we support:
Hibernate 3.1
Java Persistence API (sometimes called JPA or EJB3 persistence)
Db4Objects (a lightweight object database)
It works inside a Java EE container, inside a plain Servlet environment or in a purely SE environment such as a desktop application (with obvious limitations--cant use session-per-http-request strategy outside a servlet environment for instance
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."
Joda-Time provides a complete quality alternative to the JDK date and time classes. At some point however, many projects need to persist these classes to a database. One popular tool for achieving this is Hibernate.
To ease the integration of Joda-Time and Hibernate, this sub-project was setup. It aims to provide the classes necessary to persist Joda-Time objects.
***No, no, no - needs HibernateDaoSupport! Bad! *** Another promising GenericDao framework: "Generic DAO (a.k.a generic-dao OR gendao) is a Java package which allows a developer to skip writing DAOs for their persistence objects when they are using Spring and JDBC or Hibernate. It is a lightweight ORM package without the loss of control or increase in complexity which is experienced with some of the heavier weight ORM packages.
It is designed to make it easier and faster for developers to write their DAOs without having to rewrite the same old boring save/delete/etc functions over and over for each persistent type but also not having to have implementation dependencies in their DAO interfaces. It also allows for good control over which persistent objects are usable within the DAO and is easy to extend so you can add your own DAO methods. Configuration is easily handled via spring configuration but can also be handled programmatically, however, since the package depends on the spring framework you are best off using it with spring.
Generic DAO allows a developer to write their persistent objects as POJOs with no dependencies. It supports an approach between the anemic domain model (or service/manager model) methodology and the use of a rich domain model (or heavy DDD). The use of simple POJOs as persistent objects makes it easy to swap around storage mechanisms while allowing the developer to use their model objects throughout their application and even expose them for use by other applications.
The package includes functionality for all the basic ORM CRUD type methods along with search methods and batch methods. The JDBC part of the package includes support for caching all the DAO methods (which could also be used with the hibernate part but hibernate has its own caching so you should probably use that). It also includes interceptor points for before and after all read and write methods. For simpler use cases, you can write your POJOs, make them persistent, create your DDL and not have to write a single line of DAO code. The package is built on and depends on the spring framework."
Java toolkit which makes DAO manager creating easier. It produced DAO compatible with JPA specification. It has implemented CRUD operations and some features (active, hidden, default, etc.). It also extends standard API for criteria (like Hibernate ones).
PathProxy is a design pattern for persisting complex relationships without cluttering up your database. In this article JavaWorld contributor Matthew Tyson introduces his PathProxy pattern and walks you through an example application implementation based on Spring, JSF, and JPA/Hibernate.
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.
As also described in the Hibernate book from King and Bauer: "With the adoption of Java™ 5 generics, the idea of a generic typesafe Data Access Object (DAO) implementation has become feasible. In this article, system architect Per Mellqvist presents a generic DAO implementation class based on Hibernate. He then shows you how to use Spring AOP introductions to add a typesafe interface to the class for query execution."
HiberObjects is an Eclipse plugin for object oriented design of classes and unit tests for Java Persistence API or Hibernate. PropertyChange support and DTO's for Google Web Toolkit (GWT) can also be generated.
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.