Java Data Access

Chapter 1 - Introducing Java Data Access Development

Taking Stock of Enterprise Data Stores

Database systems
Naming and directory services
XML services

Introducing Java Data Access Technologies

JDBC 3.0
JNDI
JDO
Java XML APIs

Chapter 2 - A Relational Database Primer

The RDBMS in a Nutshell

Understanding data storage
Ensuring data integrity

Reviewing SQL Basics

Using Data Manipulation Language (DML)
Using Data Definition Language (DDL)

Chapter 3 - Setting Up Your First JDBC Query

Configuring JDBC

Obtaining JDBC drivers
Installing the JDBC driver

Examining the Common JDBC Components
Writing Your First JDBC Application

Creating the sample application
Compiling and running the application
Troubleshooting the sample application

Chapter 4 - Connecting to Databases with JDBC

Understanding JDBC Drivers

What are JDBC drivers?
Using your JDBC driver

Working with Connection Objects

Understanding JDBC URLs
Opening connections
Closing JDBC connections

Chapter 5 - Building JDBC Statements

Using JDBC Statements
Introducing Statement Objects

Creating the Statement object
Using the Statement object
JDBC batch processing
JDBC transactions
Closing the Statement object

Working with PreparedStatement Objects

Creating the PreparedStatement object
Using the PreparedStatement object

Working with CallableStatement Objects

Creating the CallableStatement object
Using the CallableStatement object

Chapter 6 - Working with Result Sets

What Are JDBC Result Sets?
Introducing Result Set Concepts

Result set cursors
Result set types
Retrieving result set data

Using Standard Result Sets

Creating a standard result set
Moving data around in a standard result set

Using Scrollable Result Sets

Creating scrollable result sets
Moving around scrollable result sets

Using Updateable Result Sets

Creating updateable result sets
Updating data with updateable result set
Inserting and deleting data with updateable result sets

Chapter 7 - Understanding JDBC Data Types

Java, Databases, and Data Types
Java-to-JDBC Data-Type Mappings
JDBC-to-Java Data-Type Mappings

Standard SQL data types
Advanced SQL data types

Custom Data Type Mapping

Building custom data type maps
Using custom mapping

Chapter 8 - Mining Database Metadata with JDBC

The JDBC Metadata Interfaces
The ResultSetMetaData Interface

Creating ResultSetMetaData objects
Using ResultSetMetaData objects
ResultSetMetaData example

The DatabaseMetaData Interface

Creating DatabaseMetaData objects
Using DatabaseMetaData objects
DatabaseMetaData example

Chapter 9 - Understanding Design Patterns

What Are Design Patterns?
Categories of Design Patterns

Creational patterns
Structural patterns
Behavioral patterns

Java and Design Patterns

Inheritance
Composition
Design-pattern implementation guidelines

Chapter 10 - Building the Singleton Pattern

What Is a Singleton Pattern?
Structure of the Singleton Pattern
Using the Singleton Pattern

Basic Singleton example
Connection manager Singleton example

Chapter 11 - Producing Objects with the Factory Method Pattern

What Is the Factory Method Pattern?
Introducing the Factory Method Structure
Using the Factory Method

Chapter 12 - Creating a Façade Pattern

What Is the Façade Pattern?
Introducing the Structure of the Façade Pattern
Implementing the Façade Pattern

Chapter 13 - Accessing Enterprise Data with JNDI

Naming and Directory Services

Naming services
Directory services

Data Access with JNDI

JNDI architecture
JNDI programming
Working with the JNDI LDAP SPI

Chapter 14 - Using Data Sources and Connection Pooling

Working with Java DataSource Objects

Using DataSource objects
Looking at DataSource implementations
A DataSource example
Using DataSource objects with JNDI

Implementing Connection Pooling

Understanding connection-pooling concepts
A connection-pooling example

Chapter 15 - Understanding Distributed Transactions

Understanding the Basics

Transaction definition and properties
Two-phase commit
Transaction-processing performance and availability
Replication

Understanding Distributed Transactions

Understanding the Transaction Monitor
Understanding the Transaction Service

Distributed Transactions and Java

EIS and EAI
JMS
JTS and JTA
EJBs

Chapter 16 - Working with JDBC Rowsets

Introducing JDBC Rowsets
Understanding Rowset Concepts

Rowset implementations
Examining the rowset architecture

Working with RowSet Objects

Setting rowset properties
Configuring rowset events
Setting rowset connection properties
Executing SQL commands using rowsets
Fetching data from a rowset
Traversing data in a rowset
Controlling scrollable and updateable properties
Setting transaction levels
Cleaning up after a RowSet

Using the JdbcRowSet Class
Using the CachedRowSet Class

Serializing a CachedRowSet object
Updating and inserting disconnected rowset data

Using the WebRowSet Class

Chapter 17 - Building Data-centric Web Applications

Reviewing Enterprise Web Applications

Two-tier Web architecture
MVC design pattern
Three-tier Web architecture
n-tier Web architecture
J2EE enterprise application framework

Using JDBC with Servlets

Servlet overview
Constructing a JDBC servlet
Server deployment
Design considerations

Using JDBC with JavaServer Pages

JSP overview
Constructing a JSP page
Using JDBC in JSP pages
Using JSP with JDBC JavaBeans
Design considerations

Chapter 18 - Using XML with JAXP

Introducing XML

What is XML?
Namespaces
Document Type Definitions and XML Schemas
XML Databases

Working with XML—The Basics

Parsing XML: The Simple API for XML (SAX)
Traversing XML: The Document Object Model (DOM)
Transforming XML: XSLT

Using the JAXP API

Where to get the JAXP API
Using JAXP
Parsing XML with JAXP
Traversing XML with JAXP
Transforming XML with JAXP

Chapter 19 - Accessing Data with Enterprise JavaBeans

Working with the EJB Tier

Enterprise bean types
The Parts of an EJB

Introducing EJB Classes and Interfaces

Session beans
Entity beans
Message-Driven beans

Understanding the EJB Life Cycle

Session beans
Entity beans
Message-Driven beans

Dealing with Data Persistence

Object serialization
Managed persistence

Using Data Access Objects
Using Value Objects
Transactions and EJBs
Guidelines for Working with EJBs

Appendix A: JDBC 3.0 New Features Summary

Appendix B: Java Database Programming on Linux

Appendix C: JDBC Error Handling

Appendix D: UML Class Diagram Quick Reference