设计模式—— 十六 :责任链模式

设计模式(十六)—— 责任链模式 又名职责链模式,为了避免请求发送者与多个请求处理者耦合在一起,将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链;当有请求发生时,可将请求沿着这条链传递,直到有对象处理它为止。 阅读详情

什么是责任链模式?

职责链模式的定义:

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request.Chain the receiving objects and pass the request along the chain until an object handles it.(使多个对象都有机会处理请求,从而避免了请求的发送者和接受者之间的耦合关 系。将这些对象连成一条链,并沿着这条链传递该请求,直到有对象处理它为止。)

责任链模式的重点是在“链”上,由一条链去处理相似的请求在链中决定谁来处理这个请求,并返回相应的结果,

通用类图如图16-1所示:

图16-1:命令模式模式通用类图

在这里插入图片描述

责任链模式的核心在“链”上,“链”是由多个处理者ConcreteHandler组成的,包含如下几个角色:

● Handler(抽象处理者):

 抽象处理者实现三个职责:

  • 一是定义一个请求的处理方法handleMessage,唯一对外开放的方法;
  • 二是定义一个链的编排方法setNext,设置下一个处理者;
  • 三是定义了具体的请求者必须实现的两个方法:定义自己能够处理的级别getHandlerLevel和具体的处理任务echo。
复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">abstract</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Handler</span> {
	<span style="color:#a626a4">private</span> Handler nextHandler; <span style="color:#a0a1a7"><em>// 每个处理者都必须对请求做出处理</em></span>

	<span style="color:#a626a4">public</span> <span style="color:#a626a4">final</span> Response <span style="color:#4078f2">handleMessage</span>(Request request) {
		<span style="color:#986801">Response</span> <span style="color:#986801">response</span> <span style="color:#ab5656">=</span> <span style="color:#0184bb">null</span>;
		<span style="color:#a0a1a7"><em>// 判断是否是自己的处理级别</em></span>
		<span style="color:#a626a4">if</span> (<span style="color:#c18401">this</span>.getHandlerLevel().equals(request.getRequestLevel())) {
			response = <span style="color:#c18401">this</span>.echo(request);
		} <span style="color:#a626a4">else</span> { <span style="color:#a0a1a7"><em>// 不属于自己的处理级别</em></span>
					<span style="color:#a0a1a7"><em>// 判断是否有下一个处理者</em></span>
			<span style="color:#a626a4">if</span> (<span style="color:#c18401">this</span>.nextHandler != <span style="color:#0184bb">null</span>) {
				response = <span style="color:#c18401">this</span>.nextHandler.handleMessage(request);
			} <span style="color:#a626a4">else</span> {
				<span style="color:#a0a1a7"><em>// 没有适当的处理者,业务自行处理</em></span>
			}
		}
		<span style="color:#a626a4">return</span> response;
	}

	<span style="color:#a0a1a7"><em>// 设置下一个处理者是谁</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">setNext</span>(Handler _handler) {
		<span style="color:#c18401">this</span>.nextHandler = _handler;
	}

	<span style="color:#a0a1a7"><em>// 每个处理者都有一个处理级别</em></span>
	<span style="color:#a626a4">protected</span> <span style="color:#a626a4">abstract</span> Level <span style="color:#4078f2">getHandlerLevel</span>();

	<span style="color:#a0a1a7"><em>// 每个处理者都必须实现处理任务</em></span>
	<span style="color:#a626a4">protected</span> <span style="color:#a626a4">abstract</span> Response <span style="color:#4078f2">echo</span>(Request request);
}
</code></span></span>

在处理者中涉及三个类:Level类负责定义请求和处理级别,Request类负责封装请 求,Response负责封装链中返回的结果,该三个类都需要根据业务产生,可以在实际应用中完成相关的业务填充:

复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Level</span> {
	<span style="color:#a0a1a7"><em>//定义一个请求和处理等级</em></span>
}

<span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Request</span> {
	<span style="color:#a0a1a7"><em>//请求的等级 </em></span>
	<span style="color:#a626a4">public</span> Level <span style="color:#4078f2">getRequestLevel</span>(){ <span style="color:#a626a4">return</span> <span style="color:#0184bb">null</span>; }
}

<span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Response</span> {
	<span style="color:#a0a1a7"><em>//处理者返回的数据</em></span>
}
</code></span></span>

● ConcreteHandler(具体处理者):

复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">ConcreteHandler1</span> <span style="color:#a626a4">extends</span> <span style="color:#4078f2">Handler</span>{

	<span style="color:#a0a1a7"><em>/**
	 * 设置自己的处理级别
	 */</em></span>
	<span style="color:#4078f2">@Override</span>
	<span style="color:#a626a4">protected</span> Level <span style="color:#4078f2">getHandlerLevel</span>() {
		<span style="color:#a0a1a7"><em>// TODO Auto-generated method stub</em></span>
		<span style="color:#a626a4">return</span> <span style="color:#0184bb">null</span>;
	}

	<span style="color:#a0a1a7"><em>/**
	 * 定义自己的处理逻辑
	 */</em></span>
	<span style="color:#4078f2">@Override</span>
	<span style="color:#a626a4">protected</span> Response <span style="color:#4078f2">echo</span>(Request request) {
		<span style="color:#a0a1a7"><em>// TODO Auto-generated method stub</em></span>
		<span style="color:#a626a4">return</span> <span style="color:#0184bb">null</span>;
	}

}
</code></span></span>

定义了三个处理者,代码都是一样,此处不重复贴出。

● Client(客户端):在客户端或高层模块中对链进行组装,并传递请求,返回结果。

复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Client</span> {

	<span style="color:#a0a1a7"><em>/**
	 * <span style="color:#a626a4">@param</span> args
	 */</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">static</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">main</span>(String[] args) {
		<span style="color:#a0a1a7"><em>//声明所有的处理节点</em></span>
		<span style="color:#986801">Handler</span> <span style="color:#986801">handler1</span> <span style="color:#ab5656">=</span> <span style="color:#a626a4">new</span> <span style="color:#4078f2">ConcreteHandler1</span>(); 
		<span style="color:#986801">Handler</span> <span style="color:#986801">handler2</span> <span style="color:#ab5656">=</span> <span style="color:#a626a4">new</span> <span style="color:#4078f2">ConcreteHandler2</span>(); 
		<span style="color:#986801">Handler</span> <span style="color:#986801">handler3</span> <span style="color:#ab5656">=</span> <span style="color:#a626a4">new</span> <span style="color:#4078f2">ConcreteHandler3</span>(); 
		<span style="color:#a0a1a7"><em>//设置链中的阶段顺序1-->2-->3 </em></span>
		handler1.setNext(handler2); 
		handler2.setNext(handler3); 
		<span style="color:#a0a1a7"><em>//提交请求,返回结果 </em></span>
		<span style="color:#986801">Response</span> <span style="color:#986801">response</span> <span style="color:#ab5656">=</span> handler1.handleMessage(<span style="color:#a626a4">new</span> <span style="color:#4078f2">Request</span>());
	}

}
</code></span></span>

在实际应用中,一般会有一个封装类对责任模式进行封装,也就是替代Client类,直接返回链中的第一个处理者,具体链的设置不需要高层次模块关系,这样,更简化了高层次模 块的调用,减少模块间的耦合,提高系统的灵活性。

为什么要用责任链模式

这里有一个业务场景,在万恶的封建社会,女子讲究“三从四德”,“三从”是指“未嫁从父、既嫁从夫、夫死从子”。

不使用责任链模式

以批判的态度去分析这个业务场景,类图如下:

图16-2:腐朽的“三从”类图

在这里插入图片描述
IHandler是三个有决策权对象的接口,IWomen是女性的代码。下面是实现:

  • IWomen(妇女接口):
复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">interface</span> <span style="color:#4078f2">IWomen</span> {
	<span style="color:#a0a1a7"><em>//获得个人状况 </em></span>
	<span style="color:#a626a4">public</span> <span style="color:#986801">int</span> <span style="color:#4078f2">getType</span>(); 
	<span style="color:#a0a1a7"><em>//获得个人请示 </em></span>
	<span style="color:#a626a4">public</span> String <span style="color:#4078f2">getRequest</span>();
}
</code></span></span>
  • Women(妇女实现类):
复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Women</span> <span style="color:#a626a4">implements</span> <span style="color:#4078f2">IWomen</span>{
	<span style="color:#a0a1a7"><em>/** 通过一个int类型的参数来描述妇女的个人状况 * 1--未出嫁 * 2--出嫁 * 3--夫死 */</em></span>
	<span style="color:#a626a4">private</span> <span style="color:#986801">int</span> <span style="color:#986801">type</span> <span style="color:#ab5656">=</span> <span style="color:#986801">0</span>;
	<span style="color:#a0a1a7"><em>// 妇女的请示</em></span>
	<span style="color:#a626a4">private</span> <span style="color:#986801">String</span> <span style="color:#986801">request</span> <span style="color:#ab5656">=</span> <span style="color:#50a14f">""</span>;

	<span style="color:#a0a1a7"><em>// 构造函数传递过来请求</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#4078f2">Women</span>(<span style="color:#986801">int</span> _type, String _request) {
		<span style="color:#c18401">this</span>.type = _type;
		<span style="color:#c18401">this</span>.request = _request;
	}

	<span style="color:#a0a1a7"><em>// 获得自己的状况</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#986801">int</span> <span style="color:#4078f2">getType</span>() {
		<span style="color:#a626a4">return</span> <span style="color:#c18401">this</span>.type;
	}

	<span style="color:#a0a1a7"><em>// 获得妇女的请求</em></span>
	<span style="color:#a626a4">public</span> String <span style="color:#4078f2">getRequest</span>() {
		<span style="color:#a626a4">return</span> <span style="color:#c18401">this</span>.request;
	}
}
</code></span></span>
  • IHandler(有处理权的人员接口):
复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">interface</span> <span style="color:#4078f2">IHandler</span> {
	<span style="color:#a0a1a7"><em>//一个女性(女儿、妻子或者母亲)要求逛街,你要处理这个请求 </em></span>
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">HandleMessage</span>(IWomen women);
}
</code></span></span>
  • 实现类:有处理权的人对妇女的请求进行处理,分别有三个实现类,在女儿没有出嫁之前父亲是有决定权的;在女性出嫁后,丈夫有决定权;在女性丧偶后,对母亲提出的请求儿子有决定权;
