Modèle de conception DAO

DAO signifie Data Access Object. Le DAO Design Pattern est utilisé pour séparer la logique de persistance des données dans une couche distincte. De cette façon, le service reste totalement dans l’ignorance de la manière dont les opérations de bas niveau pour accéder à la base de données sont effectuées. Cela correspond au principe de Séparation de la Logique.

DAO Design Pattern

Avec le design pattern DAO, nous avons les composants suivants sur lesquels repose notre conception :

• Le modèle qui est transféré d’une couche à l’autre.
• Les interfaces qui offrent une conception flexible.
• L’implémentation de l’interface qui est une implémentation concrète de la logique de persistance.

Mise en œuvre du modèle DAO

Avec les composants mentionnés ci-dessus, essayons d’implémenter le modèle DAO. Nous utiliserons ici 3 composants :

1. Le modèle Book qui est transféré d’une couche à l’autre.
2. L’interface BookDao qui offre une conception flexible et une API à implémenter.
3. BookDaoImpl classe concrète qui est une implémentation de l’interface BookDao.

Plaçons cette logique dans un diagramme:

Modèle de classe du modèle de motif DAO

Maintenant, mettons en place notre objet modèle.

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éthodes getter setter
}

C’est un objet simple avec seulement 2 propriétés pour simplifier les choses.

Interface du motif DAO

Définissons l’interface pour accéder aux données associées à elle au niveau de la persistance.

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

Implémentation du motif DAO

Ensuite, nous créons une classe concrète implémentant l’interface ci-dessus.

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 liste fonctionne comme une base de données
    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);
    }
}

Utilisation du motif DAO

Enfin, nous mettons en œuvre cette implémentation dans notre méthode principale :

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

        //mettre à jour l'étudiant
        Books book = bookDao.getAllBooks().get(1);
        book.setBookName("Algorithms");
        bookDao.saveBook(book);
    }
}

Avantages du modèle DAO

Il existe de nombreux avantages à utiliser le modèle DAO. En voici quelques-uns :

1. Lorsque vous modifiez un mécanisme de persistance, la couche de service n’a même pas besoin de savoir d’où proviennent les données. Par exemple, si vous envisagez de passer de MySQL à MongoDB, toutes les modifications doivent être apportées uniquement dans la couche DAO.
2. Le modèle DAO met l’accent sur le faible couplage entre les différents composants d’une application. Ainsi, la couche Vue ne dépend pas de la couche DAO et seule la couche Service en dépend, même avec les interfaces et non avec une implémentation concrète.
3. Comme la logique de persistance est complètement séparée, il est beaucoup plus facile d’écrire des tests unitaires pour les composants individuels. Par exemple, si vous utilisez JUnit et Mockito comme frameworks de test, il sera facile de simuler les composants individuels de votre application.
4. Comme nous travaillons avec des interfaces dans le modèle DAO, il met également l’accent sur le style « travailler avec des interfaces plutôt qu’avec une implémentation », qui est un excellent style de programmation orientée objet.

Conclusion du modèle DAO

Dans cet article, nous avons appris comment nous pouvons utiliser le modèle de conception DAO pour mettre l’accent sur la séparation de la logique de persistance et ainsi, rendre nos composants moins couplés. Les modèles de conception sont simplement basés sur une manière de programmer et donc, sont indépendants du langage et du framework. N’hésitez pas à laisser vos avis dans les commentaires ci-dessous. Téléchargez l’exemple de projet DAO depuis le lien ci-dessous.

Télécharger le Projet Exemple de Modèle DAO

Références : Documentation Oracle, Wikipedia.