Memento

Memento (pamiatka) je jednoduchý návrhový vzor, ktorý rieši uloženie vnútorného stavu objektu, bez toho by bol porušený princíp zapuzdrenie. Keďže vnútorný stav je vnútri objektu zapuzdrený, musí uloženie dát objektu vykonať objekt sám. K vnútornému stavu sa dá potom vrátiť. V základnej verzii tohto vzoru sa nejedná o princíp histórie (späť a dopredu), ale naozaj o jeden stav, ktorý sa uloží a objekt sa do neho potom dokáže vrátiť. Princíp histórie možno však doimplementovat a to aj inkrementálne, aby sa ukladali iba zmeny oproti pôvodným dátam. Vzor nijako nerieši ako ukladanie stavu implementovať, pre tieto účely môžeme použiť napr. Serializáciu.

Motivácia

V našich aplikáciách môžeme na niektorých miestach vyžadovať možnosť vrátiť sa k predchádzajúcemu stavu, napr. Získať dáta z formulára, ktorý užívateľ vyplnil a po ktorého odoslaní došlo k výpadku internetového pripojenia. Môžeme tiež potrebovať zaviesť funkcie späť / vpred, tie sa hodia nech programujeme kalkulačku alebo napr. Nejaký editor. Asi vás neprekvapí, že vzor bude oddeľovať túto funkcionalitu do samostatného objektu. To je koniec koncov princíp, o ktorý sa väčšina vzorov snaží. Pôvodný trieda uchovávajúci stav tak zostane nezanesené touto logikou a bude lepšie udržiavateľná.

Vzor

Vzor obsahuje nasledujúce triedy:

• Originator - Trieda, ktorej stav ukladáme. Umožňuje svoj stav načítať z mementá alebo ho uložiť do nového mementá a vrátiť.
• Memento - Reprezentácia vnútorného stavu triedy Originator. Iba objekt držiace stav bez ďalšej logiky.
• Caretaker - Trieda ukladá / načítava mementá z / do originator, jedná sa o manažér stavov.

Príklad

Predstavme si, že chceme uchovávať históriu výpočtov kalkulačky. Pre zjednodušenie ukladajte iba celej zadanej príklady ako textové reťazce. Pre reprezentáciu histórie využijeme dátovú štruktúru zásobník. V praxi samozrejme môžete ukladať objekty s ľubovoľným počtom ľubovoľne zložitých vlastností. Memento môžeme naprogramovať aj generický, aby sme ho mohli využívať aj pre ďalšie triedy a nemuseli písať zbytočne novej triedy.

Trieda Memento:

public class Memento<T>
{

    private T data;

    public Memento(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

}

Trieda Originator (Kalkulačka):

public class Kalkulacka<T> {
    private T priklad;

    public Memento<T> uloz() {
        return new Memento(priklad);
    }

    public void nacti(Memento<T> memento) {
        priklad = memento.getData();
    }

    public void setPriklad(T priklad) {
        this.priklad = priklad;
    }

    public T getPriklad() {
        return priklad;
    }

    // Nějaké další metody kalkulačky...

}

A trieda Caretaker:

public class Caretaker<T> {
    private Kalkulacka<T> kalkulacka;
    private Stack<Memento<T>> historie = new Stack<Memento<T>>();

    public Caretaker(Kalkulacka kalkulacka) {
        this.kalkulacka = kalkulacka;
    }

    public void uloz() {
        historie.push(kalkulacka.uloz());
    }

    public void zpet() {
        kalkulacka.nacti(historie.pop());
    }

}

Použitie je nasledovné:

Kalkulacka kalkulacka = new Kalkulacka();
Caretaker<String> historie = new Caretaker<>(kalkulacka);
kalkulacka.setPriklad("1 + 1");
System.out.println(kalkulacka.getPriklad());
historie.uloz();
kalkulacka.setPriklad("2 * 3");
System.out.println(kalkulacka.getPriklad());
historie.zpet();
System.out.println(kalkulacka.getPriklad());

A výstup aplikácie:

Konzolová aplikácia
1 + 1
2 * 3
1 + 1

Ak by vás zaujímalo, ako naprogramovať výpočet takého matematického výrazu, rieši to návrhový vzor Interpreter, tiež z GOF.