DAO Ontwerppatroon

DAO staat voor Data Access Object. Het DAO Ontwerppatroon wordt gebruikt om de logica van gegevenspersistentie in een aparte laag te scheiden. Op deze manier blijft de service volledig in het duister over hoe de low-level operaties voor toegang tot de database worden uitgevoerd. Dit staat bekend als het principe van Scheiding van Logica.

DAO Ontwerppatroon

Met het DAO-ontwerppatroon hebben we de volgende componenten waarop ons ontwerp afhankelijk is:

• Het model dat van de ene laag naar de andere wordt overgedragen.
• De interfaces die zorgen voor een flexibel ontwerp.
• De interface-implementatie die een concrete implementatie is van de persistentielogica.

Implementatie van het DAO-patroon

Met de bovengenoemde componenten zullen we proberen het DAO-patroon te implementeren. We zullen hier 3 componenten gebruiken:

1. Het Book-model dat van de ene laag naar de andere wordt overgedragen.
2. De BookDao-interface die zorgt voor een flexibel ontwerp en API om te implementeren.
3. BookDaoImpl concrete klasse die een implementatie is van de BookDao interface.

Laten we deze logica in een diagram plaatsen:

DAO Patroon model Klasse

Nu, laten we ons modelobject opzetten.

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 setter methoden
}

Het is een eenvoudig object met slechts 2 eigenschappen om de zaken eenvoudig te houden.

DAO Patroon Interface

Laten we de interface definiëren om toegang te krijgen tot de gegevens die ermee op persistentieniveau zijn geassocieerd.

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 Patroon Implementatie

Vervolgens maken we een concrete klasse die de bovenstaande interface implementeert.

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 {

    //lijst werkt als een 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);
    }
}

Gebruikmakend van DAO Patroon

Eindelijk zetten we deze implementatie in gebruik in onze main() methode:

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

Voordelen van het DAO-patroon

Er zijn veel voordelen voor het gebruik van het DAO-patroon. Laten we er hier een paar noemen:

1. Bij het veranderen van een persistentiemechanisme hoeft de servicelaag zelfs niet te weten waar de gegevens vandaan komen. Bijvoorbeeld, als je overweegt om over te stappen van het gebruik van MySQL naar MongoDB, moeten alle wijzigingen alleen in de DAO-laag worden aangebracht.
2. Het DAO-patroon benadrukt de lage koppeling tussen verschillende onderdelen van een toepassing. Dus, de View-laag heeft geen afhankelijkheid van de DAO-laag en alleen de servicelaag is ervan afhankelijk, zelfs dat met de interfaces en niet van concrete implementatie.
3. Omdat de persistentielogica volledig gescheiden is, is het veel gemakkelijker om unit tests te schrijven voor individuele onderdelen. Bijvoorbeeld, als je JUnit en Mockito gebruikt voor testframeworks, zal het gemakkelijk zijn om de afzonderlijke onderdelen van je toepassing te mocken.
4. Omdat we werken met interfaces in het DAO-patroon, benadrukt het ook de stijl van “werken met interfaces in plaats van implementatie”, wat een uitstekende OOP-stijl van programmeren is.

Conclusie DAO-patroon

In dit artikel hebben we geleerd hoe we het DAO-ontwerppatroon kunnen gebruiken om de nadruk te leggen op het gescheiden houden van persistentielogica en zo onze componenten losjes te koppelen. Ontwerppatronen zijn gebaseerd op een manier van programmeren en zijn daarom taal- en frameworkonafhankelijk. Voel je vrij om je mening achter te laten in de opmerkingen hieronder. Download het DAO-voorbeeldproject vanaf de onderstaande link.

Download DAO-voorbeeldproject

Referenties: Oracle-documentatie, Wikipedia.