Data Access Pattern: Database Interaction in Object-Oriented Applications: Database Interaction in Object-Oriented Applications

Author: Clifton Nock
Publisher:
Publication Date: 2004-06-01
Features: This book is written for software architects, designers, and engineers responsible for building data access software components. Additionally, the material in this book is also suitable for students who wish to understand common data access problems and solutions. The patterns in this book are described using general database and object-oriented concepts and terminology. Readers should have a basic understanding of both areas. If you encounter unfamiliar terms, refer to the glossary at the end of this book. The patterns described in this book are applicable to multiple platforms, programming languages, and databases. Each pattern's example code is written using Java 2 Standard Edition (J2SE), Java 2 Enterprise Edition (J2EE), and Java Database Connectivity (JDBC) APIs. The example code represents database operations using Structured Query Language (SQL). If readers have some familiarity with Java and JDBC, it will be helpful to study these example codes, but it is not required. Comments and explanations are provided for less intuitive code.
How This Book Is Organized
This book is a catalog of patterns, detailing a set of data access patterns. The patterns are organized into several different sections based on their applicability. Because this is a catalog, there is no need to force yourself to read the descriptions of the patterns in order. If a pattern depends on concepts defined in other pattern descriptions, this will be clearly indicated. Patterns are identified using concise, descriptive, and familiar names. The names of the patterns are important because you can use them in discussions and writings. Describing a set of interacting classes as instances of resource decorators is more effective than repeatedly detailing each component of the pattern.
The "Introduction" of this book explains the motivation for researching and applying data access patterns and briefly introduces each pattern. This chapter also defines the form used to describe the details of the patterns in later chapters. The rest of the book is the pattern catalog, dividing each category of patterns into a section:
● Part "Decoupling Patterns" describes patterns that decouple data access code from other application logic, producing clearer application code and reducing the likelihood of defects caused by modifications related only to data access details.
● Part "Resource Patterns" describes patterns for effectively managing database resources.
● Part "Input/Output Patterns" describes patterns that simplify input/output operations, using consistent transformations between physically represented relational data and domain object representations.
● Part "Cache Patterns" describes patterns for implementing strategic data caching, addressing the trade-off between data access optimization and caching overhead.
● Part "Concurrency Patterns" describes patterns for implementing concurrency strategies. Effective and high-quality data access code is crucial for the performance and applicability of any enterprise application in the real world. There is no better way to improve existing systems than to optimize data access code. Regardless of the database engine, platform, language, or application, developers constantly encounter the same relational database access challenges. In this book, Clifton Nock identifies 25 proven solutions, presenting each in a concise and user-friendly format. These patterns comprehensively address a wide range of problems, including creating effective database-agnostic applications, hiding ambiguous database semantics from users, accelerating database resource initialization, simplifying development and maintenance, improving support for concurrency and transactions, and eliminating data access bottlenecks. Each pattern is illustrated with fully commented Java/JDBC code examples and represented using UML diagrams for interfaces, classes, and relationships.
· Decoupling Patterns: Build cleaner and more reliable systems by decoupling data access code from other application logic.
· Resource Patterns: Manage relational database resources more effectively.
· Input/Output Patterns: Simplify I/O operations by consistently transforming between the "physical" relational data and the domain object representation of that data.
· Cache Patterns: Use caching strategies to optimize the trade-off between data access optimization and caching overhead.
· Concurrency Patterns: Implement concurrency and transactions more efficiently and reliably.
This book reveals techniques previously used only in robust data access solutions, making them accessible to every software developer, architect, and designer.