Modello di progettazione DAO

DAO sta per Data Access Object. Il Design Pattern DAO viene utilizzato per separare la logica di persistenza dei dati in uno strato separato. In questo modo, il servizio rimane completamente all’oscuro di come vengono eseguite le operazioni a basso livello per accedere al database. Questo è noto come il principio di Separazione della Logica.

Design Pattern DAO

Con il design pattern DAO, abbiamo i seguenti componenti su cui si basa il nostro design:

• Il modello che viene trasferito da uno strato all’altro.
• Le interfacce che forniscono un design flessibile.
• L’implementazione dell’interfaccia, che è un’implementazione concreta della logica di persistenza.

Implementazione del pattern DAO

Con i componenti sopra menzionati, cerchiamo di implementare il pattern DAO. Utilizzeremo 3 componenti qui:

1. Il modello Book che viene trasferito da uno strato all’altro.
2. L’interfaccia BookDao che fornisce un design flessibile e un’API per l’implementazione.
3. BookDaoImpl classe concreta che è un’implementazione dell’interfaccia BookDao.

Mettiamo questa logica in un diagramma:

Classe modello del pattern DAO

Ora, mettiamo su il nostro oggetto modello.

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

    // metodi getter setter
}

È un oggetto semplice con solo 2 proprietà per mantenere le cose semplici.

Interfaccia del pattern DAO

Definiamo l’interfaccia per accedere ai dati associati ad essa a livello di persistenza.

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

Implementazione del pattern DAO

Successivamente, creiamo una classe concreta che implementi l’interfaccia sopra.

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 funziona come un database
    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);
    }
}

Utilizzando il pattern DAO

Infine, mettiamo in uso questa implementazione nel nostro metodo 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());
        }

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

Vantaggi del pattern DAO

Ci sono molti vantaggi nell’utilizzare il pattern DAO. Enunciamo alcuni di essi qui:

1. Durante il cambiamento di un meccanismo di persistenza, il livello di servizio non deve neanche sapere da dove provengano i dati. Ad esempio, se stai pensando di passare dall’uso di MySQL a MongoDB, tutte le modifiche devono essere apportate solo nel livello DAO.
2. Il pattern DAO enfatizza il basso accoppiamento tra i diversi componenti di un’applicazione. Quindi, il livello di visualizzazione non ha dipendenza dal livello DAO e solo il livello di servizio dipende da esso, anche quello con le interfacce e non dall’implementazione concreta.
3. Poiché la logica di persistenza è completamente separata, è molto più facile scrivere test unitari per i singoli componenti. Ad esempio, se stai utilizzando JUnit e Mockito come framework di test, sarà facile simulare i singoli componenti della tua applicazione.
4. Poiché lavoriamo con le interfacce nel pattern DAO, si enfatizza anche lo stile “lavorare con le interfacce anziché con l’implementazione”, che è un ottimo stile di programmazione OOP.

Conclusioni sul pattern DAO

In questo articolo abbiamo appreso come possiamo utilizzare il pattern di progettazione DAO per mettere in evidenza la separazione della logica di persistenza e, di conseguenza, la bassa accoppiatura dei nostri componenti. I pattern di progettazione si basano solo su un modo di programmazione e quindi sono indipendenti dal linguaggio e dal framework. Sentitevi liberi di lasciare i vostri commenti qui sotto. Scaricate l’esempio di progetto DAO dal link sottostante.

Scarica l’esempio di progetto del pattern DAO

Riferimenti: Documentazione Oracle, Wikipedia.