复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Father</span> <span style="color:#a626a4">implements</span> <span style="color:#4078f2">IHandler</span> {
	<span style="color:#a0a1a7"><em>// 未出嫁的女儿来请示父亲</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">HandleMessage</span>(IWomen women) {
		System.out.println(<span style="color:#50a14f">"女儿的请示是:"</span> + women.getRequest());
		System.out.println(<span style="color:#50a14f">"父亲的答复是:同意"</span>);
	}
}

<span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Husband</span> <span style="color:#a626a4">implements</span> <span style="color:#4078f2">IHandler</span> {
	<span style="color:#a0a1a7"><em>// 妻子向丈夫请示</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">HandleMessage</span>(IWomen women) {
		System.out.println(<span style="color:#50a14f">"妻子的请示是:"</span> + women.getRequest());
		System.out.println(<span style="color:#50a14f">"丈夫的答复是:同意"</span>);
	}
}

<span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Son</span> <span style="color:#a626a4">implements</span> <span style="color:#4078f2">IHandler</span> {
	<span style="color:#a0a1a7"><em>// 母亲向儿子请示</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">HandleMessage</span>(IWomen women) {
		System.out.println(<span style="color:#50a14f">"母亲的请示是:"</span> + women.getRequest());
		System.out.println(<span style="color:#50a14f">"儿子的答复是:同意"</span>);
	}
}
</code></span></span>
  • 场景类:
复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Client</span> {

	<span style="color:#a626a4">public</span> <span style="color:#a626a4">static</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">main</span>(String[] args) {
		<span style="color:#a0a1a7"><em>// 随机挑选几个女性</em></span>
		<span style="color:#986801">Random</span> <span style="color:#986801">rand</span> <span style="color:#ab5656">=</span> <span style="color:#a626a4">new</span> <span style="color:#4078f2">Random</span>();
		ArrayList<IWomen> arrayList = <span style="color:#a626a4">new</span> <span style="color:#4078f2">ArrayList</span>();
		<span style="color:#a626a4">for</span> (<span style="color:#986801">int</span> <span style="color:#986801">i</span> <span style="color:#ab5656">=</span> <span style="color:#986801">0</span>; i < <span style="color:#986801">5</span>; i++) {
			arrayList.add(<span style="color:#a626a4">new</span> <span style="color:#4078f2">Women</span>(rand.nextInt(<span style="color:#986801">4</span>), <span style="color:#50a14f">"看戏"</span>));
		}
		<span style="color:#a0a1a7"><em>// 定义三个请示对象</em></span>
		<span style="color:#986801">IHandler</span> <span style="color:#986801">father</span> <span style="color:#ab5656">=</span> <span style="color:#a626a4">new</span> <span style="color:#4078f2">Father</span>();
		<span style="color:#986801">IHandler</span> <span style="color:#986801">husband</span> <span style="color:#ab5656">=</span> <span style="color:#a626a4">new</span> <span style="color:#4078f2">Husband</span>();
		<span style="color:#986801">IHandler</span> <span style="color:#986801">son</span> <span style="color:#ab5656">=</span> <span style="color:#a626a4">new</span> <span style="color:#4078f2">Son</span>();
		<span style="color:#a626a4">for</span> (IWomen women : arrayList) {
			<span style="color:#a626a4">if</span> (women.getType() == <span style="color:#986801">1</span>) {
				<span style="color:#a0a1a7"><em>// 未结婚少女,请示父亲</em></span>
				System.out.println(<span style="color:#50a14f">"\n--------女儿向父亲请示-------"</span>);
				father.HandleMessage(women);
			} <span style="color:#a626a4">else</span> <span style="color:#a626a4">if</span> (women.getType() == <span style="color:#986801">2</span>) {
				<span style="color:#a0a1a7"><em>// 已婚少妇,请示丈夫</em></span>
				System.out.println(<span style="color:#50a14f">"\n--------妻子向丈夫请示-------"</span>);
				husband.HandleMessage(women);
			} <span style="color:#a626a4">else</span> <span style="color:#a626a4">if</span> (women.getType() == <span style="color:#986801">3</span>) {
				<span style="color:#a0a1a7"><em>// 母亲请示儿子</em></span>
				System.out.println(<span style="color:#50a14f">"\n--------母亲向儿子请示-------"</span>);
				son.HandleMessage(women);
			} <span style="color:#a626a4">else</span> {
				<span style="color:#a0a1a7"><em>// 暂时什么也不做</em></span>
			}
		}
	}

}
</code></span></span>

首先是通过随机方法产生了5个古代妇女的对象,然后看她们是如何就看戏这件事去请示的,运行结果如下:

在这里插入图片描述

OK,业务已经实现了,但是明显这个业务实现是存在问题的。

● 职责界定不清晰
对女儿提出的请示,应该在父亲类中做出决定,父亲有责任、有义务处理女儿的请示, 因此Father类应该是知道女儿的请求自己处理,而不是在Client类中进行组装出来,也就是说原本应该是父亲这个类做的事情抛给了其他类进行处理。

