责任链模式

逻辑：

请假这个事情，相信每个人都不陌生。

我们公司是个相对很宽松的公司。

在公司里，如果你的请假时间小于0.5天，那么只需要向项目经理打声招呼就OK了。

如果超过了0.5天，但是还小于2天，那么就要去找人事部处理，当然，这就要扣工资了。

如果超过了2天，你就需要去找总经理了，工资当然也玩完了。

 

类图：

 

 

 代码：

Requester

package designMode.responsibility;

/** 
 * @Package designMode.responsibility

 * @ClassName: Requester

 * @Description: TODO(这里用一句话描述这个类的作用)

 * @author andy

 * @date 2014-8-26 下午4:35:56

 */
public class Requester {
    private int day;
    private String reason;

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }

    public Requester(int day, String reason) {
        this.day = day;
        this.reason = reason;
    }
}

Boss

package designMode.responsibility;

/** 
 * @Package designMode.responsibility

 * @ClassName: Boss

 * @Description: TODO(这里用一句话描述这个类的作用)

 * @author andy

 * @date 2014-8-26 下午4:38:29

 */
public abstract class Boss {
    private String name;
    private Boss successor;
    
    public Boss(String str){
        this.name = str;
    }
    
    public abstract boolean passRequest(Requester req);

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Boss getSuccessor() {
        return successor;
    }

    public void setSuccessor(Boss successor) {
        this.successor = successor;
    }
}

 

 

 ProjectManager

package designMode.responsibility;

/** 
 * @Package designMode.responsibility

 * @ClassName: ProjectManager

 * @Description: TODO(这里用一句话描述这个类的作用)

 * @author andy

 * @date 2014-8-26 下午4:43:12

 */
public class ProjectManager extends Boss {

    public ProjectManager(String str) {
        super(str);
    }
    
    public boolean passRequest(Requester req) {
        if(null != req){
            if(req.getDay() <=0.5){
                System.out.println(this.getName() + "处理!");
                return true;
            }else{
                this.getSuccessor().passRequest(req);
            }
        }
        return false;
    }

}

HumanResource

package designMode.responsibility;

/** 
 * @Package designMode.responsibility

 * @ClassName: HumanResource

 * @Description: TODO(这里用一句话描述这个类的作用)

 * @author andy

 * @date 2014-8-26 下午4:46:06

 */
public class HumanResource extends Boss{
    
    public HumanResource(String str) {
        super(str);
    }

    public  boolean passRequest(Requester req){
        if(null != req){
            if(req.getDay()<=2){
                System.out.println(this.getName() + "处理!");
                return true;
            }else{
                this.getSuccessor().passRequest(req);
            }
        }
        return false;
    }
}

Manager

package designMode.responsibility;

/** 
 * @Package designMode.responsibility

 * @ClassName: Manager

 * @Description: TODO(这里用一句话描述这个类的作用)

 * @author andy

 * @date 2014-8-26 下午4:50:17

 */
public class Manager extends Boss {

    public Manager(String str) {
        super(str);
    }

    public boolean passRequest(Requester req) {
        if(null != req && "正当理由".equals(req.getReason())){
            System.out.println(this.getName() + "处理!");
            return true;
        }
        return false;
    }

}

MainTest

package designMode.responsibility;

/** 
 * @Package designMode.responsibility

 * @ClassName: MainTest

 * @Description: TODO(这里用一句话描述这个类的作用)

 * @author andy

 * @date 2014-8-26 下午5:02:52

 */
public class MainTest {
    
    public static void main(String[] args) {
        Requester requester = new Requester(1, "正当理由");
        Boss a = new ProjectManager("项目经理");
        Boss b = new HumanResource("人事部");
        Boss c = new Manager("总经理");
        
        a.setSuccessor(b);
        b.setSuccessor(c);
        a.passRequest(requester);
    }

}

控制台打印结果：人事部处理!

 

定义: 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系(即将 if else 都写在一起)。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

1、有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定；

2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求；

3、处理一个请求的对象集合应被动态指定。

 

不足之处：

让我们继续回到上面的例子，我们发现，其实当请假时间超过2天的时候，PM和HR其实没有做任何的事情，而只是做了一个传递工作。

而传递工作之后，他们就成了垃圾对象。

也就是说，他们在实际的处理中，并没有发挥任何的作用。

那么当这个链结构比较长，比较复杂的话，会产生很多的内存垃圾对象。

对于每一个请求都需要遍历职责链，性能是个问题；

 

 

 

参考：  http://www.cnblogs.com/kym/archive/2009/04/06/1430078.html