简介:这种设计模式使多个对象都有机会处理同一个请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。
在这种模式中,通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求,那么它会把相同的请求传给下一个接收者,依此类推。
下面的例子是一个关于“开会,请假,出差”的例子,这三个业务处理器执行起来有顺序。开会的处理器可以执行开会,请假,出差。请假的处理器可以执行请假,出差。而出差的处理器只能处理出差,不能执行请假和开会。
/**
*定义一个业务,该业务有三种类型,分别是开会,请假,出差。这三种业务类型有严格的次序,分别是开会->请假->出差,
*或者开会—>出差,或者请假->出差,或者开会->请假。不能反向执行!
*/
public class Task {
private String name;
private Integer type;//1代表开会,2代表请假,3代表出差
public String getName() {
return name;
}
public Integer getType() {
return type;
}
public void setType(Integer type) {
this.type = type;
if(type==1){
this.name="开会";
}
if(type==2){
this.name="请假";
}
if(type==3){
this.name="出差";
}
}
@Override
public String toString() {
return "Task [name=" + name + ", type=" + type + "]";
}
}
/**
*创建一个抽象的处理器
*/
abstract class AbstractHandler {
public static int MEET = 1;//开会
public static int LEAVE = 2;//请假
public static int TRAVEL = 3;//出差
public int level;//处理器等级
// 下一个处理器
private AbstractHandler nextHandler;
//设置下一个处理器
public AbstractHandler setNextHandler(AbstractHandler handler){
this.nextHandler=handler;
return nextHandler;
}
public void doHandler(Task task){
if(this.level<=task.getType()){
doTask(task);
}
//如果存在下一个处理器,那么重新执行业务。
if(nextHandler!=null){
nextHandler.doHandler(task);
}
}
public String getHandlerName(){
if(this.level==MEET){
return "开会handler";
}else if(this.level==LEAVE){
return "请假handler";
}else if(this.level==TRAVEL){
return "出差handler";
}else{
return "不存在的handler";
}
}
//抽象的方法,因处理器而异
abstract void doTask(Task task);
}
/**
*开会处理器
*/
class MeetHandler extends AbstractHandler{
public MeetHandler(int level) {
this.level=level;
}
@Override
protected void doTask(Task task) {
System.err.println("处理器是"+getHandlerName()+", 处理等级是"+level+", task是:"+task);
}
}
/**
* 请假处理器
*/
class LeaveHandler extends AbstractHandler{
public LeaveHandler(int level) {
this.level=level;
}
@Override
protected void doTask(Task task) {
System.err.println("处理器是"+getHandlerName()+", 处理等级是"+level+", task是:"+task);
}
}
/**
*出差处理器
*/
class TravelHandler extends AbstractHandler{
public TravelHandler(int level) {
this.level=level;
}
@Override
protected void doTask(Task task) {
System.err.println("处理器是"+getHandlerName()+", 处理等级是"+level+", task是:"+task);
}
}
主程序:
public static void main(String[] args) {
AbstractHandler handler=new MeetHandler(1);
handler.setNextHandler(new LeaveHandler(2)).setNextHandler(new TravelHandler(3));
Task task=new Task();
task.setType(1);
handler.doHandler(task);
}
运行结果:
处理器是开会handler, 处理等级是1, task是:Task [name=开会, type=1]
主程序:
public static void main(String[] args) {
AbstractHandler handler=new MeetHandler(1);
handler.setNextHandler(new LeaveHandler(2)).setNextHandler(new TravelHandler(3));
Task task=new Task();
task.setType(2);
handler.doHandler(task);
}
运行结果:
处理器是开会handler, 处理等级是1, task是:Task [name=请假, type=2]
处理器是请假handler, 处理等级是2, task是:Task [name=请假, type=2]
主程序:
public static void main(String[] args) {
AbstractHandler handler=new MeetHandler(1);
handler.setNextHandler(new LeaveHandler(2)).setNextHandler(new TravelHandler(3));
Task task=new Task();
task.setType(3);
handler.doHandler(task);
}
运行结果:
处理器是开会handler, 处理等级是1, task是:Task [name=出差, type=3]
处理器是请假handler, 处理等级是2, task是:Task [name=出差, type=3]
处理器是出差handler, 处理等级是3, task是:Task [name=出差, type=3]
参考的文章:
菜鸟教程:责任链模式,
coshaho的博客