● 代码臃肿
我们在Client类中写了if...else的判断条件,而且能随着能处理该类型的请示人员越多,if...else的判断就越多。

● 耦合过重
这是什么意思呢,我们要根据Women的type来决定使用IHandler的那个实现类来处理请 求。有一个问题是:如果IHandler的实现类继续扩展怎么办?如果修改Client类,那就违背了开闭原则。

● 异常情况欠考虑
妻子只能向丈夫请示吗?如果妻子(比如一个现代女性穿越到古代了,不懂什么“三从四德”)向自己的父亲请示了,父亲应该做何处理?我们的程序上可没有体现出来,逻辑失败了!

引入责任链模式

针对上面的问题,这时候就该考虑引入责任链模式了。

可以抽象成这样一个结构,女性的请求先发送到父亲类,父亲类一看是自己要处理的,就 作出回应处理,如果女儿已经出嫁了,那就要把这个请求转发到女婿来处理,那女婿一旦去天国报道了,那就由儿子来处理这个请求,类似于如图16-3所示的顺序处理图:

图16-3:女性请示的顺序处理图

在这里插入图片描述

父亲、丈夫、儿子每个节点有两个选择:要么承担责任,做出回应;要么把请求转发到后序环节。

根据责任链模式,修改后的类图如下:

图16-4:使用责任链模式后的女子“三从”类图

在这里插入图片描述

实现如下:

  • 改造后的Handler类:
复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">abstract</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Handler</span> {
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">final</span> <span style="color:#a626a4">static</span> <span style="color:#986801">int</span> <span style="color:#986801">FATHER_LEVEL_REQUEST</span> <span style="color:#ab5656">=</span> <span style="color:#986801">1</span>;
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">final</span> <span style="color:#a626a4">static</span> <span style="color:#986801">int</span> <span style="color:#986801">HUSBAND_LEVEL_REQUEST</span> <span style="color:#ab5656">=</span> <span style="color:#986801">2</span>;
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">final</span> <span style="color:#a626a4">static</span> <span style="color:#986801">int</span> <span style="color:#986801">SON_LEVEL_REQUEST</span> <span style="color:#ab5656">=</span> <span style="color:#986801">3</span>;
	<span style="color:#a0a1a7"><em>// 能处理的级别</em></span>
	<span style="color:#a626a4">private</span> <span style="color:#986801">int</span> <span style="color:#986801">level</span> <span style="color:#ab5656">=</span> <span style="color:#986801">0</span>;
	<span style="color:#a0a1a7"><em>// 责任传递,下一个人责任人是谁</em></span>
	<span style="color:#a626a4">private</span> Handler nextHandler;

	<span style="color:#a0a1a7"><em>// 每个类都要说明一下自己能处理哪些请求</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#4078f2">Handler</span>(<span style="color:#986801">int</span> _level) {
		<span style="color:#c18401">this</span>.level = _level;
	}

	<span style="color:#a0a1a7"><em>// 一个女性(女儿、妻子或者是母亲)要求逛街,你要处理这个请求</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">final</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">HandleMessage</span>(IWomen women) {
		<span style="color:#a626a4">if</span> (women.getType() == <span style="color:#c18401">this</span>.level) {
			<span style="color:#c18401">this</span>.response(women);
		} <span style="color:#a626a4">else</span> <span style="color:#a626a4">if</span> (<span style="color:#c18401">this</span>.nextHandler != <span style="color:#0184bb">null</span>) {
			<span style="color:#a0a1a7"><em>// 有后续环节,才把请求往后递送</em></span>
			<span style="color:#c18401">this</span>.nextHandler.HandleMessage(women);
		} <span style="color:#a626a4">else</span> {
			<span style="color:#a0a1a7"><em>// 已经没有后续处理人了,不用处理了</em></span>
			System.out.println(<span style="color:#50a14f">"---没地方请示了,按不同意处理---\n"</span>);
		}
	}

	<span style="color:#a0a1a7"><em>/** 如果不属于你处理的请求,你应该让她找下一个环节的人,如女儿出嫁了, * 还向父亲请示是否可以逛街,那父亲就应该告诉女儿,应该找丈夫请示 */</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">setNext</span>(Handler _handler) {
		<span style="color:#c18401">this</span>.nextHandler = _handler;
	}

<span style="color:#a0a1a7"><em>//有请示那当然要回应</em></span>
	<span style="color:#a626a4">protected</span> <span style="color:#a626a4">abstract</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">response</span>(IWomen women);
}
</code></span></span>

在这里也用到模板方法模式,在模板方法中判断请求的级别和当前能够处理的级别,如果相同则调用基本方法,做出 反馈;如果不相等,则传递到下一个环节,由下一环节做出回应,如果已经达到环节结尾, 则直接做不同意处理。基本方法response需要各个实现类实现,每个实现类只要实现两个职 责:一是定义自己能够处理的等级级别;二是对请求做出回应。

三个实现类如下:三个实现类分别处理不同等级的请求

  • 父亲类:
