How to implement the responsibility chain pattern in Java? 1. Define an abstract class or interface for processing requests, including processing methods and methods for setting up the next processor. 2. Create a specific processor class to implement request processing logic. If the current processor cannot process it, it will be passed to the next one. 3. Build a processor chain and form a chain by setting up the next processor of each processor. 4. The client initiates a request and starts processing from the first node of the chain until the processor processes or the chain ends. For example, TeamLead, ProjectManager, and Director process purchase requests of different amounts in turn, and determine whether to process or forward the requests based on the amount.

Implementing the Chain of Responsibility pattern in Java can help you decouple the sender and receiver of a request, especially when multiple objects could potentially handle the request. This design pattern allows you to pass a request along a chain of handlers until one of them processes it.

Understanding the Core Components

The Chain of Responsibility pattern consists of several key components:

• Handler : An interface or abstract class that defines the method for handling requests and maintaining the next handler in the chain.
• Concrete Handlers : Classes that implement the handler interface and contains the logic for processing specific requests. If a concrete handler cannot process the request, it forwards it to the next handler in the chain.
• Client : The object that initiates the request and sends it to the first handler in the chain.

For example, imagine you're building a system where different types of purchase requests need approval from various managers based on the amount. A PurchaseRequest might be handled by a TeamLead , then passed to a ProjectManager , and finally to a Director .

Building the Handler Interface

Start by defining an interface or abstract class for your handlers. In this case, let's use an abstract class to provide a default implementation for chaining handlers together.

 public abstract class Approver {
    protected Approver nextApprover;

    public void setNextApprover(Approver nextApprover) {
        this.nextApprover = nextApprover;
    }

    public abstract void processRequest(PurchaseRequest request);
}

This abstract class includes:

• A reference to the next approver in the chain.
• A method to set the next approver.
• An abstract method processRequest() that each concrete handler will implement.

Implementing Concrete Handlers

Now create concrete implementations of the Approver class. Each handler checks if it can process the request; otherwise, it passes the request to the next handler.

Here's how a TeamLead might look:

 public class TeamLead extends Approver {
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() <= 1000) {
            System.out.println("Team Lead approved the request of $" request.getAmount());
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);
        }
    }
}

And here's a ProjectManager :

 public class ProjectManager extends Approver {
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() > 1000 && request.getAmount() <= 5000) {
            System.out.println("Project Manager approved the request of $" request.getAmount());
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);
        }
    }
}

You can continue adding more levels like a Director for higher amounts.

Setting Up and Using the Chain

Once all handlers are defined, you link them together to form the chain. Then, you send the request to the first handler in the sequence.

Here's how you might set up the chain and make a request:

 public class Client {
    public static void main(String[] args) {
        // Build the chain
        Approver teamLead = new TeamLead();
        Approver projectManager = new ProjectManager();
        Approver director = new Director();

        teamLead.setNextApprover(projectManager);
        projectManager.setNextApprover(director);

        // Make requests
        teamLead.processRequest(new PurchaseRequest(800));
        teamLead.processRequest(new PurchaseRequest(3000));
        teamLead.processRequest(new PurchaseRequest(10000));
    }
}

In this example:

• The PurchaseRequest with $800 is handled by the TeamLead .
• The $3000 request goes to the ProjectManager .
• The $10000 request reaches the Director .

Make sure to test edge cases—like a request that no one can approve—and consider adding logging or fallback behavior.

Basically, that's how you implement the Chain of Responsibility pattern in Java. It keeps your code flexible and makes it easier to extend the chain as needed.

The above is the detailed content of How to implement the Chain of Responsibility pattern in Java?. For more information, please follow other related articles on the PHP Chinese website!