ONJava.com -- The Independent Source for Enterprise Java
oreilly.comSafari Books Online.Conferences.


AddThis Social Bookmark Button

Java Database Connectivity (JDBC)

Java Database Connectivity (JDBC)

JDBC API allows access to almost any tabular data source from the Java programming language. It provides cross-DBMS connectivity to a wide range of SQL databases, including SQLJ. With the new JDBC API, access to other tabular data sources, such as spreadsheets or flat files is also available.

Spring: Integrating iBATIS (ONJava.com)
iBATIS is one of the object-relational (OR) frameworks embraced by the Spring framework, and it's an ideal choice for those seeking a middle ground between full-blown OR and hand-written JDBC. In this excerpt from Spring: A Developer's Notebook, Bruce Tate and Justin Gehtland show how to integrate iBATIS with Spring.

Lightweight R/O Mapping (ONJava.com)
O/R frameworks map Java classes to database tables and SQL code. While popular, this approach is unpopular among DBAs, with the database at the mercy of an external tool. Another approach is to go the other direction: write tables and stored procedures and generate Java classes from that. Norbert Ehreke introduces Amber, a framework that embodies this approach.

Hibernate for Java SE (ONJava.com)
For many, Hibernate goes hand in hand with Java EE as part of their enterprise development strategy. But what if you need access to your data access objects outside of the EE container? Jason Lee offers some strategy for getting and using a Hibernate session from Java SE code.

iBatis DAO (ONJava.com)
The J2EE Data Access Object pattern calls for encapsulating access to a data source behind an API, giving you the freedom to change implementations or use different persistence strategies for different operations. As Sunil Patil shows, the Apache iBatis DAO framework helps you develop such a strategy.

Simple Object Persistence with the db4o Object Database (ONJava.com)
Mapping Java objects to relational databases is a difficult task, fraught with perils and gotchas. db4o dodges the issue entirely by providing an object-oriented persistence mechanism that is small, lightweight and efficient. Jim Paterson shows how it works.

An Introduction to JDBC, Part 3 (ONJava.com)
In part three of this four-part excerpt on JDBC from Java Enterprise in a Nutshell, learn about error handling, prepared statements, BLOBs and CLOBs.

An Introduction to JDBC, Part 2 (ONJava.com)
Part Two of this excerpt from Java Enterprise in a Nutshell focuses on database connection, statements and results.

An Introduction to JDBC, Part 1 (ONJava.com)
In this excerpt from Chapter 2 of Java Enterprise in a Nutshell, the authors introduce the JDBC architecture.

DDL Statements and Transactions (ONJava.com)
Learn how to add SQLJ statements to Java programs that use the embedded SQL Data Definition Language.

Database Access Using Lightweight Applets (ONJava.com)
Using lightweight applet technology, you can bring the full weight of Java's GUI capability and the advantages of client-side dynamic database access to your Web applications. Because the technology employs HTTP to communicate with a database via SqlServlet, lightweight applets perform well, yet remain small enough to have acceptable download times.

Java Programming with Oracle JDBC: Performance (ONJava.com)
When it comes to JDBC performance issues, there are two major factors to consider: performance of the database structure and the SQL statements used against it and relative efficiency of the different ways you can use the JDBC interfaces to manipulate a database. This excerpt from Java Programming with Oracle JDBC explores these.

Dynamic Database Access from Client-Side JavaScript (ONJava.com)
Imagine the advantages of being able to dynamically access a database from client-side JavaScript. You could dynamically query a database from JavaScript for client-side field validation, or dynamically populate a drop-down select list, to name just a few possibilities. In fact, you can do this with the help of an applet-servlet pair. This article describes the applet-servlet pair architecture and offers several sample applications.

Introducing Automatic Data Expiration (ONJava.com)
How you choose to expire data can make the difference between an application that scales to enterprise quality and one that doesn't. In the first of this three-part series, William Grosso covers the fundamentals of data expiration, and presenting solutions of increasing functionality.

Setting Up Your Environment to Develop SQLJ Programs (ONJava.com)
Jason Price describes how to set up your environment to develop SQLJ applications, and he demonstrates a "Hello World" program that uses SQLJ to access a database.

Tuning JDBC: Measuring JDBC performance (ONJava.com)
Many Java apps are dependent on Java Database Connectivity, but how do you measure JDBC's performance, and which subsystems need optimizing?

Getting Up To Date with JDBC API (ONJava.com)
Object Computing's Jeff Brown covers the JDBC 3.0 specification in its proposed final draft form, which promises to add more robust transactions by way of savepoints, a number of resource pooling enhancements, retrieval of auto-generated keys and a lot more.

Resources and links: