Beispiele für die Verwendung von Chain-of-Responsibility-Mustern in der Java-Entwurfsmusterprogrammierung

Chain-of-Responsibility-Modell: Mehrere Objekte werden durch die Referenzen ihrer entsprechenden Objekte zu einer Kette verbunden. Die Anfrage wird auf dieser Kette weitergeleitet, bis ein empfangendes Objekt in der Kette die Anfrage bearbeitet. Da der anfragende Client nicht weiß, wer die Anfrage letztendlich in der Kette bearbeiten wird, kann das System die Verantwortlichkeiten dynamisch neu organisieren und zuweisen, ohne dass dies Auswirkungen auf den Client hat, wodurch die Kopplung zwischen dem Anfragesender und dem Anfragehandler vermieden wird.
An der Verantwortungskette sind drei Rollen beteiligt: ​​
1, abstrakte Bearbeiterrolle
2, konkrete Bearbeiterrolle
3, Anfragesender
Kleines Beispiel: Angenommen, Sie möchten ein Haus kaufen Der Kauf eines Hauses erfordert Verhandlungen. Je nach Position des Hausverkäufers kann auch der Preis, der rabattiert werden kann, unterschiedlich sein. Wir entscheiden vorläufig: * Basisverkäufer können nur 3 % Rabatt erhalten * Vertriebsleiter: können 5 % Rabatt erhalten * Vertriebsleiter: können 8 % Rabatt erhalten * Boss (Boss): können 10 % Rabatt erhalten

Java-Instanz
Klassendiagramm:

/** 
 * 抽象责任 
 */
public abstract class IFilter { 
  private IFilter successor; 
  
  public IFilter getSuccessor() { 
    return successor; 
  } 
  
  public void setSuccessor(IFilter successor) { 
    this.successor = successor; 
  } 
    
  public abstract void handleFilter(); 
    
  public abstract void handleFilter2(); 
}

/** 
 * 具体责任 
 */
public class ConcreteFilter extends IFilter { 
    
  private String name; 
  public ConcreteFilter(String name) { 
    this.name = name; 
  } 
    
  @Override
  public void handleFilter() { 
    /* 
     * 自己先处理，如有后继者，再由它处理一次 
     */ 
    System.out.println(name + " 处理了请求"); 
    if (getSuccessor() != null) { 
      getSuccessor().handleFilter(); 
    } 
  } 
    
  @Override 
  public void handleFilter2() { 
    /* 
     * 有后继者就后继者处理, 否则自己处理 
     */
    if (getSuccessor() != null) { 
      getSuccessor().handleFilter2(); 
    } else { 
      System.out.println(name + " 处理了请求"); 
    } 
  } 
}

public class Test { 
  public static void main(String[] args) { 
    IFilter filter1 = new ConcreteFilter("permission-filter");//权限过滤 
    IFilter filter2 = new ConcreteFilter("suffix-filter");//后缀名过滤 
    IFilter filter3 = new ConcreteFilter("style-filter");//风格过滤 
    filter1.setSuccessor(filter2); 
    filter2.setSuccessor(filter3); 
    System.out.println("------以下是每一个处理者(包括后继者)都处理了, 顺序也是一级一级的传递------"); 
    filter1.handleFilter(); 
      
    System.out.println("------以下是交由最后一个后继者处理------"); 
    filter1.handleFilter2(); 
      
  } 
}

Drucken:

------以下是每一个处理者(包括后继者)都处理了, 顺序也是一级一级的传递------ 
permission-filter 处理了请求 
suffix-filter 处理了请求 
style-filter 处理了请求 
------以下是交由最后一个后继者处理------ 
style-filter 处理了请求

Mehr Chain of Responsibility-Muster Verwendung in der Java-Entwurfsmusterprogrammierung. Beispiele für verwandte Artikel finden Sie auf der chinesischen PHP-Website!