Chain of Responsibility VS Case statements

Question

When I read about Chain of Responsibility, it talks about separating the client from the actual processing of the data. So it says the client program calls the first member of a chain and that member determines if it can process the request and if it can, it processes it and if not it calls the next member of the chain and so on.

I have read that additional members can be added to the chain and the client program does not have to actually change to handle that. What I am seeing in examples, including Wikipedia, is that the client has to instantiate each member of the chain and even set the successor for each member of the chain.

How is this considered loose coupling when the order of the objects in the chain is determined by the client and the client even has to instantiate each object in the chain?

If you could provide code samples where a case statement that you think is equivalent to a chain of responsibility is used it would be easier to answer. — plalx, Dec 10 '15 at 16:55
switch(planet) { case Mercury: PlanetHandler mercuryHandler = new MercuryHandler(); break; case Venus: PlanetHandler venusHandler = new VenusHandler();; break; // etc... } — user3393354, Dec 10 '15 at 20:57
[Why would I use a chain of responsibility over a switch-statement?](https://stackoverflow.com/questions/33217397/why-would-i-use-a-chain-of-responsibility-over-a-switch-statement) — jaco0646, Oct 24 '18 at 13:36

jaco0646 · Answer 1 · 2020-07-02T22:37:35.573

Chain of Responsibility is far more flexible than a case statement. Importantly, CoR can:

process the requests without hard-wiring handler relationships and precedence, or request-to-handler mappings.

Meaning clients are unaware of any subsequent handlers, or even the existence of a chain.

The number and type of handler objects isn't known a priori, they can be configured dynamically.

Meaning new handlers can be added at runtime, and existing handlers can be reordered.

A more basic answer is that case statements are a procedural construct, and therefore are generally not used in object-oriented programming, such as the Gang of Four design patterns.

Online examples may tend to configure a CoR within the client for the sake of simplicity; but in practice that defeats the purpose of the pattern, so the CoR would be configured elsewhere. Toy examples merely aim to show what a chain looks like and how it operates after instantiation; but where it is instantiated is key to the motivation for choosing CoR.

Example: A client depends on a service to process a String value.

The service API is trivial.

interface StringHandler {
    void handle(String arg);
}

The client may be infinitely complex, but at some point it invokes the service.

class Client {
    private final StringHandler argHandler;

    Client(StringHandler argHandler) {
        this.argHandler = argHandler;
    }

    void method(String arg) {
        argHandler.handle(arg);
        // more business logic...
    }
}

We choose to implement the service as a Chain of Responsibility.

class ChainedHandler implements StringHandler {
    private final String handledString;
    private ChainedHandler next;

    ChainedHandler(String handledString) {
        this.handledString = handledString;
    }

    Optional<ChainedHandler> next() {
        return Optional.ofNullable(next);
    }

    ChainedHandler next(ChainedHandler handler) {
        ChainedHandler subsequent = next;
        next = handler;
        if (handler != null && subsequent != null)
            handler.next(subsequent);
        return this;
    }

    @Override
    public void handle(String arg) {
        if (arg.equalsIgnoreCase(handledString)) {
            System.out.println("Handled: " + arg);
        } else {
            next().ifPresentOrElse(
                    handler -> handler.handle(arg),
                    () -> System.out.println("No handler for: " + arg));
        }
    }
}

So we build a Chain, wire it into the Client, and execute a few scenarios by modifying the Chain.

public static void main(String... commandLineArgs) {
    List<String> args = commandLineArgs.length > 0
            ? Arrays.asList(commandLineArgs)
            : List.of("foo", "bar", "baz", "qux");

    ChainedHandler chain = new ChainedHandler("foo")
            .next(new ChainedHandler("bar")
            .next(new ChainedHandler("baz")));

    Client client = new Client(chain);
    args.forEach(client::method);
    System.out.println();
    
    chain.next(new ChainedHandler("qux"));
    args.forEach(client::method);
    System.out.println();
    
    chain.next(null);
    args.forEach(client::method);
}

Note the Client is unaware that a chain exists. Furthermore, note the chain is modified without editing code. This is the decoupling that the GoF refers to. A case statement or if/else block would not provide the same flexibility.

Like I said, the example I used was very basic and the order of the chain was set up in the actual client program. There was no way for new handlers to be set up without actually changing the client program. — user3393354, Dec 11 '15 at 17:39
It sounds like the example you looked at may not actually implement the GoF Chain of Responsibility pattern. — jaco0646, Dec 11 '15 at 19:42
I have looked at many and they are all doing it the same way. Here is an example http://www.joezimjs.com/javascript/javascript-design-patterns-chain-of-responsibility/ — user3393354, Dec 12 '15 at 00:46
http://www.journaldev.com/1617/chain-of-responsibility-design-pattern-in-java-example-tutorial — user3393354, Dec 12 '15 at 00:51
http://www.avajava.com/tutorials/lessons/chain-of-responsibility-pattern.html?page=2 — user3393354, Dec 12 '15 at 00:52
http://www.oodesign.com/chain-of-responsibility-pattern.html — user3393354, Dec 12 '15 at 00:53
And even Wikipedia does it this way: https://en.wikipedia.org/wiki/Chain-of-responsibility_pattern — user3393354, Dec 12 '15 at 17:20
@jaco0646 "...where it is instantiated is key to the motivation for choosing CoR" this is a really good pointer for most of us, could you please provide an example or a link to a real world usage? — Taha Yavuz Bodur, Jul 02 '20 at 10:19

Chain of Responsibility VS Case statements

1 Answers1