I was trying Apache Commons Chain when I was trying to design a simple workflow system for my back-end application using the Chain of Responsibility design pattern.

Chain of Responsibility is a popular technique for organizing the execution of complex processing flows. It is not difficult if you want to write it yourself but Commons Chain has already implemented this pattern for you.

Commons Chain models a computation as a series of "commands" that can be combined into a "chain". The API for a command consists of a single method (execute()), which is passed a "context" parameter containing the dynamic state of the computation, and whose return value is a boolean that determines whether or not processing for the current chain has been completed (true), or whether processing should be delegated to the next command in the chain (false).

E.g., first I create my custom context to be passed around my flows.

import org.apache.commons.chain.impl.ContextBase;

public class MyContext extends ContextBase {
    private String name;
    private String email;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

Then I created my processes, each one as a command.

import org.apache.commons.chain.Command;
import org.apache.commons.chain.Context;

public class Command1 implements Command {

    public boolean execute(Context context) throws Exception {
        System.out.println("First command");
        MyContext myContext = (MyContext)context;
        myContext.setName("twit88");
        return false;
    }
}

import org.apache.commons.chain.Command;
import org.apache.commons.chain.Context;

public class Command2 implements Command {

    public boolean execute(Context context) throws Exception {
        System.out.println("Second command");
        MyContext myContext = (MyContext)context;
        myContext.setEmail("admin@twit88.com");
        return false;
    }
}

import org.apache.commons.chain.Command;
import org.apache.commons.chain.Context;

public class Command3 implements Command {

    public boolean execute(Context context) throws Exception {
        System.out.println("Third command");
        MyContext myContext = (MyContext)context;
        System.out.println("name: " + myContext.getName());
        System.out.println("email: " + myContext.getEmail());
        return false;
    }
}

I defined the sequence of processing in a configuration file.

<catalog>

  <!-- Single command "chains"
         from CatalogBaseTestCase -->
  <command   name="MyFirstCommand"
        className="Command1"/>
  <command   name="MySecondCommand"
        className="Command2"/>
  <command   name="MySecondCommand"
        className="Command3"/>

  <!-- Chains with nested commands -->
  <chain     name="MyFlow">
    <command   id="1"
        className="Command1"/>
    <command   id="2"
        className="Command2"/>
    <command   id="3"
        className="Command3"/>
  </chain>

</catalog>

Then I can test it.

import org.apache.commons.chain.Catalog;
import org.apache.commons.chain.Command;
import org.apache.commons.chain.Context;
import org.apache.commons.chain.config.ConfigParser;
import org.apache.commons.chain.impl.CatalogFactoryBase;

public class TestChain {

    private static final String CONFIG_FILE = "/chain.xml";
    private ConfigParser parser;
    private Catalog catalog;

    public TestChain() {
        parser = new ConfigParser();
    }

    public Catalog getCatalog() throws Exception {
        if (catalog == null) {
            parser.parse(
              this.getClass().getResource(CONFIG_FILE));

        }
        catalog = CatalogFactoryBase.getInstance().getCatalog();
        return catalog;
    }

    public static void main(String[] args) throws Exception {
        TestChain chain = new TestChain();
        Catalog catalog = chain.getCatalog();
        Command command = catalog.getCommand("MyFlow");
        Context ctx = new MyContext();
        command.execute(ctx);
    }

}

The output

First command
Second command
Third command
name: twit88
email: admin@twit88.com

Another interesting article for reading will be using Spring to create the workflow.

A Command pattern is an object behavioral pattern that allows us to achieve complete decoupling between the sender and the receiver. It allows you to encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests.

Here is a rewrite of the C# example provided in dofactory.com.

First define the Command interface.

public interface Command {
    public void execute();
    public void unExecute();
}

A Calculator is a good example.

public class Calculator {
    private int current = 0;

    public void operation(char operator, int operand) {
        switch (operator) {
            case '+':
                current += operand;
                break;
            case '-':
                current -= operand;
                break;
            case '*':
                current *= operand;
                break;
            case '/':
                current /= operand;
                break;
        }
        System.out.println("Current value = "
               + current + " after " + operator + " " + operand);
    }
}

CalculatorCommand wraps the Calculator.

public class CalculatorCommand implements Command {

    private char operator;
    private int operand;
    private Calculator calculator;

    public CalculatorCommand(Calculator calculator,
                             char operator, int operand) {
        this.calculator = calculator;
        this.operator = operator;
        this.operand = operand;
    }

    public char getOperator() {
        return operator;
    }

