DAO Design Pattern

DAO steht für Data Access Object. Das DAO Designmuster wird verwendet, um die Datenpersistenzlogik in einer separaten Schicht zu trennen. Auf diese Weise bleibt der Service völlig im Dunkeln darüber, wie die Low-Level-Operationen zum Zugriff auf die Datenbank durchgeführt werden. Dies ist als das Prinzip der Trennung von Logik bekannt.

DAO Designmuster

Mit dem DAO Designmuster haben wir folgende Komponenten, auf die unser Design abhängt:

• Das Modell, das von einer Schicht zur anderen übertragen wird.
• Die Schnittstellen, die ein flexibles Design ermöglichen.
• Die Schnittstellenimplementierung, die eine konkrete Implementierung der Persistenzlogik ist.

Implementierung des DAO-Musters

Mit den oben genannten Komponenten versuchen wir, das DAO-Muster zu implementieren. Wir werden hier 3 Komponenten verwenden:

1. Das Book Modell, das von einer Schicht zur anderen übertragen wird.
2. Die BookDao Schnittstelle, die ein flexibles Design und eine API zur Implementierung bietet.
3. BookDaoImpl ist eine konkrete Klasse, die eine Implementierung des BookDao Interface ist.

Lassen Sie uns diese Logik in ein Diagramm bringen:

DAO Pattern Modellklasse

Jetzt setzen wir unser Modellobjekt auf.

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

    // Getter- und Setter-Methoden
}

Es ist ein einfaches Objekt mit nur 2 Eigenschaften, um die Dinge einfach zu halten.

DAO Pattern Interface

Definieren wir das Interface, um auf die damit verbundenen Daten auf der Persistenzebene zuzugreifen.

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

DAO Pattern Implementierung

Als nächstes erstellen wir eine konkrete Klasse, die das oben genannte Interface implementiert.

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 {

    // Die Liste funktioniert als Datenbank
    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);
    }
}

Verwendung des DAO Patterns

Schließlich setzen wir diese Implementierung in unserer main() Methode ein:

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

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

Vorteile des DAO-Musters

Es gibt viele Vorteile bei der Verwendung des DAO-Musters. Hier sind einige davon:

1. Beim Ändern eines Persistenzmechanismus muss die Service-Schicht nicht einmal wissen, woher die Daten stammen. Wenn Sie beispielsweise darüber nachdenken, von MySQL auf MongoDB umzusteigen, müssen alle Änderungen nur in der DAO-Schicht vorgenommen werden.
2. Das DAO-Muster legt großen Wert auf die geringe Kopplung zwischen den verschiedenen Komponenten einer Anwendung. Die View-Schicht hat also keine Abhängigkeit von der DAO-Schicht und nur die Service-Schicht hängt von ihr ab, und das auch nur über die Schnittstellen und nicht über eine konkrete Implementierung.
3. Da die Persistenzlogik vollständig getrennt ist, ist es viel einfacher, Unittests für einzelne Komponenten zu schreiben. Wenn Sie beispielsweise JUnit und Mockito für Testframeworks verwenden, können Sie die einzelnen Komponenten Ihrer Anwendung einfach mocken.
4. Da wir im DAO-Muster mit Schnittstellen arbeiten, wird auch der Stil „mit Schnittstellen anstelle von Implementierungen arbeiten“ betont, was ein ausgezeichneter Programmierstil in der objektorientierten Programmierung ist.

DAO-Muster Zusammenfassung

In diesem Artikel haben wir gelernt, wie wir das DAO-Entwurfsmuster verwenden können, um die Trennung der Persistenzlogik zu betonen und unsere Komponenten lose gekoppelt zu halten. Design Patterns basieren nur auf einer Art des Programmierens und sind daher unabhängig von Sprache und Framework. Hinterlassen Sie gerne Ihre Meinungen in den Kommentaren unten. Laden Sie das DAO-Beispielprojekt über den unten stehenden Link herunter.

Laden Sie das DAO-Muster Beispielprojekt herunter

Referenzen: Oracle-Dokumentation, Wikipedia.