Java Command Design Pattern

/* The Invoker class */
public class Switch {

private Command flipUpCommand;
private Command flipDownCommand;

public Switch(Command flipUpCmd, Command flipDownCmd) {
this.flipUpCommand = flipUpCmd;
this.flipDownCommand = flipDownCmd;
}

public void flipUp() {
flipUpCommand.execute();
}

public void flipDown() {
flipDownCommand.execute();
}
}

/* The Receiver class */
public class Light {

public Light() {  }

public void turnOn() {
System.out.println("The light is on");
}

public void turnOff() {
System.out.println("The light is off");
}
}

/* The Command interface */
public interface Command {
void execute();
}

/* The Command for turning on the light */
public class FlipUpCommand implements Command {

private Light theLight;

public FlipUpCommand(Light light) {
this.theLight=light;
}

public void execute(){
theLight.turnOn();
}
}

/* The Command for turning off the light */
public class FlipDownCommand implements Command {

private Light theLight;

public FlipDownCommand(Light light) {
this.theLight=light;
}

public void execute() {
theLight.turnOff();
}
}

/* The test class or client */
public class PressSwitch {

public static void main(String[] args) {
Light lamp = new Light();
Command switchUp = new FlipUpCommand(lamp);
Command switchDown = new FlipDownCommand(lamp);

// See criticism of this model above:
// The switch itself should not be aware of lamp details (switchUp, switchDown)
// either directly or indirectly
Switch s = new Switch(switchUp,switchDown);

try {
if (args[0].equalsIgnoreCase("ON")) {
s.flipUp();
} else if (args[0].equalsIgnoreCase("OFF")) {
s.flipDown();
} else {
System.out.println("Argument \"ON\" or \"OFF\" is required.");
}
} catch (Exception e){
System.out.println("Arguments required.");
}
}
}

arne_v (3) skrev:

#1

Det korte svar er vel at den state gemmes i instansen af den konkrete command klasse.

squad2nd (1) skrev:

Mit problem er, at jeg har Actions, der implementerer Command, men som skal returnere et object.

Da du giver objektet med som Command-objektet opererer på, kan du blot efterfølgende kigge på dets tilstand.

interface Command
{ void execute() }


public class GetDataFromDatabase implements Command
{
private DatabaseList dbList;

public GetDataFromDatabase(DatabaseList g)
{
dbList = g;
}

public void execute()
{
dbList.getSomeDataFromDatabase();
}

}


public class DatabaseList
{
public ArrayList getSomeDataFromDatabase()
{
ArrayList f = //connect to database, and get some database
return f;
}



// Eller...
private ArrayList dataFromDb;
public void getSomeDataFromDatabase()
{
this.dataFromDb = //connect to database, and get some database
}

public ArrayList getDbData()
{
return dataFromDb;
}


}

Der er dog ingen måde til at undo operationen at "hente data"

class OpenFileDialog implements ActionListener

Et command pattern kan ikke sammenlignes med en action listener.

But there are still a couple of more ways to approach this. If you give every control its own actionListener class, you are in effect creating individual command objects for each of them. And, in fact, this is really what the designers of the Java 1.1 event model had in mind.

class CutToClipboard implements ActionListener, Command

jButton1.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {
Command c = new CutCommand(jTextArea1);
c.execute();
}

});

squad2nd (11) skrev:

#10

Kan være du har ret, og forfatteren ikke er klog nok, men
ifølge dette her dokument om Command pattern:

But there are still a couple of more ways to approach this. If you give every control its own actionListener class, you are in effect creating individual command objects for each of them. And, in fact, this is really what the designers of the Java 1.1 event model had in mind.

squad2nd (11) skrev:

Mit problem er egenligt Swing. Hvis du gider, og har lyst, vil jeg være meget taknemmelig hvis du kunne skrive et lille eksempel til mig i Java... bare et simpelt program hvor man trykker på en jbutton og den så kalder et Command object.

// Listener-registration etc.

JTextArea jTextArea1 = ….
UndoManager undoMgr = ...

jButton1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
UndoableEdit adapter = new CommandAdapter(new CutCommand(jTextArea1));
undoMgr.undoableEditHappened(new UndoableEditEvent(e.getSource(), adapter);
}
});

// Interfaces and Classes, for Command(s) and "Swing"-API-wrapper

interface Command {
void execute();
void undo();
}

class CutCommand implements Command {
… field members…
public CutCommand(JTextArea area) {
this.area = area;
this.selection = area.getSelection(); // whatever the method is named
this.contents = area.getText();
}
void execute() {
// put selection on Clipboard and remove from area
}
void undo() {
// restore contents of area, and remove selection from Clipboard
}
}

class CommandAdapter extends AbstractUndoableEdit {
… field members…
public CommandAdapter(Command command) {
this.command = command;
}
public void undo() throws CannotUndoException() {
command.undo();
}
public void redo() throws CannotRedoException() {
command.redo();
}
… canUndo, and canRedo-methods goes here…
}