Padrão de Projeto DAO

DAO significa Data Access Object. O Padrão de Design DAO é usado para separar a lógica de persistência de dados em uma camada separada. Dessa forma, o serviço permanece completamente no escuro sobre como as operações de baixo nível para acessar o banco de dados são feitas. Isso é conhecido como o princípio da Separation of Logic (Separação da Lógica).

Padrão de Design DAO

Com o padrão de design DAO, temos os seguintes componentes nos quais nosso design depende:

• O modelo que é transferido de uma camada para a outra.
• As interfaces que fornecem um design flexível.
• A implementação da interface que é uma implementação concreta da lógica de persistência.

Implementando o padrão DAO

Com os componentes mencionados acima, vamos tentar implementar o padrão DAO. Usaremos 3 componentes aqui:

1. O modelo Book que é transferido de uma camada para a outra.
2. A interface BookDao que fornece um design flexível e API para implementar.
3. BookDaoImpl classe concreta que é uma implementação da interface BookDao.

Vamos colocar essa lógica em um diagrama:

Classe do modelo do padrão DAO

Agora, vamos apresentar nosso objeto 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
}

É um objeto simples com apenas 2 propriedades para manter as coisas simples.

Interface do padrão DAO

Vamos definir a interface para acessar os dados associados a ela no nível de persistência.

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);
}

Implementação do padrão DAO

Em seguida, criamos uma classe concreta implementando a interface acima.

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 {

    // a lista está funcionando como um banco de dados
    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 o padrão DAO

Finalmente, colocamos esta implementação em uso no nosso método main():
//atualizar aluno

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());
        }

        

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

Vantagens do padrão DAO

Existem muitas vantagens em usar o padrão DAO. Vamos listar algumas delas aqui:

1. Ao alterar um mecanismo de persistência, a camada de serviço nem precisa saber de onde vêm os dados. Por exemplo, se estiver pensando em mudar de usar MySQL para MongoDB, todas as alterações precisam ser feitas apenas na camada DAO.
2. O padrão DAO enfatiza o baixo acoplamento entre diferentes componentes de uma aplicação. Assim, a camada de visualização não tem dependência da camada DAO, e apenas a camada de serviço depende dela, mesmo assim com interfaces e não com implementação concreta.
3. Como a lógica de persistência é completamente separada, é muito mais fácil escrever testes unitários para componentes individuais. Por exemplo, se estiver usando JUnit e Mockito para frameworks de teste, será fácil simular os componentes individuais da sua aplicação.
4. Como trabalhamos com interfaces no padrão DAO, também enfatiza o estilo de “trabalhar com interfaces em vez de implementação”, que é um excelente estilo de programação OOP.

Conclusão do Padrão DAO

Neste artigo, aprendemos como podemos usar o padrão de design DAO para enfatizar a separação da lógica de persistência e, assim, manter nossos componentes pouco acoplados. Os padrões de design baseiam-se apenas em uma forma de programação e, portanto, são independentes de linguagem e framework. Sinta-se à vontade para deixar seus comentários abaixo. Baixe o projeto de exemplo DAO no link abaixo.

Baixar Projeto de Exemplo do Padrão DAO

Referências: Documentação Oracle, Wikipedia.