【JAVA设计模式08】——责任链模式

来源：慕课网

模式的秘密——责任链模式




责任链模式实例：



（1）首先，创建一个抽象类PriceHandler ：
         successor指代责任链上的下一个对象。
         processDiscount(float discount)是处理折扣的具体方法，需要子类实现。
         静态工厂方法createPriceHandler() 用来组装一个责任链。

package tao.pattern.cor.handler;

public abstract class PriceHandler {

/*
* 直接后继
*/
protected PriceHandler successor;

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

/*
* 处理折扣的方法
*/
public abstract void processDiscount(float discount);

/*
* 建立责任链的工厂方法
*/
public static PriceHandler createPriceHandler() {

PriceHandler sales = new Sales();
PriceHandler manager = new Manager();
PriceHandler director = new Director();
PriceHandler vicePresident = new VicePresident();
PriceHandler ceo = new CEO();

//建立责任链
sales.setSuccessor(manager);
manager.setSuccessor(director);
director.setSuccessor(vicePresident);
vicePresident.setSuccessor(ceo);

return sales;
}
}

（2）然后，对应不同的职位，创建对应的类，需要继承PriceHandler并实现priceDiscount(float discount)抽象方法：
Sales:

package tao.pattern.cor.handler;

/*
* 销售，可以批准5%以内的折扣
*/
public class Sales extends PriceHandler {

@Override
public void processDiscount(float discount) {
if(discount <= 0.05) {
System.out.format("%s批准了折扣：%.2f%n", this.getClass().getName(), discount);
}else {
successor.processDiscount(discount);
}
}
}

Manager:

package tao.pattern.cor.handler;

/*
* 销售经理，可以批准30%以内的折扣
*/
public class Manager extends PriceHandler {

@Override
public void processDiscount(float discount) {
if(discount <= 0.3) {
System.out.format("%s批准了折扣：%.2f%n", this.getClass().getName(), discount);
}else {
successor.processDiscount(discount);
}
}
}

Director:

package tao.pattern.cor.handler;

/*
* 销售总监，可以批准40%以内的折扣
*/
public class Director extends PriceHandler {

@Override
public void processDiscount(float discount) {
if(discount <= 0.4) {
System.out.format("%s批准了折扣：%.2f%n", this.getClass().getName(), discount);
}else {
successor.processDiscount(discount);
}
}
}

VicePresident:

package tao.pattern.cor.handler;

/*
* 销售副总裁，可以批准50%以内的折扣
*/
public class VicePresident extends PriceHandler {

@Override
public void processDiscount(float discount) {
if(discount <= 0.5) {
System.out.format("%s批准了折扣：%.2f%n", this.getClass().getName(), discount);
}else {
successor.processDiscount(discount);
}
}
}

CEO:

package tao.pattern.cor.handler;

/*
* CEO，可以批准55%以内的折扣
* 折扣超过55%，就拒绝申请
*/
public class CEO extends PriceHandler {

@Override
public void processDiscount(float discount) {
if(discount <= 0.55) {
System.out.format("%s批准了折扣：%.2f%n", this.getClass().getName(), discount);
}else {
System.out.format("%s拒绝了折扣：%.2f%n", this.getClass().getName(), discount);
}
}
}

（3）然后，创建一个客户类Customer，提出折扣申请：

package tao.pattern.cor;

import java.util.Random;
import tao.pattern.cor.handler.PriceHandler;

/*
* 客户，请求折扣
*/
public class Customer {

private PriceHandler priceHandler;

public void setPriceHandler(PriceHandler priceHandler) {
this.priceHandler = priceHandler;
}

/*
* 请求方法
*/
public void requestDiscount(float discount) {
priceHandler.processDiscount(discount);
}

public static void main(String[] args) {
Customer customer = new Customer();
customer.setPriceHandler(PriceHandler.createPriceHandler());

Random rand = new Random();
for(int i = 1; i <= 100; i++) {
System.out.print(i + ": ");
customer.requestDiscount(rand.nextFloat());
}
}
}

改进：
根据 单一职责 原则，创建责任链的工厂方法不应该放在PriceHandler中：
新建一个PriceHandlerFactory类，将静态方法createPriceHandler放在其中!

package tao.pattern.cor.handler;

public class PriceHandlerFactory {

/*
* 静态工厂方法（简单工厂方法）
* 建立责任链的工厂方法
*/
public static PriceHandler createPriceHandler() {

PriceHandler sales = new Sales();
PriceHandler manager = new Manager();
PriceHandler director = new Director();
PriceHandler vicePresident = new VicePresident();
PriceHandler ceo = new CEO();

//建立责任链
sales.setSuccessor(manager);
manager.setSuccessor(director);
director.setSuccessor(vicePresident);
vicePresident.setSuccessor(ceo);

return sales;
}
}

同时，在main方法中，通过customer.setPriceHandler(PriceHandlerFactory.createPriceHandler()); 调用！

纯责任链：只有一个对象处理请求。
不纯责任链：可以有多个对象处理同一个请求。

优点：方便解耦！
缺点：创建多个对象，却只是用一个，增加了内存开销！

责任链模式并不是一个常用的模式，需要根据具体业务进行取舍。。。！！！

应用： （1）AWT中的事件处理，后改用观察者模式！
                （2）JavaScript中的Event事件处理。
           （3）javaWeb中的Filter拦截操作。

进一步学习 ==> 观察者模式！