个人中心
文章发布
退出
作者热门文章
- Java锁的逻辑（结合对象头和ObjectMonitor）
- 还在用饼状图？来瞧瞧这些炫酷的百分比可视化新图形（附代码实现）⛵
- 自动注册实体类到EntityFrameworkCore上下文，并适配ABP及ABPVNext
- 基于Sklearn机器学习代码实战
24
4
责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，也叫职责链模式、命令链模式。这种模式为请求创建了一个接收者对象的链，允许你将请求沿着处理者链进行发送，每个处理者均可对请求进行处理，或将其传递给链上的下个处理者.
当程序需要使用不同方式来处理多种类请求，且请求类型和顺序不可知，或者当必须按顺序执行多个处理时，可以使用责任链模式。或者如果所需处理及其顺序必须在运行时进行改变，也可以使用该模式.
。
//
AbstractHandler.java 所有处理变成链式，可以互动干涉，动态组合
public
abstract
class
AbstractHandler {
//
形成职责链
private
AbstractHandler next;
//
创建调用链，传入多个handler，按顺序形成链，返回第一个handler
public
static
AbstractHandler link(AbstractHandler first, AbstractHandler... chain) {
AbstractHandler head
=
first;
for
(AbstractHandler handler : chain) {
head.next
=
handler;
head
=
handler;
}
return
first;
}
//
子类需要实现的检查方法
public
abstract
boolean
check(
int
uid);
//
继续下一个检查
protected
boolean
checkNext(
int
uid) {
if
(next ==
null
) {
return
true
;
}
return
next.check(uid);
}
}
。
```java
//
AuthHandler.java 权限检查类
public
class
AuthHandler
extends
AbstractHandler {
//
如果检查不通过则返回失败，否则继续下一个检查
public
boolean
check(
int
uid) {
System.out.println(
this
.getClass().getName() + "::check() [uid = " + uid + "]"
);
if
(uid % 2 == 0
) {
return
false
;
}
return
checkNext(uid);
}
}
```
```java
//
RequestHandler.java 请求是否安全合法检查
public
class
RequestHandler
extends
AbstractHandler {
//
如果检查不通过则返回失败，否则继续下一个检查
public
boolean
check(
int
uid) {
System.out.println(
this
.getClass().getName() + "::check() [uid = " + uid + "]"
);
if
(uid % 1 != 0
) {
return
false
;
}
return
checkNext(uid);
}
}
```
```java
//
UserHandler.java 用户基本信息检查类
public
class
UserHandler
extends
AbstractHandler {
//
如果检查不通过则返回失败，否则继续下一个检查
public
boolean
check(
int
uid) {
System.out.println(
this
.getClass().getName() + "::check() [uid = " + uid + "]"
);
if
(uid % 3 == 0
) {
return
false
;
}
return
checkNext(uid);
}
}
```
。
/**
* 责任链模式核心是打造一个调用处理链，每个处理链都实现抽象类的next方法，从而可以任意组织各种检查行为。
* 通过改变链内的成员或者调动它们的顺序，允许动态地新增或者删除职责，从而实现按需组织。
*/
//
可以任意组织职责链，先后顺序根据需要来
AbstractHandler handler1 =
AbstractHandler.link(
new
RequestHandler(),
new
UserHandler(),
new
AuthHandler());
System.out.println(
"handler1.check(1001)开始"
);
handler1.check(
1001
);
System.out.println(
"handler1.check(1002)开始"
);
handler1.check(
1002
);
//
可以任意组织职责链，先后顺序根据需要来
AbstractHandler handler2 =
AbstractHandler.link(
new
AuthHandler(),
new
RequestHandler(),
new
UserHandler());
System.out.println(
"handler2.check(1001)开始"
);
handler2.check(
1001
);
System.out.println(
"handler2.check(1002)开始"
);
handler2.check(
1002);
。
#include <stdio.h>
#include
<stdlib.h>
#include
<stdbool.h>
//
定义通用handler
typedef
struct
Handler
{
char
name[
50
];
//
handler链指针
struct
Handler *
next;
//
结构体内部的check_handler函数，供各handler独立实现
bool
(*check_handler)(
struct
Handler *,
int
);
} Handler;
//
创建handler调用链，逐个创建
Handler *link_handler(Handler *handler, Handler *
next);
//
两种创建链式hander的方式，功能相同，可以传入多个参数
Handler *make_handler_chain_count(
int
lenght, ...);
Handler
*make_handler_chain(Handler *
handler, ...);
//
检查handler通用函数
bool
check_handler_start(Handler *handler,
int
param);
//
定义权限检查handler
typedef
struct
AuthHandler
{
char
name[
50
];
Handler
*
next;
bool
(*check_handler)(
struct
Handler *,
int
);
} AuthHandler;
//
创建AuthHandler
AuthHandler *create_auth_handler(
char
*
name);
//
定义请求检查handler
typedef
struct
RequestHandler
{
char
name[
50
];
Handler
*
next;
bool
(*check_handler)(
struct
Handler *,
int
);
} RequestHandler;
//
创建RequestHandler
RequestHandler *create_request_handler(
char
*
name);
//
定义用户检查handler
typedef
struct
UserHandler
{
char
name[
50
];
Handler
*
next;
bool
(*check_handler)(
struct
Handler *,
int
);
} UserHandler;
//
创建UserHandler
UserHandler *create_user_handler(
char
*name);
。
//
handler.c 基础事件
#include <stdio.h>
#include
<stdlib.h>
#include
<stdarg.h>
#include
"
func.h
"
//
创建调用链，按顺序形成链，返回第一个handler
Handler *link_handler(Handler *handler, Handler *
next)
{
handler
->next =
next;
return
handler;
}
//
不定参数创建调用链，第一个参数是handler的数量，后面是多个handler
Handler *make_handler_chain_count(
int
lenght, ...)
{
va_list args;
va_start(args, lenght);
//
取出第1个handler
Handler *first = va_arg(args, Handler *
);
Handler
*head =
first;
//
把handler追加到next中，形成链，总长度减去第1个
for
(
int
i =
0
; i < lenght -
1
; i++
)
{
head
->next = va_arg(args, Handler *
);
head
= head->
next;
}
va_end(args);
return
first;
}
//
不定参数创建调用链，第一个参数是handler的数量，后面是多个handler，最后一个传NULL
Handler *make_handler_chain(Handler *
first, ...)
{
va_list args;
va_start(args, first);
Handler
*head =
first;
//
把handler追加到next中，以NULL作为结束符
while
(head !=
NULL)
{
head
->next = va_arg(args, Handler *
);
head
= head->
next;
}
va_end(args);
return
first;
}
//
单独handler检查开始函数
bool
check_handler_start(Handler *handler,
int
param)
{
return
handler->
check_handler(handler, param);
}
。
```c
//
auth_handler.c 权限检查类
#include <
string
.h>
#include
<stdio.h>
#include
<stdlib.h>
#include
"
func.h
"
/*
AuthHandler check函数实现
*/
bool
auth_handler_check(Handler *handler,
int
param)
{
printf(
"
\r\n auth_handler_check: [handler.name = %s param = %d]
"
, handler->
name, param);
AuthHandler
*auth_handler = (AuthHandler *
)handler;
//
这里是判断条件，如果出错则终止调用链，返回false
if
(param %
2
==
0
)
{
printf(
"
\r\n auth_handler_check: error[ %d %s 2 ] == 0
"
, param,
"
%
"
);
return
false
;
}
//
通过next调用下一步检查
if
(handler->next !=
NULL)
{
return
auth_handler->next->check_handler(handler->
next, param);
}
return
true
;
}
/*
创建具体处理器的函数
*/
AuthHandler
*create_auth_handler(
char
*
name)
{
AuthHandler
*handler = (AuthHandler *)
malloc
(
sizeof
(AuthHandler));
strncpy(handler
->name, name,
50
);
//
将handler的check_handler函数赋值为指定函数，便于检查处理
handler->check_handler = &
auth_handler_check;
handler
->next =
NULL;
return
handler;
}
```
```c
//
request_handler.c 请求是否安全合法检查
#include <
string
.h>
#include
<stdio.h>
#include
<stdlib.h>
#include
"
func.h
"
/*
RequestHandler check函数实现
*/
bool
request_handler_check(Handler *handler,
int
param)
{
printf(
"
\r\n request_handler_check: [handler.name = %s param = %d]
"
, handler->
name, param);
RequestHandler
*request_handler = (RequestHandler *
)handler;
//
这里是判断条件，如果出错则终止调用链，返回false
if
(param %
5
==
0
)
{
printf(
"
\r\n request_handler_check: error[ %d %s 5 ] == 0
"
, param,
"
%
"
);
return
false
;
}
//
通过next调用下一步检查
if
(handler->next !=
NULL)
{
return
request_handler->next->check_handler(handler->
next, param);
}
return
true
;
}
/*
创建具体处理器的函数
*/
RequestHandler
*create_request_handler(
char
*
name)
{
RequestHandler
*handler = (RequestHandler *)
malloc
(
sizeof
(RequestHandler));
strncpy(handler
->name, name,
50
);
//
将handler的check_handler函数赋值为指定函数，便于检查处理
handler->check_handler = &
request_handler_check;
handler
->next =
NULL;
return
handler;
}
```
```c
//
user_handler.c 用户基本信息检查类
#include <
string
.h>
#include
<stdio.h>
#include
<stdlib.h>
#include
"
func.h
"
/*
UserHandler check_handler函数实现
*/
bool
user_handler_check(Handler *handler,
int
param)
{
printf(
"
\r\n user_handler_check: [handler.name = %s param = %d]
"
, handler->
name, param);
UserHandler
*user_handler = (UserHandler *
)handler;
//
这里是判断条件，如果出错则终止调用链，返回false
if
(param %
3
==
0
)
{
printf(
"
\r\n user_handler_check: error[ %d %s 3 ] == 0
"
, param,
"
%
"
);
return
false
;
}
//
通过next调用下一步检查
if
(handler->next !=
NULL)
{
return
user_handler->next->check_handler(handler->
next, param);
}
return
true
;
}
/*
创建具体处理器的函数
*/
UserHandler
*create_user_handler(
char
*
name)
{
UserHandler
*handler = (UserHandler *)
malloc
(
sizeof
(UserHandler));
strncpy(handler
->name, name,
50
);
//
将handler的check_handler函数赋值为指定函数，便于检查处理
handler->check_handler = &
user_handler_check;
handler
->next =
NULL;
return
handler;
}
```
。
#include <stdio.h>
#include
<stdlib.h>
#include
<stdbool.h>
#include
"
../src/func.h
"
int
main(
void
)
{
/*
*
* 责任链模式核心是打造一个调用处理链，每个处理链都实现抽象类的next方法，从而可以任意组织各种检查行为。
* 通过改变链内的成员或者调动它们的顺序，允许动态地新增或者删除职责，从而实现按需组织。
*/
//
创建一组hanler
RequestHandler *request_handler = create_request_handler(
"
request_handler_01
"
);
UserHandler
*user_handler = create_user_handler(
"
user_handler_02
"
);
AuthHandler
*auth_handler = create_auth_handler(
"
auth_handler_03
"
);
printf(
"
创建handler:\r\n %s %s %s
"
, request_handler->name, user_handler->name, auth_handler->
name);
//
将handler逐个链接成职责链
link_handler((Handler *)request_handler, (Handler *
)user_handler);
link_handler((Handler
*)user_handler, (Handler *
)auth_handler);
printf(
"
\r\n建立职责链:\r\n
"
);
Handler
*handler_cur = (Handler *
)request_handler;
while
(handler_cur !=
NULL)
{
printf(
"
-> %s
"
, handler_cur->
name);
handler_cur
= handler_cur->
next;
}
//
从任意handler开始检查
//
printf("\r\ncheck_handler_start检查:");
//
check_handler_start((Handler *)request_handler, 666);
//
从执行handler开始
printf(
"
\r\n开始检查:
"
);
bool
result1 = request_handler->check_handler((Handler *)request_handler,
666
);
printf(
"
\r\n执行结果: %s \r\n
"
, result1 ?
"
true
"
:
"
false
"
);
/*
释放内存
*/
free
(handler_cur);
free
(request_handler);
free
(auth_handler);
free
(user_handler);
/*
** ========分割线============ **
*/
printf(
"
\r\n=============\r\n
"
);
/*
创建一组hanler
*/
RequestHandler
*request_handler2 = create_request_handler(
"
request_handler_101
"
);
UserHandler
*user_handler2 = create_user_handler(
"
user_handler_102
"
);
AuthHandler
*auth_handler2 = create_auth_handler(
"
auth_handler_103
"
);
printf(
"
\r\n创建handler:\r\n %s %s %s
"
, request_handler2->name, user_handler2->name, auth_handler2->
name);
//
将handler一次性链接为职责链，传入多个handler，第一个参数是数量
Handler *handler2 = make_handler_chain_count(
3
, auth_handler2, request_handler2, user_handler2);
printf(
"
\r\n建立职责链:\r\n
"
);
Handler
*handler_cur2 = (Handler *
)handler2;
while
(handler_cur2 !=
NULL)
{
printf(
"
-> %s
"
, handler_cur2->
name);
handler_cur2
= handler_cur2->
next;
}
//
调用通用检查函数开始
printf(
"
\r\n开始检查:
"
);
bool
result2 = check_handler_start(handler2,
777
);
printf(
"
\r\n执行结果: %s \r\n
"
, result2 ?
"
true
"
:
"
false
"
);
/*
释放内存
*/
free
(handler_cur2);
free
(request_handler2);
free
(auth_handler2);
free
(user_handler2);
/*
** ========分割线============ **
*/
printf(
"
\r\n=============\r\n
"
);
/*
再创建一组hanler
*/
RequestHandler
*request_handler3 = create_request_handler(
"
request_handler_201
"
);
UserHandler
*user_handler3 = create_user_handler(
"
user_handler_202
"
);
AuthHandler
*auth_handler3 = create_auth_handler(
"
auth_handler_203
"
);
printf(
"
\r\n创建handler:\r\n %s %s %s
"
, request_handler3->name, user_handler3->name, auth_handler3->
name);
//
将handler一次性链接为职责链，传入多个handler，最后一个参数是NULL
Handler *handler3 = make_handler_chain((Handler *
)auth_handler3, user_handler3, request_handler3, NULL);
Handler
*handler_cur3 = (Handler *
)handler3;
printf(
"
\r\n建立职责链:\r\n
"
);
while
(handler_cur3 !=
NULL)
{
printf(
"
-> %s
"
, handler_cur3->
name);
handler_cur3
= handler_cur3->
next;
}
printf(
"
\r\n开始检查:
"
);
bool
result3 = check_handler_start(handler3,
167
);
printf(
"
\r\n执行结果: %s \r\n
"
, result3 ?
"
true
"
:
"
false
"
);
/*
释放内存
*/
free
(handler_cur3);
free
(request_handler3);
free
(auth_handler3);
free
(user_handler3);
return
0
;
}
。
不同语言实现设计模式： https://github.com/microwind/design-pattern 。
最后此篇关于【责任链设计模式详解】C/Java/JS/Go/Python/TS不同语言实现的文章就讲到这里了,如果你想了解更多关于【责任链设计模式详解】C/Java/JS/Go/Python/TS不同语言实现的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
24
4
0
我正在编写一个具有以下签名的 Java 方法。 void Logger(Method method, Object[] args); 如果一个方法(例如 ABC() )调用此方法 Logger，它应该
我是 Java 新手。 我的问题是我的 Java 程序找不到我试图用作的图像文件一个 JButton。 (目前这段代码什么也没做，因为我只是得到了想要的外观第一的)。这是我的主课 代码: packag
好的，今天我在接受采访，我已经编写 Java 代码多年了。采访中说“Java 垃圾收集是一个棘手的问题，我有几个 friend 一直在努力弄清楚。你在这方面做得怎么样？”。她是想骗我吗？还是我的一生都
我的 friend 给了我一个谜语让我解开。它是这样的: There are 100 people. Each one of them, in his turn, does the following
如果我将使用 Java 5 代码的应用程序编译成字节码，生成的 .class 文件是否能够在 Java 1.4 下运行？ 如果后者可以工作并且我正在尝试在我的 Java 1.4 应用程序中使用 Jav
有关于why Java doesn't support unsigned types的问题以及一些关于处理无符号类型的问题。我做了一些搜索，似乎 Scala 也不支持无符号数据类型。限制是Java和S
我只是想知道在一个 java 版本中生成的字节码是否可以在其他 java 版本上运行 最佳答案 通常，字节码无需修改即可在 较新 版本的 Java 上运行。它不会在旧版本上运行，除非您使用特殊参数 (
我有一个关于在命令提示符下执行 java 程序的基本问题。 在某些机器上我们需要指定 -cp 。 (类路径)同时执行java程序 (test为java文件名与.class文件存在于同一目录下) jav
我已经阅读 StackOverflow 有一段时间了，现在我才鼓起勇气提出问题。我今年 20 岁，目前在我的家乡(罗马尼亚克卢日-纳波卡)就读 IT 大学。足以介绍:D。 基本上，我有一家提供簿记应用
我有 public JSONObject parseXML(String xml) { JSONObject jsonObject = XML.toJSONObject(xml); r
我已经在 Java 中实现了带有动态类型的简单解释语言。不幸的是我遇到了以下问题。测试时如下代码: def main() { def ks = Map[[1, 2]].keySet()
一直提示输入 1 到 10 的数字 - 结果应将 st、rd、th 和 nd 添加到数字中。编写一个程序，提示用户输入 1 到 10 之间的任意整数，然后以序数形式显示该整数并附加后缀。 public
我有这个 DownloadFile.java 并按预期下载该文件: import java.io.*; import java.net.URL; public class DownloadFile {
我想在 GUI 上添加延迟。我放置了 2 个 for 循环，然后重新绘制了一个标签，但这 2 个 for 循环一个接一个地执行，并且标签被重新绘制到最后一个。 我能做什么？ for(int i=0;
我正在对对象 Student 的列表项进行一些测试，但是我更喜欢在 java 类对象中创建硬编码列表，然后从那里提取数据，而不是连接到数据库并在结果集中选择记录。然而，自从我这样做以来已经很长时间了，
我知道对象创建分为三个部分: 声明 实例化 初始化 classA{} classB extends classA{} classA obj = new classB(1,1); 实例化 它必须使用
我有兴趣使用 GPRS 构建车辆跟踪系统。但是，我有一些问题要问以前做过此操作的人: GPRS 是最好的技术吗？人们意识到任何问题吗？ 我计划使用 Java/Java EE - 有更好的技术吗？ 如果
我可以通过递归方法反转数组，例如:数组={1,2,3,4,5} 数组结果={5,4,3,2,1}但我的结果是相同的数组，我不知道为什么，请帮助我。 public class Recursion { p
有这样的标准方式吗？ 包括 Java源代码-测试代码- Ant 或 Maven联合单元持续集成(可能是巡航控制)ClearCase 版本控制工具部署到应用服务器 最后我希望有一个自动构建和集成环境。
我什至不知道这是否可能，我非常怀疑它是否可能，但如果可以，您能告诉我怎么做吗？我只是想知道如何从打印机打印一些文本。 有什么想法吗？ 最佳答案 这里有更简单的事情。 import javax.swin
我是一名优秀的程序员,十分优秀！