Java使用责任链模式处理学生请假问题详解

时间：2022-12-04 21:29:21

本文实例讲述了java使用责任链模式处理学生请假问题。分享给大家供大家参考，具体如下：

一. 模式定义

在责任链模式中，很多对象由每一个对象对其下家的引用而连接起来，形成一条链。客户端应用请求在这个链上进行传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪个对象最终处理这个请求，这使系统可以在不影响客户端的情况下动态地重新组织链和分配责任。

(1)抽象处理者角色：定义出一个处理请求的接口。如果需要，接口可以定义出一个方法，以设定和返回下家的引用。这个角色通常由一个java抽象类或java接口实现。

(2)具体处理角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。

二. 模式举例

1 模式分析

我们借用学生请假来说明这一模式

Java使用责任链模式处理学生请假问题详解

2 责任链模式静态类图

Java使用责任链模式处理学生请假问题详解

3 代码示例

3.1学生接口一istudent

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.demo.chain.message;
/**
 * 学生接口
 *
 * @author
 *
 */
public interface istudent {
  /**
   * 获得学生病情状态
   *
   * 0：小事（班长就可以处理）
   *
   * 1：班长处理不了 老师能处理的事
   *
   * 2：老师处理不了 校长能处理的事
   *
   *
   */
  public int getstate();
  /**
   * 获得学生请假消息
   *
   * @return
   */
  public string getrequestmessage();
}

3.2学生实现一student

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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使用责任链模式处理学生请假问题详解

希望本文所述对大家java程序设计有所帮助。

原文链接：https://blog.csdn.net/chengqiuming/article/details/70139492

标签：

相关文章