复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Father</span> <span style="color:#a626a4">extends</span> <span style="color:#4078f2">Handler</span> {
	<span style="color:#a0a1a7"><em>// 父亲只处理女儿的请求</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#4078f2">Father</span>() {
		<span style="color:#c18401">super</span>(Handler.FATHER_LEVEL_REQUEST);
	}

	<span style="color:#a0a1a7"><em>// 父亲的答复</em></span>
	<span style="color:#a626a4">protected</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">response</span>(IWomen women) {
		System.out.println(<span style="color:#50a14f">"--------女儿向父亲请示-------"</span>);
		System.out.println(women.getRequest());
		System.out.println(<span style="color:#50a14f">"父亲的答复是:同意\n"</span>);
	}
}
</code></span></span>
  • 丈夫类:
复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Husband</span> <span style="color:#a626a4">extends</span> <span style="color:#4078f2">Handler</span> {
	<span style="color:#a0a1a7"><em>// 丈夫只处理妻子的请求</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#4078f2">Husband</span>() {
		<span style="color:#c18401">super</span>(Handler.HUSBAND_LEVEL_REQUEST);
	}

<span style="color:#a0a1a7"><em>//丈夫请示的答复 </em></span>
	<span style="color:#a626a4">protected</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">response</span>(IWomen women) {
		System.out.println(<span style="color:#50a14f">"--------妻子向丈夫请示-------"</span>);
		System.out.println(women.getRequest());
		System.out.println(<span style="color:#50a14f">"丈夫的答复是:同意\n"</span>);
	}
}
</code></span></span>
  • 儿子类:
复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Son</span> <span style="color:#a626a4">extends</span> <span style="color:#4078f2">Handler</span> {
	<span style="color:#a0a1a7"><em>// 儿子只处理母亲的请求</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#4078f2">Son</span>() {
		<span style="color:#c18401">super</span>(Handler.SON_LEVEL_REQUEST);
	}

	<span style="color:#a0a1a7"><em>// 儿子的答复</em></span>
	<span style="color:#a626a4">protected</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">response</span>(IWomen women) {
		System.out.println(<span style="color:#50a14f">"--------母亲向儿子请示-------"</span>);
		System.out.println(women.getRequest());
		System.out.println(<span style="color:#50a14f">"儿子的答复是:同意\n"</span>);
	}
}
</code></span></span>
  • Women类的接口没有任何变化

  • 实现类稍微有些变化:为了展示结果清晰一点,输出请求的来源

复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Women</span> <span style="color:#a626a4">implements</span> <span style="color:#4078f2">IWomen</span> {
	<span style="color:#a0a1a7"><em>/**
	 * 通过一个int类型的参数来描述妇女的个人状况 1--未出嫁 * 2--出嫁 * 3--夫死
	 */</em></span>
	<span style="color:#a626a4">private</span> <span style="color:#986801">int</span> <span style="color:#986801">type</span> <span style="color:#ab5656">=</span> <span style="color:#986801">0</span>;
	<span style="color:#a0a1a7"><em>// 妇女的请示</em></span>
	<span style="color:#a626a4">private</span> <span style="color:#986801">String</span> <span style="color:#986801">request</span> <span style="color:#ab5656">=</span> <span style="color:#50a14f">""</span>;

	<span style="color:#a0a1a7"><em>// 构造函数传递过来请求</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#4078f2">Women</span>(<span style="color:#986801">int</span> _type, String _request) {
		<span style="color:#c18401">this</span>.type = _type; <span style="color:#a0a1a7"><em>// 为了便于显示,在这里做了点处理</em></span>
		<span style="color:#a626a4">switch</span> (<span style="color:#c18401">this</span>.type) {
		<span style="color:#a626a4">case</span> <span style="color:#986801">1</span>:
			<span style="color:#c18401">this</span>.request = <span style="color:#50a14f">"女儿的请求是:"</span> + _request;
			<span style="color:#a626a4">break</span>;
		<span style="color:#a626a4">case</span> <span style="color:#986801">2</span>:
			<span style="color:#c18401">this</span>.request = <span style="color:#50a14f">"妻子的请求是:"</span> + _request;
			<span style="color:#a626a4">break</span>;
		<span style="color:#a626a4">case</span> <span style="color:#986801">3</span>:
			<span style="color:#c18401">this</span>.request = <span style="color:#50a14f">"母亲的请求是:"</span> + _request;
		}
	}

	<span style="color:#a0a1a7"><em>// 获得自己的状况</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#986801">int</span> <span style="color:#4078f2">getType</span>() {
		<span style="color:#a626a4">return</span> <span style="color:#c18401">this</span>.type;
	}

	<span style="color:#a0a1a7"><em>// 获得妇女的请求</em></span>
	<span style="color:#a626a4">public</span> String <span style="color:#4078f2">getRequest</span>() {
		<span style="color:#a626a4">return</span> <span style="color:#c18401">this</span>.request;
	}
}
</code></span></span>

  • 场景类:
