Padrão de Design DAO

DAO significa Data Access Object. O Padrão de Projeto DAO é usado para separar a lógica de persistência de dados em uma camada separada. Dessa forma, o serviço permanece completamente alheio a como as operações de baixo nível para acessar o banco de dados são realizadas. Isso é conhecido como o princípio de Separacão de Lógica.

Padrão de Projeto DAO

Com o padrão de projeto 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 de 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 uma API para implementação.
3. BookDaoImpl é uma classe concreta que é uma implementação da interface BookDao.

Vamos colocar essa lógica em um diagrama:

Classe de modelo do padrão DAO

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

É 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 ele 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 {

    // 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 principal:

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

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

Vantagens do padrão DAO

Há muitas vantagens em utilizar 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 MySQL para MongoDB, todas as alterações precisam ser feitas apenas na camada DAO.
2. O padrão DAO enfatiza o baixo acoplamento entre os 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 as interfaces e não com a implementação concreta.
3. Como a lógica de persistência é completamente separada, é muito mais fácil escrever testes unitários para os componentes individuais. Por exemplo, se estiver usando JUnit e Mockito como 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 enfatizamos o estilo “trabalhe 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 utilizar o padrão de design DAO para enfatizar a separação da lógica de persistência e, assim, deixar nossos componentes fracamente acoplados. Os padrões de design são apenas baseados em uma forma de programação e, portanto, são independentes de linguagem e framework. Sinta-se à vontade para deixar suas opiniões nos comentários abaixo. Baixe o projeto de exemplo DAO pelo link abaixo.

Baixe o Projeto de Exemplo do Padrão DAO

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