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:

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); 
 } 
}

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.

The structure of the chain of responsibility pattern

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.

##

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))); 
  } 
}

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. .

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.

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!