复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Client</span> {
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">static</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">main</span>(String[] args) {
		<span style="color:#a0a1a7"><em>// 随机挑选几个女性</em></span>
		<span style="color:#986801">Random</span> <span style="color:#986801">rand</span> <span style="color:#ab5656">=</span> <span style="color:#a626a4">new</span> <span style="color:#4078f2">Random</span>();
		ArrayList<IWomen> arrayList = <span style="color:#a626a4">new</span> <span style="color:#4078f2">ArrayList</span>();
		<span style="color:#a626a4">for</span> (<span style="color:#986801">int</span> <span style="color:#986801">i</span> <span style="color:#ab5656">=</span> <span style="color:#986801">0</span>; i < <span style="color:#986801">5</span>; i++) {
			arrayList.add(<span style="color:#a626a4">new</span> <span style="color:#4078f2">Women</span>(rand.nextInt(<span style="color:#986801">4</span>), <span style="color:#50a14f">"我要看戏"</span>));
		}
		<span style="color:#a0a1a7"><em>// 定义三个请示对象</em></span>
		<span style="color:#986801">Handler</span> <span style="color:#986801">father</span> <span style="color:#ab5656">=</span> <span style="color:#a626a4">new</span> <span style="color:#4078f2">Father</span>();
		<span style="color:#986801">Handler</span> <span style="color:#986801">husband</span> <span style="color:#ab5656">=</span> <span style="color:#a626a4">new</span> <span style="color:#4078f2">Husband</span>();
		<span style="color:#986801">Handler</span> <span style="color:#986801">son</span> <span style="color:#ab5656">=</span> <span style="color:#a626a4">new</span> <span style="color:#4078f2">Son</span>();
		<span style="color:#a0a1a7"><em>// 设置请示顺序</em></span>
		father.setNext(husband);
		husband.setNext(son);
		<span style="color:#a626a4">for</span> (IWomen women : arrayList) {
			father.HandleMessage(women);
		}
	}
}
</code></span></span>

在Client中设置请求的传递顺序,先向父亲请示,不是父亲应该解决的问题,则由父亲 传递到丈夫类解决,若不是丈夫类解决的问题则传递到儿子类解决,最终的结果必然有一个 返回,其运行结果如下所示:

在这里插入图片描述

业务调用类Client不用再去做判断到底是需要谁去处理,而且Handler抽象类的子类可以继续增加下去,只需要扩展传递链而已,调用类可以不用了解变化过程,甚至是谁在处理这个请求都不用知道。

责任链模式优缺点

责任链模式优点

  • 责任链模式使得一个对象无须知道是其他哪一个对象处理其请求,对象仅需知道该请求会 被处理即可,接收者和发送者都没有对方的明确信息,且链中的对象不需要知道链的结构, 由客户端负责链的创建,降低了系统的耦合度。
  • 请求处理对象仅需维持一个指向其后继者的引用,而不需要维持它对所有的候选处理者的 引用,可简化对象的相互连接。
  • 在给对象分派职责时,职责链可以给我们更多的灵活性,可以通过在运行时对该链进行动 态的增加或修改来增加或改变处理一个请求的职责。
  • 在系统中增加一个新的具体请求处理者时无须修改原有系统的代码,只需要在客户端重新 建链即可,从这一点来看是符合“开闭原则”的。

责任链模式缺点

  • 由于一个请求没有明确的接收者,那么就不能保证它一定会被处理,该请求可能一直到链 的末端都得不到处理;一个请求也可能因职责链没有被正确配置而得不到处理。
  • 对于比较长的职责链,请求的处理可能涉及到多个处理对象,系统性能将受到一定影响, 而且在进行代码调试时不太方便。
  • 如果建链不当,可能会造成循环调用,将导致系统陷入死循环。

责任链模式应用场景

在以下情况下可以考虑使用职责链模式:

  • 有多个对象可以处理同一个请求,具体哪个对象处理该请求待运行时刻再确定,客户端只 需将请求提交到链上,而无须关心请求的处理对象是谁以及它是如何处理的。
  • 在不明确指定接收者的情况下,向多个对象中的一个提交一个请求。
  • 可动态指定一组对象处理请求,客户端可以动态创建职责链来处理请求,还可以改变链中 处理者之间的先后次序。

域用户无法修改密码问题的解决方案 问题描述:加域的电脑无法更改密码,提示“无法更新密码,为新密码提供的值不符合字符域的长度、复杂度或历史要求”。 问题原因:域控制器中相关设置问题,主要如下图所示(如启用复杂性、最短期限和强制密码历史) 解决方案:在域控制器中更改对应的密码策略即可: ① 禁用复杂性要求 ② 最短使用期限改为0天 ③ 强制密码历史改为0 如果出现无法更改的情况,如下图箭头所指的图标所示 代表需要在域控制器的组策... 阅读详情

相关推荐

Geant4学习一:写一个简单程序

1、 基本介绍

ccwwNUAA的博客 7700

JAVA架构师之路十六:设计模式之责任链模式

责任链模式

cuixhao110的博客 8万+

PaddleOCR PP-OCRv5实战:5分钟搞定身份证信息提取(附完整代码)

本文详细介绍了如何利用PaddleOCR的PP-OCRv5模型,在5分钟内快速搭建身份证信息提取流程。文章从环境搭建、核心代码实战出发,深入解析了PP-OCRv5针对证件识别的优化特性,并提供了从OCR结果到结构化数据的完整处理方案与避坑指南,帮助开发者高效实现AI驱动的自动化信息提取。