    public void setOperator(char operator) {
        this.operator = operator;
    }

    public int getOperand() {
        return operand;
    }

    public void setOperand(int operand) {
        this.operand = operand;
    }

    public void execute() {
        calculator.operation(operator, operand);
    }

    public void unExecute() {
        calculator.operation(undo(operator), operand);
    }

    // Private helper function
    private char undo(char operator) {
        char undo;
        switch (operator) {
            case '+':
                undo = '-';
                break;
            case '-':
                undo = '+';
                break;
            case '*':
                undo = '/';
                break;
            case '/':
                undo = '*';
                break;
            default:
                undo = ' ';
                break;
        }
        return undo;
    }
}

User invokes calculator.

import java.util.ArrayList;

public class User {
    private Calculator calculator = new Calculator();
    private ArrayList<Command> commands =
        new ArrayList<Command>();

    private int current = 0;

    public void redo(int levels) {
        System.out.println("\n---- Redo " + levels + " levels ");
        // Perform redo operations
        for (int i = 0; i < levels; i++) {
            if (current < commands.size()) {
                Command command = commands.get(current++);
                command.execute();
            }
        }
    }

    public void undo(int levels) {
        System.out.println("\n---- Undo " + levels + " levels ");
        // Perform undo operations
        for (int i = 0; i < levels; i++) {
            if (current >= 0) {
                Command command = commands.get(--current);
                command.unExecute();
            }
        }
    }

    public void compute(char operator, int operand) {
        // Create command operation and execute it
        Command command = new CalculatorCommand(
                calculator, operator, operand);
        command.execute();

        // Add command to undo list
        commands.add(command);
        current++;
    }
}

To test it

public class TestCommandPattern {

    public static void main(String[] args) {
        // Create user and let her compute
        User user = new User();

        user.compute('+', 100);
        user.compute('-', 50);
        user.compute('*', 10);
        user.compute('/', 2);

        // Undo 4 commands
        user.undo(4);

        // Redo 3 commands
        user.redo(3);

    }
}

The output

Current value = 100 after + 100
Current value = 50 after - 50
Current value = 500 after * 10
Current value = 250 after / 2

---- Undo 4 levels
Current value = 500 after * 2
Current value = 50 after / 10
Current value = 100 after + 50
Current value = 0 after - 100

---- Redo 3 levels
Current value = 100 after + 100
Current value = 50 after - 50
Current value = 500 after * 10

NOTE: This is written for me to recap and relearn what I learnt before….

This article is written in order for me to recap what I have learnt and used before, though I know there are already many sites which talked about all these.

Visitor Pattern defines a new operation to deal with the classes of the elements without changing their structures.

E.g.,

Create a IProcess interface,

public interface IProcessor {
    public void process(IMessage message);
}

IProcessor accepts IMessage as the parameter.

Create a IMessage interface,

public interface IMessage {
    public String parse();
}

Create a MessageProcessor class which implements IProcessor

public class MessageProcessor implements IProcessor{

    private String messageType;

    public void process(IMessage message) {
        messageType = message.parse();
    }

    public String toString() {
        return "Processor for " + messageType ;
    }
}

Create SMSMessage and MMSMessage class which implement IMessage

public class SMSMessage implements IMessage {

    public String parse() {
        return "SMS Message";
    }
}

public class MMSMessage implements IMessage {

    public String parse() {
        return "MMS Message";
    }
}

You can create another message processor depending on your need.

public class AnotherMessageProcessor {
    private String messageType;

    public void process(IMessage message) {
        messageType = message.parse();
    }

    public String toString() {
        return "Another Processor for " + messageType;
    }
}

To test it, use the following code stub

public class TestPattern {

    public static void main(String[] args) {
        MMSMessage mmsMessage = new MMSMessage();
        SMSMessage smsMessage = new SMSMessage();

        MessageProcessor messageProcessor = new MessageProcessor();
        AnotherMessageProcessor
                   anotherMessageProcessor =
                                   new AnotherMessageProcessor();

        messageProcessor.process(mmsMessage);
        System.out.println(messageProcessor.toString());

        messageProcessor.process(smsMessage);
        System.out.println(messageProcessor.toString());

        anotherMessageProcessor.process(mmsMessage);
        System.out.println(anotherMessageProcessor.toString());

        anotherMessageProcessor.process(smsMessage);
        System.out.println(anotherMessageProcessor.toString());
    }
}

The output

Processor for MMS Message
Processor for SMS Message
Another Processor for MMS Message
Another Processor for SMS Message