Comment implémenter un simple undo/redo pour les actions en java?

TL;DR: Vous pouvez soutenir annuler et rétablir des actions par la mise en œuvre de la Commande et de Mémento de schémas (Les Modèles de conception - Gama et. al).

Le Souvenir Modèle

Ce modèle simple permet d'enregistrer les états d'un objet. Enroulez simplement l'objet d'une nouvelle classe et à chaque fois que ses changements d'état, la mise à jour.

public class Memento
{
    MyObject myObject;

    public MyObject getState()
    {
        return myObject;
    }

    public void setState(MyObject myObject)
    {
        this.myObject = myObject;
    }
}

Le Modèle De Commande

Le modèle de Commande stocke l'objet d'origine (que nous voulons soutenir undo/redo) et le souvenir de l'objet, dont nous avons besoin dans le cas d'une annulation. En outre, les 2 méthodes sont définies:

1. exécuter: exécute la commande
2. unExecute: supprime la commande

Code:

public abstract class Command
{
    MyObject myObject;
    Memento memento;

    public abstract void execute();

    public abstract void unExecute();
}

À la définition de la logique "Actions" qui s'étendent de Commande (par exemple, Insertion):

public class InsertCharacterCommand extends Command
{
    //members..

    public InsertCharacterCommand()
    {
        //instantiate 
    }

    @Override public void execute()
    {
        //create Memento before executing
        //set new state
    }

    @Override public void unExecute()
    {
        this.myObject = memento.getState()l
    }
}

Appliquant les modèles:

Cette dernière étape définit la fonction annuler/rétablir le comportement. Ils l'idée de base est de stocker une pile de commandes qui fonctionne comme une histoire-liste des commandes. À l'appui de refaire, vous pouvez garder un secondaire pointeur à chaque fois que la commande annuler est appliquée. Notez que chaque fois qu'un nouvel objet est inséré, puis toutes les commandes après sa position actuelle retirés; qui est atteint par la deleteElementsAfterPointer méthode définie ci-dessous:

private int undoRedoPointer = -1;
private Stack<Command> commandStack = new Stack<>();

private void insertCommand()
{
    deleteElementsAfterPointer(undoRedoPointer);
    Command command =
            new InsertCharacterCommand();
    command.execute();
    commandStack.push(command);
    undoRedoPointer++;
}

private void deleteElementsAfterPointer(int undoRedoPointer)
{
    if(commandStack.size()<1)return;
    for(int i = commandStack.size()-1; i > undoRedoPointer; i--)
    {
        commandStack.remove(i);
    }
}

 private void undo()
{
    Command command = commandStack.get(undoRedoPointer);
    command.unExecute();
    undoRedoPointer--;
}

private void redo()
{
    if(undoRedoPointer == commandStack.size() - 1)
        return;
    undoRedoPointer++;
    Command command = commandStack.get(undoRedoPointer);
    command.execute();
}

Conclusion:

Ce qui rend cette conception est le fait que vous pouvez ajouter autant de commandes que vous le souhaitez (par extension de la Command classe), par exemple, RemoveCommand, UpdateCommand et ainsi de suite. En outre, le même modèle est applicable à tout type d'objet, design réutilisables et modifiables à travers différents cas d'utilisation.

OriginalL'auteur Menelaos Kotsollaris

Je voudrais essayer de créer une classe d'Action, avec un AddElementAction classe héritant hors d'Action.
AddElementAction pourrait avoir un Do() et Annuler() méthode qui permettrait d'ajouter/supprimer des éléments en conséquence. Vous pouvez ensuite faire deux piles d'Actions pour les annuler/refaire, et il suffit d'appeler N'()/Annuler() sur l'élément de plus haut niveau avant de les faire éclater.

OriginalL'auteur nolegs