salt9的博客 785

设计模式(十六):行为型之责任链模式

一个请求有多个对象可以处理,但每个对象的处理条件或权限不同例如,公司员工请假,可批假的领导有部门负责人、副总经理、总经理等但每个领导能批准的天数不同,员工必须根据自己要请假的天数去找不同的领导签名也就是说员工必须记住每个领导的姓名、电话和地址等信息,这增加了难度定义为了避免请求发送者与多个请求处理者耦合在一起将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链当有请求发生时,可将请求沿着这条链传递,直到有对象处理它为止。

从基础到源码解析的学习记录 2137

OAI骨关节炎数据集申请与DICOM下载全流程避坑指南

医学影像分析中,DICOM格式是存储与交换CT、MRI等数据的通用标准,其元数据Tag承载着像素间距、层厚等关键物理信息,直接影响定量分析的准确性。在骨关节炎研究领域,OAI数据集因样本量大、随访时间长而成为高价值资源,但获取需通过NDA协议申请,并借助nda-tools命令行工具完成TB级影像的批量下载与断点续传。这一流程涉及浏览器环境配置、DICOM格式转换及Python预处理等工程环节,任一细节疏漏都可能导致数据读取异常或分析偏差。掌握从申请到落地的完整链路,能显著提升医学影像AI研究的效率与可复现性

weixin_30843121的博客 279

华为OD机试双机位C卷:流量波峰 (C/C++/Py/Java/Js/Go)

华为OD机试双机位C卷 流量波峰,提供C语言、Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解。华为OD机试 - 流量波峰。

qq_45776114的博客 2448

【专题系列】搞定设计模式之—— 十六 :责任链模式

点击上方“java大数据修炼之道”,选择“设为星标”优质文章, 第一时间送达目录什么是责任链模式?为什么要用责任链模式不使用责任链模式引入责任链模式责任链模式优缺点责任链模式优点责任链模...

hello world! 718

YOLOv13手把手添加YOLOv13注意力机制:Biformer(BiLevelRoutingAttentio)YOLOv13双层路由注意力 革命性的高效注意力机制深度解析YOLOv13YOLOv1

YOLOv13 BiLevelRoutingAttention是一种革命性的高效注意力机制,YOLOv13通过双层路由策略显著降低了计算复杂度。YOLO它将注意力计算分为区域级路由和令牌级注意力两个层次,前者选择最相关的K个区域,后者仅在选定区域内执行注意力计算。这种设计借鉴了人类视觉系统的分层处理机制,在保持长距离依赖建模能力的同时,将复杂度从O(N²)降至O(NK + P⁴)。该机制还集成了可微分路由、自适应参数和LePE位置编码等创新技术,YOLOv13 YOLOv13 YOLOv13 YOLOv13

FJN110的博客 660

设计模式学习(十六):责任链模式

不过,更为优雅的一种方式是设计一个 FilterChain ,把所有的 Filter 都加入到这个 FilterChain 里面,对于 Msg 直接去调用 FilterChain 的过滤方法即可把 FilterChain 中的所有 Filter 都执行,而且还可以很灵活指定 Filter 顺序。我们有多个过滤规则,比如第一个规则是:过滤 scripts 这个关键字(实际的规则可能很复杂,目前只是举这个简单例子来说明情况)然后,可以抽象一个 Filter 接口,各种过滤规则无非就是实现这个接口即可。

Practitioner 286

从数据库到数据仓库:数据仓库导论

本文为数据仓库导论,旨在介绍数据仓库的基本理念和应用场景,帮助读者理解数据仓库的重要性及其在企业中的实际应用。

探索大数据世界 - 深入解析数据存储、分布式计算与人工智能 2788

prometheus普罗米修斯集监控外部k8s

prometheus普罗米修斯集监控外部k8s

你是我一生的追求 2250

设计模式十六:责任链模式(Command)

在现实生活中,常常会出现这样的事例:一个请求有多个对象可以处理,但每个对象的处理条件或权限不同。例如,公司员工请假,可批假的领导有部门负责人、副总经理、总经理等,但每个领导能批准的天数不同,员工必须根据自己要请假的天数去找不同的领导签名,也就是说员工必须记住每个领导的姓名、电话和地址等信息,这增加了难度。这样的例子还有很多,如找领导出差报销、生活中的“击鼓传花”游戏等。 在计算机软硬件中也有相关例...

weixin_42073629的博客 345

Autodesk Revit软件二次开发:Revit二次开发中的插件设计与实现

在 Revit 中,族是构成建筑模型的基本单元,可以是门窗、家具等。通过自定义族,可以创建符合特定需求的建筑构件。参数化设计允许族的尺寸、形状等属性根据参数变化而变化。使用 Revit API 创建自定义族涉及多个步骤,包括定义族类型、设置参数、创建几何形状等。// 创建族文档// 定义参数Parameter param = family.FamilyManager.AddParameter("Width", BuiltInParameterGroup.PG_LENGTH, "宽度");

kkchenjj的博客 2232

设计模式(十六):责任链模式

