Java使用責(zé)任鏈模式處理學(xué)生請假問題詳解

更新時間：2018年04月23日 10:03:07 作者：chengqiuming

這篇文章主要介紹了Java使用責(zé)任鏈模式處理學(xué)生請假問題,結(jié)合實例形式詳細(xì)分析了責(zé)任鏈模式的概念、原理及Java使用責(zé)任鏈模式處理學(xué)生請假問題的相關(guān)步驟、操作技巧與相關(guān)注意事項,需要的朋友可以參考下

本文實例講述了Java使用責(zé)任鏈模式處理學(xué)生請假問題。分享給大家供大家參考，具體如下：

一. 模式定義

在責(zé)任鏈模式中，很多對象由每一個對象對其下家的引用而連接起來，形成一條鏈?？蛻舳藨?yīng)用請求在這個鏈上進(jìn)行傳遞，直到鏈上的某一個對象決定處理此請求。發(fā)出這個請求的客戶端并不知道鏈上的哪個對象最終處理這個請求，這使系統(tǒng)可以在不影響客戶端的情況下動態(tài)地重新組織鏈和分配責(zé)任。

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

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

二. 模式舉例

1 模式分析

我們借用學(xué)生請假來說明這一模式

2 責(zé)任鏈模式靜態(tài)類圖

3 代碼示例

3.1學(xué)生接口一IStudent

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

3.2學(xué)生實現(xiàn)一Student

package com.demo.chain.message;
/**
 * 學(xué)生實現(xiàn)類
 *
 * @author
 *
 */
public class Student implements IStudent {
  // 病情的大小狀態(tài)
  private int state = -1;
  // 請假消息
  private final String message;
  public Student(int state, String message) {
    this.state = state;
    this.message = message;
  }
  /**
   * 獲得學(xué)生請假狀態(tài)
   *
   * 0：小事（班長就可以處理）
   *
   * 1：班長處理不了 老師能處理的事
   *
   * 2：老師處理不了 校長能處理的事
   *
   *
   */
  public int getState() {
    return this.state;
  }
  /**
   * 獲得學(xué)生請假消息
   *
   * @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);
  // 設(shè)置下一個處理者
  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;
  // 構(gòu)造方法 設(shè)置級別
  public AbstractHandler(int state) {
    this.state = state;
  }
  // 處理請求 交由子類負(fù)責(zé)進(jìn)行具體的處理
  public abstract void process(IStudent student);
  // 處理請求
  public void handleRequest(IStudent student) {
    // 如果學(xué)生對象存在
    if (student != null) {
      if (this.state == student.getState()) {
        // 如果請假級別和當(dāng)前一致 則當(dāng)前對象進(jìn)行處理
        this.process(student);
      } else {
        if (this.handler != null) {
          System.out.println("請求上級領(lǐng)導(dǎo)批復(fù)！");
          // 如果當(dāng)前對象處理不了 則交給下一個處理者進(jìn)行處理
          this.handler.handleRequest(student);
        }
      }
    }
  }
  // 設(shè)置下一個處理者
  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;
  // 構(gòu)造方法 設(shè)置級別
  public AbstractHandler(int state) {
    this.state = state;
  }
  // 處理請求 交由子類負(fù)責(zé)進(jìn)行具體的處理
  public abstract void process(IStudent student);
  // 處理請求
  public void handleRequest(IStudent student) {
    // 如果學(xué)生對象存在
    if (student != null) {
      if (this.state == student.getState()) {
        // 如果請假級別和當(dāng)前一致 則當(dāng)前對象進(jìn)行處理
        this.process(student);
      } else {
        if (this.handler != null) {
          System.out.println("請求上級領(lǐng)導(dǎo)批復(fù)！");
          // 如果當(dāng)前對象處理不了 則交給下一個處理者進(jìn)行處理
          this.handler.handleRequest(student);
        }
      }
    }
  }
  // 設(shè)置下一個處理者
  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("老師 批復(fù)：" + 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("校長 批復(fù)：" + 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;
/**
 * 設(shè)置責(zé)任鏈關(guān)聯(lián)
 *
 * @author
 *
 */
public class ProcessHandler {
  // 班長處理者
  private final IHandler sqmshandler;
  // 老師處理者
  private final IHandler techhandler;
  // 校長處理者
  private final IHandler scmshandler;
  // 單例模式
  private static ProcessHandler processHandler = new ProcessHandler();
  /**
   * 構(gòu)造方法建立請假處理責(zé)任鏈
   */
  private ProcessHandler() {
    // 創(chuàng)建處理對象
    // 班長
    this.sqmshandler = new SquadLeaderHandler();
    // 老師
    this.techhandler = new TeacherHandler();
    // 校長
    this.scmshandler = new SchoolMasterHandler();
    /**
     * 建立責(zé)任鏈
     */
    // 設(shè)置班長的下一個處理者：老師
    this.sqmshandler.setHandler(this.techhandler);
    // 設(shè)置老師的下一個處理者：校長
    this.techhandler.setHandler(this.scmshandler);
  }
  /**
   * 獲得單例對象實例
   *
   * @return
   */
  public static ProcessHandler getInstance() {
    return processHandler;
  }
  /**
   * 發(fā)送請假請求
   *
   * @param message
   */
  public void sendMessage(IStudent student) {
    // 發(fā)送給第一個處理者：班長 處理
    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;
/**
 * 主應(yīng)用程序
 *
 * @author
 *
 */
public class Client {
  /**
   * @param args
   */
  public static void main(String[] args) {
    // 獲得外觀對象
    ProcessHandler processHandler = ProcessHandler.getInstance();
    // 創(chuàng)建隨機(jī)數(shù)對象 用來隨機(jī)產(chǎn)生學(xué)生對象
    Random random = new Random();
    for (int i = 0; i < 3; i++) {
      // 獲得隨機(jī)數(shù)
      int radom = random.nextInt(3);
      IStudent student = new Student(radom, "學(xué)生" + i + "生病了，要請假！");
      System.out.println("#################################");
      // 處理消息
      processHandler.sendMessage(student);
      System.out.println("#################################\n");
    }
  }
}

4 運行結(jié)果

#################################
請求上級領(lǐng)導(dǎo)批復(fù)！
請求上級領(lǐng)導(dǎo)批復(fù)！
校長批復(fù)：學(xué)生0生病了，要請假！
#################################
#################################
請求上級領(lǐng)導(dǎo)批復(fù)！
請求上級領(lǐng)導(dǎo)批復(fù)！
校長批復(fù)：學(xué)生1生病了，要請假！
#################################
#################################
班長批復(fù)：學(xué)生2生病了，要請假！
#################################

三. 該模式設(shè)計原則

1"開-閉"原則

2單一職責(zé)原則

四. 使用場合

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

五. 責(zé)任鏈模式靜態(tài)類圖