Java如何使用責任鏈模式處理學生請假問題

這篇文章給大家分享的是有關Java如何使用責任鏈模式處理學生請假問題的內容。小編覺得挺實用的，因此分享給大家做個參考，一起跟隨小編過來看看吧。

一. 模式定義

在責任鏈模式中，很多對象由每一個對象對其下家的引用而連接起來，形成一條鏈。客戶端應用請求在這個鏈上進行傳遞，直到鏈上的某一個對象決定處理此請求。發出這個請求的客戶端并不知道鏈上的哪個對象最終處理這個請求，這使系統可以在不影響客戶端的情況下動態地重新組織鏈和分配責任。

(1)抽象處理者角色：定義出一個處理請求的接口。如果需要，接口可以定義出一個方法，以設定和返回下家的引用。這個角色通常由一個Java抽象類或Java接口實現。

(2)具體處理角色：具體處理者接到請求后，可以選擇將請求處理掉，或者將請求傳給下家。

二. 模式舉例

1 模式分析

我們借用學生請假來說明這一模式

2 責任鏈模式靜態類圖

3 代碼示例

3.1學生接口一IStudent

package com.demo.chain.message;
/**
 * 學生接口
 *
 * @author
 *
 */
public interface IStudent {
  /**
   * 獲得學生病情狀態
   *
   * 0：小事（班長就可以處理）
   *
   * 1：班長處理不了 老師能處理的事
   *
   * 2：老師處理不了 校長能處理的事
   *
   *
   */
  public int getState();
  /**
   * 獲得學生請假消息
   *
   * @return
   */
  public String getRequestMessage();
}

3.2學生實現一Student

package com.demo.chain.message;
/**
 * 學生實現類
 *
 * @author
 *
 */
public class Student implements IStudent {
  // 病情的大小狀態
  private int state = -1;
  // 請假消息
  private final String message;
  public Student(int state, String message) {
    this.state = state;
    this.message = message;
  }
  /**
   * 獲得學生請假狀態
   *
   * 0：小事（班長就可以處理）
   *
   * 1：班長處理不了 老師能處理的事
   *
   * 2：老師處理不了 校長能處理的事
   *
   *
   */
  public int getState() {
    return this.state;
  }
  /**
   * 獲得學生請假消息
   *
   * @return
   */
  public String getRequestMessage() {
    return this.message;
  }
}

3.3抽象處理接口一IHandler

package com.demo.chain.handle;
import com.demo.chain.message.IStudent;
/**
 * 抽象處理者接口
 *
 * @author
 *
 */
public interface IHandler {
  // 處理請求
  public void handleRequest(IStudent student);
  // 設置下一個處理者
  public void setHandler(IHandler handler);
}

3.4抽象處理者一AbstractHandler

package com.demo.chain.handle;
import com.demo.chain.message.IStudent;
/**
 * 抽象處理者
 *
 * @author
 *
 */
public abstract class AbstractHandler implements IHandler {
  // 下一個處理者
  private IHandler handler;
  // 請假級別
  private int state = -1;
  // 構造方法 設置級別
  public AbstractHandler(int state) {
    this.state = state;
  }
  // 處理請求 交由子類負責進行具體的處理
  public abstract void process(IStudent student);
  // 處理請求
  public void handleRequest(IStudent student) {
    // 如果學生對象存在
    if (student != null) {
      if (this.state == student.getState()) {
        // 如果請假級別和當前一致 則當前對象進行處理
        this.process(student);
      } else {
        if (this.handler != null) {
          System.out.println("請求上級領導批復！");
          // 如果當前對象處理不了 則交給下一個處理者進行處理
          this.handler.handleRequest(student);
        }
      }
    }
  }
  // 設置下一個處理者
  public void setHandler(IHandler handler) {
    this.handler = handler;
  }
}

3.5班長一SquadLeaderHandler

package com.demo.chain.handle;
import com.demo.chain.message.IStudent;
/**
 * 抽象處理者
 *
 * @author
 *
 */
public abstract class AbstractHandler implements IHandler {
  // 下一個處理者
  private IHandler handler;
  // 請假級別
  private int state = -1;
  // 構造方法 設置級別
  public AbstractHandler(int state) {
    this.state = state;
  }
  // 處理請求 交由子類負責進行具體的處理
  public abstract void process(IStudent student);
  // 處理請求
  public void handleRequest(IStudent student) {
    // 如果學生對象存在
    if (student != null) {
      if (this.state == student.getState()) {
        // 如果請假級別和當前一致 則當前對象進行處理
        this.process(student);
      } else {
        if (this.handler != null) {
          System.out.println("請求上級領導批復！");
          // 如果當前對象處理不了 則交給下一個處理者進行處理
          this.handler.handleRequest(student);
        }
      }
    }
  }
  // 設置下一個處理者
  public void setHandler(IHandler handler) {
    this.handler = handler;
  }
}