抽象处理者角色(Handler):定义出一个处理请求的接口。如果需要,接口可以定义 出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。 具体处理者角色(ConcreteHandler):具体处理者接到请求后,可以选择将请求处理掉,或者将请求传给下家。由于具体处理者持有对下家的引用,因此,如果需要,具体处理者可以访问下家。 //抽象处理者 public abstract class Handler { /** * 持有后继的责任对象

qq_34748010的博客 131

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

【Java设计模式】十六、责任链模式

三个请求处理者(领导)连成一条线,现在张三来请假,只需找其部分负责人即可,部门负责人看张三请假的天数,自己能批准就批准,不能批准就找他自己的上级(副总经理),以此类推。需求:请假流程控制,一天以下只需小组长同意,1到3天需要部门经理同意,3到7天需要总经理同意。责任链模式,即:为了避免请求发送者和多个请求处理者耦合在一起,让所有请求处理者通过下一对象的引用连成一条链。如此实现,扩展性强很强:如果以后要加个总监审批,那就再定义个具体处理者类,set进责任链即可。定义具体的处理者,继承抽象处理:小组长。

llg___的博客 1728

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

【设计模式系列】责任链模式(十六)

责任链模式(Chain of Responsibility Pattern)是一种行为型设计模式。其核心思想是将请求的发送者和接收者解耦,通过一个中介链来传递请求,使得多个对象都有可能接收请求,从而避免请求发送者和接收者之间的耦合关系。抽象处理者(Handler)角色:作为责任链模式的核心,这个接口定义了统一的处理请求的方法,并定义了如何将请求传递给下一个处理者。具体处理者(Concrete Handler)角色:实现抽象处理者的处理方法,判断能否处理本次请求。如果可以处理请求,则直接处理;否则,将请求传递

LHW0621的专栏 1286

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

设计模式之十六责任链模式

前言: 责任链模式亦称:职责链模式、命令链、CoR、Chain of Command、Chain of Responsibility,是一种行为设计模式,允许你将请求沿着处理者链进行发送。收到请求后,每个处理者均可对请求进行处理,或将其传递给链上的下个处理者。 目录 一、结构 二、代码实现(敏感词汇过滤) 三、责任链模式在开源框架中的应用 3.1、Java Servlet中的应用 3.2、Spring Inte...

heijunwei的博客 589

十六、行为型(责任链模式)

责任链模式是一种行为型设计模式,它使多个对象都有机会处理请求,从而避免请求的发送者与接收者之间的耦合。:在日志记录或权限验证的场景中,不同的日志级别或权限控制可以使用责任链模式进行逐级处理。:当一个请求可能被多个对象处理时,可以采用责任链模式将这些处理对象串联起来,沿着链条传递请求,直到找到合适的处理者。在某些情况下,责任链的顺序可能并不是固定的。:如果链条中包含的处理者对象很多,请求在链中传递的时间可能会较长,因此链的长度不宜过长。:实现处理者接口的类,负责处理具体的请求,或者将请求传递给下一个处理者。

xiaoqi270620903的专栏 1032

【新人系列】Python 入门(二十六):常见设计模式

提高代码可重用性(重点)提供代码的扩展性(重点)提高可读性提高软件的性能、效率提高代码的维护性。

Newin2020的博客 1491

JAVA设计模式(十六) -- 责任链模式

一、概念 责任链模式:使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。 二、责任链模式的组成结构 抽象处理者角色(Handler): 它定义了一个处理请求的接口。当然对于链子的不同实现,也可以在这个角色中实现后继链。 具体处理者角色(Concrete Handler): 实现抽象角色中定义的接口,并处理...

分享技术,共同进步! 249

小白十六篇 责任链模式

责任链模式 多个拦截器对于同一件事情实现多重拦截,即一个对象在一条链上被多个拦截器拦截处理。 对于一个真实对象,以三层拦截器为例子: 到达第一个拦截器将使用第一个动态代理proxy_1 到达第二个拦截器将使用第二个动态代理proxy_2并且是在第一个动态代理的基础上生成 到达第三个拦截器将使用第三个动态代理proxy_3并且是在第二个动态代理的基础上生成 达到层层控制的效果。 责任链模式案例...

小青的博客 207

第六十六节 Java设计模式 -责任链模式

Java设计模式 -责任链模式

2301_78772942的博客 1206

设计模式—— 十六

其实关于Kafka,能问的问题实在是太多了,扒了几天,最终筛选出44问:基础篇17问、进阶篇15问、高级篇12问,个个直戳痛点,不知道如果你不着急看答案,又能答出几个呢?若是对Kafka的知识还回忆不起来,不妨先看我手绘的知识总结脑图(xmind不能上传,文章里用的是图片版)进行整体架构的梳理梳理了知识,刷完了面试,如若你还想进一步的深入学习解读kafka以及源码,那么接下来的这份《手写“kafka”》将会是个不错的选择。Kafka入门为什么选择KafkaKafka的安装、管理和配置。

VIP129370的博客 765

【设计模式】第十五章:责任链模式详解及应用案例

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

Bummon的学习随笔 595
上一篇: 设计模式—— 十五 :命令模式
下一篇: 设计模式—— 十七:装饰器模式
加班不秃顶
博客等级 码龄7年 1822粉丝 599原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值