Member-only story
Build a Configurable Chain of Responsibility in Go
Use the Chain of Responsibility design pattern to modify app behavior based on configuration changes
Chain of Responsibility or Chain of Command is a design pattern that lets you pass requests along a chain of Handlers. Each Handler decides to process the request and enrich it or pass it to the next Handler.
It allows you to have great isolation between each step and avoid having business logic in the middle of some technical logic. It also gives you the possibility to re-order your chain if what your app is supposed to do changes.
This is great, but why do we want it to be configurable?
The reason behind that is to be able to quickly change your app’s behavior without deploying code.
Let’s say that we have a set of Handlers available for our service:
As you can see, we have a simple pipeline here where we chain the Handlers to handle the request. It can easily be represented by a configuration that looks like this:
root: step1
steps:
step1:
type: handlerImpl1
next: step2
step2:
type: handlerImpl2
next: step3 step3:
type: handlerImpl3
But let’s say that you are in production and you want to add a cache layer before calling Step 3. You are lucky because the Handler to manage your cache solution already exists for another pipeline.
By changing the configuration, you can easily have a different pipeline with this caching step:
root: step1
steps:
step1:
type: handlerImpl1
next: step2
step2:
type: handlerImpl2
next: step4step3:
type: handlerImpl3step4:
type: RewriteHandler
next: step3
