Apache Commons JDBC Utility
DbUtils is a small set of classes designed to make working with JDBC easier. JDBC resource cleanup code is mundane, error prone work so these classes abstract out all of the cleanup tasks from your code leaving you with what you really wanted to do with JDBC in the first place: query and update data.
Some of the advantages of using DbUtils are:
* No possibility for resource leaks. Correct JDBC coding isn't difficult but it is time-consuming and tedious. This often leads to connection leaks that may be difficult to track down.
* Cleaner, clearer persistence code. The amount of code needed to persist data in a database is drastically reduced. The remaining code clearly expresses your intention without being cluttered with resource cleanup.
* Automatically populate JavaBean properties from ResultSets. You don't need to manually copy column values into bean instances by calling setter methods. Each row of the ResultSet can be represented by one fully populated bean instance.
Related Articles
LdapTemplate: LDAP Programming in Java Made Simple
If you've worked with LDAP in Java, you're probably familiar with its JDBC-like hassles: lots of plumbing code, tedious iteration over results, pedantic cleanup, and exception handling hassles. The Spring-based LdapTemplate project alleviates many of those hassles. Ulrik Sandberg and Mattias Arthursson introduce you to the advantages of this approach.
Bridging the Gap Between Open Source and Commercial Applications
Migrating EJB 2.0 entity beans to Hibernate POJOs is pretty straightforward. Like many applications, all of the data for HQ is stored in the database, and we need to map from the underlying data store to an object-oriented view. In EJB 2.0, you would model that data with entity beans. An entity bean is created and found through the Home interface, and its fields are modified through its Local/Remote interface. These interface classes are automatically generated when we use XDoclet to annotate our entity bean implementations. We define the actual implementations in *EJBImpl classes.
Java Feature — Concurrent Queries
Does this sound familiar? You have a domain object, perhaps for reporting purposes, that's built from a ton of JDBC queries and it takes too long to load. Nothing else happens until this object is built, so it's become a bottleneck. Even worse, each of the queries is actually well tuned, so there isn't much to gain from modifying the queries themselves - there are just too many of them. You don't want to change (or can't change) your data model, so what can be done to alleviate this problem short of a major redesign? There are several options like caching, lazy loading, resource pooling. Another worthy option would be to implement a variation of the concurrent query pattern.
Java Feature — Concurrent Queries
Does this sound familiar? You have a domain object, perhaps for reporting purposes, that's built from a ton of JDBC queries and it takes too long to load. Nothing else happens until this object is built, so it's become a bottleneck. Even worse, each of the queries is actually well tuned, so there isn't much to gain from modifying the queries themselves - there are just too many of them. You don't want to change (or can't change) your data model, so what can be done to alleviate this problem short of a major redesign? There are several options like caching, lazy loading, resource pooling. Another worthy option would be to implement a variation of the concurrent query pattern.
Java Feature — Concurrent Queries
Does this sound familiar? You have a domain object, perhaps for reporting purposes, that's built from a ton of JDBC queries and it takes too long to load. Nothing else happens until this object is built, so it's become a bottleneck. Even worse, each of the queries is actually well tuned, so there isn't much to gain from modifying the queries themselves - there are just too many of them. You don't want to change (or can't change) your data model, so what can be done to alleviate this problem short of a major redesign? There are several options like caching, lazy loading, resource pooling. Another worthy option would be to implement a variation of the concurrent query pattern.
jdbc-utils
jdbc-utils is an alternative reusable code to dbutils developed by jakarta, provides a set of java classes to building dinamically sql statements and executing its without working with jdbc API
safejdbcSafeJDBC is a Java library that simplifies the use of JDBC. The main goal during development was, to provide a library wich prevents a user from coding resource leaks.
SafeJDBC is fully documented and ready to run.
treedrawTreeDraw is a object-oriented Java class framework to aid in visualizing tree data strucures. It consists of a few abstract classes. If you derive your tree, nodes, and edges from these abstract classes, you can easily visualize your data structure.
ldbcLDBC (Liberty Data Base Connectivity) is a JDBC driver that provides vendor-independent database access. With LDBC, your application will just work on all major databases and you don't have to change any source code. LDBC is based on ANSI-SQL and JDBC.