23种设计模式----责任链模式----行为型模式

文章信息

• 原文链接：https://jiayq.blog.csdn.net/article/details/84667778
• 发布时间：2018-11-30 20:50:43
• 阅读量：447
• 分类：java同时被 2 个专栏收录, 订阅专栏, 设计模式
• 标签：#责任链模式, #23种设计模式, #行为型模式, #环形责任链, #推卸责任

摘要

文章浏览阅读447次。本文深入讲解了责任链模式的概念，包括其角色定义、工作原理及实际应用案例。通过具体代码示例，展示了如何构建和使用责任链来解决特定问题，同时探讨了模式的扩展性和策略选择。

---

责任链模式

• 1.什么是责任链模式
• 2.责任链模式的角色
• 3.例子
• • 3.1 抽象的责任
    • 3.2 具体的责任
    • 3.3 责任链
    • 3.4结果
    • 3.5 环形责任链
    • 3.6 结果
• 4.扩展

23种设计模式

1.什么是责任链模式

责任：什么是责任，对于Java中的类来说，需要解决某一个问题，就需要调用这个方法。换句话说，拥有这个方法的类有责任解决这个问题。
所以，对于类，其方法就是责任。
责任链：责任链就是以什么顺序去寻找相应的方法。

责任链模式重要的一点：推卸责任。
在这里推卸责任不是贬义，而是一个褒义。对于类来说，只需要关心自己的责任，而不用关心其他的，当需要调用一个方法解决问题时，如果是自己的责任，那么就调用相应的方法解决。如果不是自己的责任，那么久推卸责任，至于推卸给谁，这是一个策略问题。（后面会讨论）

2.责任链模式的角色

抽象的责任，定义责任应当有什么方法，这些方法规定了责任的查询和方法的调用。责任的查询和方法的执行是抽象方法，由责任的子类去实现。
具体的责任，实现抽象的责任中定义的方法，也是解决问题的具体实现。
责任链接，这里定义了具体的责任如何形成链。

3.例子

3.1 抽象的责任

package chainResponsibility.absHander;

public abstract class AbsHander {

	protected Boolean resolve;
	
	private AbsHander next;
	
	public AbsHander(){
		this.resolve = Boolean.FALSE;
	}
	
	public void execute(AbsHander absHander){
		isResolve(absHander);
		System.out.println("---"+getName()+"--->");
		if(resolve){
			System.out.println(absHander.getName()+" problem is resolve by "+getName());
		} else {
			next.execute(absHander);
		}
	}
	
	protected abstract String getName();
	
	protected abstract void isResolve(AbsHander absHander);
	
	public AbsHander setNest(AbsHander next){
		this.next = next;
		return next;
	}
	
}

3.2 具体的责任

package chainResponsibility.implHander;

import chainResponsibility.absHander.AbsHander;

public class Hander1 extends AbsHander{

	@Override
	protected String getName() {
		return "Hander1";
	}

	@Override
	protected void isResolve(AbsHander absHander) {
		if(absHander instanceof Hander1){
			super.resolve = Boolean.TRUE;
		} else {
			super.resolve = Boolean.FALSE;
		}
	}

}




package chainResponsibility.implHander;

import chainResponsibility.absHander.AbsHander;

public class Hander2 extends AbsHander{

	@Override
	protected String getName() {
		return "Hander2";
	}

	@Override
	protected void isResolve(AbsHander absHander) {
		if(absHander instanceof Hander2){
			super.resolve = Boolean.TRUE;
		} else {
			super.resolve = Boolean.FALSE;
		}
	}

}




package chainResponsibility.implHander;

import chainResponsibility.absHander.AbsHander;

public class Hander3 extends AbsHander{

	@Override
	protected String getName() {
		return "Hander3";
	}

	@Override
	protected void isResolve(AbsHander absHander) {
		if(absHander instanceof Hander3){
			super.resolve = Boolean.TRUE;
		} else {
			super.resolve = Boolean.FALSE;
		}
	}

}

3.3 责任链

package chainResponsibility.client;

import chainResponsibility.absHander.AbsHander;
import chainResponsibility.implHander.Hander1;
import chainResponsibility.implHander.Hander2;
import chainResponsibility.implHander.Hander3;

public class Main {

	public static void main(String[] args) {
		AbsHander h1 = new Hander1();
		AbsHander h2 = new Hander2();
		AbsHander h3 = new Hander3();
		
		h1.setNest(h2).setNest(h3).setNest(h1);
		
		h1.execute(h3);
		
		h1.execute(h2);
		
		h2.execute(h3);
		
	}

}

3.4结果

---Hander1--->
---Hander2--->
---Hander3--->
Hander3 problem is resolve by Hander3
---Hander1--->
---Hander2--->
Hander2 problem is resolve by Hander2
---Hander2--->
---Hander3--->
Hander3 problem is resolve by Hander3

3.5 环形责任链

package chainResponsibility.client;

import chainResponsibility.absHander.AbsHander;
import chainResponsibility.implHander.Hander1;
import chainResponsibility.implHander.Hander2;
import chainResponsibility.implHander.Hander3;

public class Main {

	public static void main(String[] args) {
		AbsHander h1 = new Hander1();
		AbsHander h2 = new Hander2();
		AbsHander h3 = new Hander3();
		
		h1.setNest(h2).setNest(h3).setNest(h1);
		
		h1.execute(h3);
		
		h1.execute(h2);
		
		h2.execute(h3);
		
		h2.execute(h1);

		h3.execute(h2);

		h3.execute(h1);
	}

}

3.6 结果

---Hander1--->
---Hander2--->
---Hander3--->
Hander3 problem is resolve by Hander3
---Hander1--->
---Hander2--->
Hander2 problem is resolve by Hander2
---Hander2--->
---Hander3--->
Hander3 problem is resolve by Hander3
---Hander2--->
---Hander3--->
---Hander1--->
Hander1 problem is resolve by Hander1
---Hander3--->
---Hander1--->
---Hander2--->
Hander2 problem is resolve by Hander2
---Hander3--->
---Hander1--->
Hander1 problem is resolve by Hander1

4.扩展

责任链本身并不复杂，但是对于如何形成最优的责任链，这才是责任链 中最复杂的。
对于责任链，其实就是如何寻找最佳路线的问题，这方面的解决方案有很多。
责任链模式同样可以被改造成双向责任链的寻找方式，以及二叉树的寻找方式以及网格，图的寻找方式。
23种设计模式