Exemples d'utilisation du modèle de chaîne de responsabilité dans la programmation de modèles de conception Java

Modèle de chaîne de responsabilité : plusieurs objets sont connectés en une chaîne par les références de leurs objets correspondants, et la demande est transmise sur cette chaîne jusqu'à ce qu'un objet récepteur sur la chaîne gère la demande. Étant donné que le client demandeur ne sait pas qui traitera finalement la demande dans la chaîne, le système peut réorganiser et attribuer les responsabilités de manière dynamique sans affecter le client, évitant ainsi le couplage entre l'expéditeur de la demande et le gestionnaire de la demande.
Il y a trois rôles impliqués dans la chaîne de responsabilité :
1, rôle de processeur abstrait
2, rôle de processeur concret
3, expéditeur de la demande
Petit exemple : Supposons que vous souhaitiez acheter une maison L'achat d'une maison nécessite une négociation. Selon la position du vendeur de la maison, le prix pouvant être réduit est également différent. Différentes positions peuvent former une chaîne de traitement des demandes. Nous décidons provisoirement : * Les vendeurs de base ne peuvent bénéficier que d'une remise de 3 % * Directeurs commerciaux : peuvent bénéficier d'une remise de 5 % * Directeurs commerciaux : peuvent bénéficier d'une remise de 8 % * Boss (Boss) : peut bénéficier d'une remise de 10 %

Instance Java
Diagramme de classes :

/** 
 * 抽象责任 
 */
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(); 
      
  } 
}

Impression :

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

Plus de modèle de chaîne de responsabilité Utilisation dans la programmation de modèles de conception Java Pour des exemples d'articles connexes, veuillez faire attention au site Web PHP chinois !