Java implementation of responsibility chain pattern
The Chain of Responsibility Pattern is a behavioral design pattern that decouples the sender and receiver of a request, giving multiple objects the opportunity to process the request. String these objects into a chain and pass the request along this chain until an object processes it.
2. Applicable scenarios:
-When multiple objects can handle the same request and the specific object that handles the request is determined at runtime, the chain of responsibilities pattern can be used.
-When it is desired to have multiple objects have the opportunity to process the request, rather than having only one determined processor, the responsibility chain pattern can be used.
-When it is necessary to submit a request to one of multiple objects without specifying the recipient, the responsibility chain pattern can be used.
3. Benefits:
-The responsibility chain pattern decouples the sender and receiver of requests, and the sender does not need to know who processed the request or the structure of the chain.
-Can dynamically add or modify objects for processing requests, with high flexibility.
-You can control the order in which requests are processed.
The following is the complete sample code for implementing the responsibility chain pattern in Java:
//Defining Abstract Processors
abstract class Handler {
protected Handler successor;
public void setSuccessor(Handler successor) {
this.successor = successor;
}
public abstract void handleRequest(int request);
}
//Specific processor A
class ConcreteHandlerA extends Handler {
public void handleRequest(int request) {
if (request >= 0 && request < 10) {
System. out. println ("ConcreteHandlerA processing request"+request);
} else if (successor != null) {
successor.handleRequest(request);
}
}
}
//Specific processor B
class ConcreteHandlerB extends Handler {
public void handleRequest(int request) {
if (request >= 10 && request < 20) {
System. out. println ("ConcreteHandlerB processing request"+request);
} else if (successor != null) {
successor.handleRequest(request);
}
}
}
//Specific processor C
class ConcreteHandlerC extends Handler {
public void handleRequest(int request) {
if (request >= 20 && request < 30) {
System. out. println ("ConcreteHandlerC processing request"+request);
} else if (successor != null) {
successor.handleRequest(request);
}
}
}
//Test Code
public class Main {
public static void main(String[] args) {
//Building a Responsibility Chain
Handler handlerA = new ConcreteHandlerA();
Handler handlerB = new ConcreteHandlerB();
Handler handlerC = new ConcreteHandlerC();
handlerA.setSuccessor(handlerB);
handlerB.setSuccessor(handlerC);
//Send Request
int[] requests = {5, 15, 25};
for (int request : requests) {
handlerA.handleRequest(request);
}
}
}
Output results:
ConcreteHandlerA processing request 5
ConcreteHandlerB processing request 15
ConcreteHandlerC processing request 25
In the above code, an abstract handler and its three concrete handlers (ConcreteHandlerA, ConcreteHandlerB, and ConcreteHandlerC) are defined, with each concrete handler having a successor handler.
In the test code, a chain of responsibilities was constructed and three different requests were sent. According to the value of the request, the processors in the responsibility chain process the request in sequence. The requested value is processed by ConcreteHandlerA if it is less than 10, ConcreteHandlerB if it is greater than or equal to 10 but less than 20, and ConcreteHandlerC if it is greater than or equal to 20 but less than 30. If a processor is unable to process the request, the request is passed on to the next processor until a processor processes the request or the end of the responsibility chain.
