Example analysis of chain of responsibility pattern in Java design patterns

This article mainly introduces the relevant information of the responsibility connection model of the design pattern in detail, which has certain reference value. Interested friends can refer to it

Definition:Allow multiple objects to have the opportunity to process the request, thus avoiding the coupling relationship between the sender and receiver of the request. These objects are connected into a chain and the request is passed along the chain until an object handles it.

Type: Behavioral class pattern

Class diagram:

##First look at a piece of code:

public void test(int i, Request request){ 
 if(i==1){ 
  Handler1.response(request); 
 }else if(i == 2){ 
  Handler2.response(request); 
 }else if(i == 3){ 
  Handler3.response(request); 
 }else if(i == 4){ 
  Handler4.response(request); 
 }else{ 
  Handler5.response(request); 
 } 
}

The business logic of the code is as follows. The method has two parameters: an integer i and a request. The value of i determines who will handle the request. If If i==1, it will be processed by Handler1, if i==2, it will be processed by Handler2, and so on. In programming, this method of handling business is very common. All classes that handle requests have if...else...conditional judgment statements connected to form a chain of responsibility to process the request. I believe everyone uses it often. The advantage of this method is that it is very intuitive, simple and clear, and relatively easy to maintain. However, this method also has several troublesome problems:

bloated code : The judgment conditions in actual applications are usually not as simple as judging whether it is 1 or 2. It may require complex calculations, querying the database, etc., which will require a lot of extra code. If If there are too many judgment conditions, then this if...else...statement will basically become unreadable.
High degree of coupling: If we want to continue to add classes for processing requests, then we must continue to add else if judgment conditions; in addition, the order of this condition judgment is also hard-coded , if you want to change the order, you can only modify this conditional statement.

Now that we are clear about the shortcomings, we must find ways to solve them. The business logic of this scenario is very simple: if condition 1 is met, it will be processed by Handler1, if not, it will be passed down; if condition 2 is met, it will be processed by Handler2, if it is not met, it will continue to be passed down, and so on, until The condition ends. In fact, the improvement method is also very simple, which is to put the judgment condition part into the processing class. This is the principle of the responsibility chain model.

The structure of the chain of responsibility pattern

The class diagram of the chain of responsibility pattern is very simple. It consists of an abstract processing class and a set of its Implementation class composition:

Abstract processing class: The abstract processing class mainly includes a member variable nextHandler that points to the next processing class and a processing request Method handRequest, the main idea of ​​the handRequest method is that if the processing conditions are met, this processing class will handle it, otherwise it will be handled by nextHandler.

Specific processing class: The specific processing class mainly implements specific processing logic and applicable conditions for processing.

                                                                                                                                                            ’s that being that Level class in the code is a simulation are easier to understand if we look at the code:

##

class Level { 
  private int level = 0; 
  public Level(int level){ 
    this.level = level; 
  }; 
   
  public boolean above(Level level){ 
   if(this.level >= level.level){ 
      return true; 
    } 
    return false; 
  } 
} 
 
class Request { 
  Level level; 
  public Request(Level level){ 
    this.level = level; 
  } 
   
  public Level getLevel(){ 
    return level; 
  } 
} 
 
class Response { 
 
} 

abstract class Handler { 
  private Handler nextHandler;   
  public final Response handleRequest(Request request){ 
    Response response = null; 
     
   if(this.getHandlerLevel().above(request.getLevel())){ 
      response = this.response(request); 
    }else{ 
      if(this.nextHandler != null){ 
        this.nextHandler.handleRequest(request); 
      }else{ 
        System.out.println("-----没有合适的处理器-----"); 
      } 
    } 
    return response; 
  } 
  public void setNextHandler(Handler handler){ 
   this.nextHandler = handler; 
  } 
  protected abstract Level getHandlerLevel(); 
   public abstract Response response(Request request); 
} 
 
class ConcreteHandler1 extends Handler { 
  protected Level getHandlerLevel() { 
    return new Level(1); 
  } 
  public Response response(Request request) { 
    System.out.println("-----请求由处理器1进行处理-----"); 
    return null; 
  } 
} 
 
class ConcreteHandler2 extends Handler { 
  protected Level getHandlerLevel() { 
    return new Level(3); 
  } 
  public Response response(Request request) { 
    System.out.println("-----请求由处理器2进行处理-----"); 
    return null; 
  } 
} 
 
class ConcreteHandler3 extends Handler { 
  protected Level getHandlerLevel() { 
    return new Level(5); 
  } 
  public Response response(Request request) { 
    System.out.println("-----请求由处理器3进行处理-----"); 
    return null; 
  } 
} 
 
public class Client { 
  public static void main(String[] args){ 
    Handler handler1 = new ConcreteHandler1(); 
    Handler handler2 = new ConcreteHandler2(); 
    Handler handler3 = new ConcreteHandler3(); 
 
    handler1.setNextHandler(handler2); 
    handler2.setNextHandler(handler3); 
     
    Response response = handler1.handleRequest(new Request(new Level(4))); 
  } 
}

Judgment conditions; Request and Response respectively correspond to requests and responses; the abstract class Handler is mainly used to judge conditions. A processing level is simulated here. Only the processing level of the processing class is higher than the level of Request can be processed, otherwise it will be handed over to the next processor. . Set the chain's before and after execution relationship in the Client class, and hand the request to the first processing class during execution. This is the responsibility chain mode. The function it completes is the same as the if...else... statement in the previous article.

Advantages and Disadvantages of Responsibility Chain Model

Comparing with if...else..., the responsibility chain model has lower coupling because It distributes conditional judgments into various processing classes, and the priority processing order of these processing classes can be set at will. The chain of responsibility model also has shortcomings, which are the same as the shortcomings of if...else... statements, that is, all judgment conditions must be executed before the correct processing class is found. When the chain of responsibility is relatively long, performance problems are more serious. .

Applicable Scenarios of the Responsibility Chain Model

Just like the initial example, if you feel inadequate when using if...else...statements to organize a chain of responsibility, When your code looks bad, use the Chain of Responsibility pattern to refactor it.

Summarize

The chain of responsibility model is actually a flexible version of the if...else... statement. It puts these judgment condition statements into each processing class. The advantage of this is that it is more flexible, but it also brings risks. For example, when setting up the relationship between processing classes, you must be particularly careful to determine the conditional relationship between the logic before and after processing classes, and be careful not to cause circular references in the chain.

The above is the detailed content of Example analysis of chain of responsibility pattern in Java design patterns. For more information, please follow other related articles on the PHP Chinese website!