Patrón de diseño DAO

DAO significa Objeto de Acceso a Datos. El patrón de diseño DAO Design Pattern se utiliza para separar la lógica de persistencia de datos en una capa independiente. De esta manera, el servicio permanece completamente ajeno a cómo se realizan las operaciones de bajo nivel para acceder a la base de datos. Esto se conoce como el principio de Separación de Lógica.

Patrón de Diseño DAO

Con el patrón de diseño DAO, tenemos los siguientes componentes en los que se basa nuestro diseño:

• El modelo que se transfiere de una capa a otra.
• Las interfaces que proporcionan un diseño flexible.
• La implementación de la interfaz, que es una implementación concreta de la lógica de persistencia.

Implementación del patrón DAO

Con los componentes mencionados anteriormente, intentemos implementar el patrón DAO. Utilizaremos 3 componentes aquí:

1. El modelo Book que se transfiere de una capa a otra.
2. La interfaz BookDao que proporciona un diseño flexible y una API para implementar.
3. BookDaoImpl es una clase concreta que es una implementación de la interfaz BookDao.

Vamos a poner esta lógica en un diagrama:

Clase de modelo del Patrón DAO

Ahora, pongamos nuestro objeto de modelo.

package com.journaldev.model;

public class Books {

    private int isbn;
    private String bookName;

    public Books() {
    }

    public Books(int isbn, String bookName) {
        this.isbn = isbn;
        this.bookName = bookName;
    }

    // métodos getter setter
}

Es un objeto simple con solo 2 propiedades para mantener las cosas simples.

Interfaz del Patrón DAO

Definamos la interfaz para acceder a los datos asociados con él a nivel de persistencia.

package com.journaldev.dao;

import com.journaldev.model.Books;

import java.util.List;

public interface BookDao {

    List<Books> getAllBooks();
    Books getBookByIsbn(int isbn);
    void saveBook(Books book);
    void deleteBook(Books book);
}

Implementación del Patrón DAO

A continuación, creamos una clase concreta que implementa la interfaz anterior.

package com.journaldev.daoimpl;

import com.journaldev.dao.BookDao;
import com.journaldev.model.Books;

import java.util.ArrayList;
import java.util.List;

public class BookDaoImpl implements BookDao {

    // la lista está funcionando como una base de datos
    private List books;

    public BookDaoImpl() {
        books = new ArrayList<>();
        books.add(new Books(1, "Java"));
        books.add(new Books(2, "Python"));
        books.add(new Books(3, "Android"));
    }

    @Override
    public List getAllBooks() {
        return books;
    }

    @Override
    public Books getBookByIsbn(int isbn) {
        return books.get(isbn);
    }

    @Override
    public void saveBook(Books book) {
        books.add(book);
    }

    @Override
    public void deleteBook(Books book) {
        books.remove(book);
    }
}

Usando el Patrón DAO

Finalmente, ponemos esta implementación en uso en nuestro método main():

package com.journaldev;

import com.journaldev.dao.BookDao;
import com.journaldev.daoimpl.BookDaoImpl;
import com.journaldev.model.Books;

public class AccessBook {

    public static void main(String[] args) {

        BookDao bookDao = new BookDaoImpl();

        for (Books book : bookDao.getAllBooks()) {
            System.out.println("Book ISBN : " + book.getIsbn());
        }

        //actualizar estudiante
        Books book = bookDao.getAllBooks().get(1);
        book.setBookName("Algorithms");
        bookDao.saveBook(book);
    }
}

Ventajas del patrón DAO

Existen muchas ventajas para usar el patrón DAO. Veamos algunas de ellas aquí:

1. Mientras se cambia un mecanismo de persistencia, la capa de servicio ni siquiera tiene que saber de dónde provienen los datos. Por ejemplo, si estás pensando en cambiar de MySQL a MongoDB, todos los cambios necesarios se deben realizar solo en la capa DAO.
2. El patrón DAO enfatiza el bajo acoplamiento entre diferentes componentes de una aplicación. Por lo tanto, la capa de vista no tiene dependencia de la capa DAO y solo la capa de servicio depende de ella, incluso eso con las interfaces y no desde la implementación concreta.
3. Como la lógica de persistencia está completamente separada, es mucho más fácil escribir pruebas unitarias para componentes individuales. Por ejemplo, si estás usando JUnit y Mockito como frameworks de prueba, será fácil simular los componentes individuales de tu aplicación.
4. Como trabajamos con interfaces en el patrón DAO, también se enfatiza el estilo de “trabajar con interfaces en lugar de implementaciones”, que es un excelente estilo de programación OOP.

Conclusión del Patrón DAO

En este artículo, aprendimos cómo podemos utilizar el patrón de diseño DAO para enfatizar la separación de la lógica de persistencia y así, mantener nuestros componentes poco acoplados. Los patrones de diseño se basan simplemente en una forma de programación y, por lo tanto, son independientes del lenguaje y del marco de trabajo. Siéntase libre de dejar sus opiniones en los comentarios a continuación. Descargue el proyecto de ejemplo DAO desde el siguiente enlace.

Descargar Proyecto de Ejemplo del Patrón DAO

Referencias: Documentación de Oracle, Wikipedia.