Data access object
||This article has multiple issues. Please help improve it or discuss these issues on the talk page.
This article is about the data access object design pattern in object-oriented software design. For the Microsoft library of the same name, see Data Access Objects.
In computer software, a data access object (DAO) is an object that provides an abstract interface to some type of database or other persistence mechanism. By mapping application calls to the persistence layer, DAOs provide some specific data operations without exposing details of the database. This isolation supports the Single responsibility principle. It separates what data accesses the application needs, in terms of domain-specific objects and data types (the public interface of the DAO), and how these needs can be satisfied with a specific DBMS, database schema, etc. (the implementation of the DAO).
Although this design pattern is equally applicable to most programming languages, most types of software with persistence needs, and most types of databases, it is traditionally associated with Java EE applications and with relational databases accessed via the JDBC API because of its origin in Sun Microsystems' best practice guidelines ("Core J2EE Patterns") for that platform.
The advantage of using data access objects is the relatively simple and rigorous separation between two important parts of an application that can and should know almost nothing of each other, and which can be expected to evolve frequently and independently. Changing business logic can rely on the same DAO interface, while changes to persistence logic do not affect DAO clients as long as the interface remains correctly implemented.
- can be used in a large percentage of applications - anywhere data storage is required.
- hide all details of data storage from the rest of the application.
- act as an intermediary between the application and the database. They move data back and forth between objects and database records.
- allow ripple effects from possible changes to the persistence mechanism to be confined to a specific area.
In the specific context of the Java programming language, Data Access Objects as a design concept can be implemented in a number of ways. This can range from a fairly simple interface that separates the data access parts from the application logic, to frameworks and commercial products. DAO coding paradigms can require some skill. Use of technologies like Java persistence technologies and JDO ensures to some extent that the design pattern is implemented. Technologies like Enterprise JavaBeans come built into application servers and can be used in applications that use a JEE application server. Commercial products like TopLink are available based on Object-relational mapping (ORM). Popular open source ORM products include Doctrine, Hibernate, iBATIS and Apache OpenJPA.
The expected benefit of use of Data Access Objects in a Java scenario is:
- Improved efficiency and performance of the data layer since it is standard reusable software.
- Modifications can be made to the DAO implementation without altering other decoupled modules of the application.
Tools and Frameworks
- AuDAO Generator for JDBC DAO (MySQL, Oracle) and Google App Engine datastore
- CodeFutures (Firestorm/DAO) Generator for JDBC DAO, Spring DAO, Hibernate DAO
- ComtorDAO Data Access Object Library for java Data Access Object Library for Java
- DB Solo EJB 3.0 DAO code generator
- EasyDriver Java library to create queries in order to be used in a DAO context.
- IBM pureQuery data access platform
- JingDAO DAO framework
- MDAOG DAO code generator for PostgreSQL databases
- nHydrate DAO/DTO framework, code generator for .NET
- ODB compiler-based object-relational mapping (ORM) system for C++
- ORMLite Lightweight Object Relational Mapping (ORM) Framework in Java for JDBC and Android
- PerfectJPattern Open Source Project, Provides componentized implementation of the DAO Pattern in Java (JPA, Hibernate and Spring)
- Persist ORM tool
- Simplest ORM
- EclipseLink Delivers a comprehensive open-source Java persistence solution addressing relational, XML, and database web services.
- Create, read, update and delete (CRUD)
- Data Access Layer
- Data Transfer Object
- Design Patterns (book)
- Service Data Objects
- "Core J2EE Patterns - Data Access Objects". Sun Microsystems Inc. 2007-08-02.