3.6老師一TeacherHandler

package com.demo.chain.impl;
import com.demo.chain.handle.AbstractHandler;
import com.demo.chain.message.IStudent;
/**
 * 老師處理者
 *
 * @author
 *
 */
public class TeacherHandler extends AbstractHandler {
  public TeacherHandler() {
    super(1);
  }
  // 子類具體處理請求
  @Override
  public void process(IStudent student) {
    System.out.println("老師 批復：" + student.getRequestMessage());
  }
}

3.7校長一SchoolMasterHandler

package com.demo.chain.impl;
import com.demo.chain.handle.AbstractHandler;
import com.demo.chain.message.IStudent;
/**
 * 校長處理者
 *
 * @author
 *
 */
public class SchoolMasterHandler extends AbstractHandler {
  public SchoolMasterHandler() {
    super(2);
  }
  // 子類具體處理請求
  @Override
  public void process(IStudent student) {
    System.out.println("校長 批復：" + student.getRequestMessage());
  }
}

3.8外觀類一ProcessHandler

package com.demo.chain.process;
import com.demo.chain.handle.IHandler;
import com.demo.chain.impl.SchoolMasterHandler;
import com.demo.chain.impl.SquadLeaderHandler;
import com.demo.chain.impl.TeacherHandler;
import com.demo.chain.message.IStudent;
/**
 * 設置責任鏈關聯
 *
 * @author
 *
 */
public class ProcessHandler {
  // 班長處理者
  private final IHandler sqmshandler;
  // 老師處理者
  private final IHandler techhandler;
  // 校長處理者
  private final IHandler scmshandler;
  // 單例模式
  private static ProcessHandler processHandler = new ProcessHandler();
  /**
   * 構造方法建立請假處理責任鏈
   */
  private ProcessHandler() {
    // 創建處理對象
    // 班長
    this.sqmshandler = new SquadLeaderHandler();
    // 老師
    this.techhandler = new TeacherHandler();
    // 校長
    this.scmshandler = new SchoolMasterHandler();
    /**
     * 建立責任鏈
     */
    // 設置班長的下一個處理者：老師
    this.sqmshandler.setHandler(this.techhandler);
    // 設置老師的下一個處理者：校長
    this.techhandler.setHandler(this.scmshandler);
  }
  /**
   * 獲得單例對象實例
   *
   * @return
   */
  public static ProcessHandler getInstance() {
    return processHandler;
  }
  /**
   * 發送請假請求
   *
   * @param message
   */
  public void sendMessage(IStudent student) {
    // 發送給第一個處理者：班長 處理
    this.sqmshandler.handleRequest(student);
  }
}

3.9客戶端一Client

package com.demo;
import java.util.Random;
import com.demo.chain.message.IStudent;
import com.demo.chain.message.Student;
import com.demo.chain.process.ProcessHandler;
/**
 * 主應用程序
 *
 * @author
 *
 */
public class Client {
  /**
   * @param args
   */
  public static void main(String[] args) {
    // 獲得外觀對象
    ProcessHandler processHandler = ProcessHandler.getInstance();
    // 創建隨機數對象 用來隨機產生學生對象
    Random random = new Random();
    for (int i = 0; i < 3; i++) {
      // 獲得隨機數
      int radom = random.nextInt(3);
      IStudent student = new Student(radom, "學生" + i + "生病了，要請假！");
      System.out.println("#################################");
      // 處理消息
      processHandler.sendMessage(student);
      System.out.println("#################################\n");
    }
  }
}

4 運行結果

#################################
請求上級領導批復！
請求上級領導批復！
校長 批復：學生0生病了，要請假！
#################################
#################################
請求上級領導批復！
請求上級領導批復！
校長 批復：學生1生病了，要請假！
#################################
#################################
班長 批復：學生2生病了，要請假！
#################################

三. 該模式設計原則

1"開-閉"原則

2單一職責原則

四. 使用場合

(1)有多個對象處理同一請求，具體由哪一個來處理還不確定，只有在運行時才確定哪個對象處理的情況。
(2)消息具有多個接收者，而接收對象又是不明確的情況。只需要向其中的一個對象發出消息，由其內部具體處理。
(3)同一消息的多個處理對象可能會動態增加或減少，需要動態地指定的情況。

五. 責任鏈模式靜態類圖

感謝各位的閱讀！關于“Java如何使用責任鏈模式處理學生請假問題”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，讓大家可以學到更多知識，如果覺得文章不錯，可以把它分享出去讓更多的人看到吧！