责任链模式应用
1. 责任链模式介绍
责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。
2. 应用场景
- 1). 有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。
- 2). 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
- 3). 可动态指定一组对象处理请求。
3. 实现(以创建订单为例子)
步骤一
创建一个接口:
package com.example.demo.designmodel.chain3;
import org.springframework.core.Ordered;
/**
* @author: robin
* @date: 2020/8/6 4:44 PM
* @aphorism: "stay hungry, stay foolish"
*/
public interface AbstractOrderHandler extends Ordered {
/**
*
* provide abstract method
*
* @param stage
* @param ride
* @return
*/
Boolean doHandler(int stage, GreenChannelOrder ride);
}
步骤二
创建责任链处理器添加后继处理器:
package com.example.demo.designmodel.chain3;
import com.google.common.collect.Maps;
import org.springframework.stereotype.Component;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
/**
* Chain of Responsibility Pattern
* Ensure link order
*/
@Component
public class OrderHandlerChain {
private List<AbstractOrderHandler> baseHandlers;
//private Map<String, AbstractOrderHandler> map2 = Maps.newHashMapWithExpectedSize(3);
public OrderHandlerChain(List<AbstractOrderHandler> baseHandlers) {
baseHandlers.sort(Comparator.comparing(AbstractOrderHandler::getOrder));
/* Map<String, AbstractOrderHandler> map = Maps.newHashMapWithExpectedSize(3);
for(AbstractOrderHandler handler:baseHandlers){
map.put(handler.handLerName(),handler);
}
*/
// this.map2=baseHandlers.stream().collect(Collectors.toMap(AbstractOrderHandler::handLerName, a -> a,(k1, k2)->k1));
this.baseHandlers = Collections.unmodifiableList(baseHandlers);
}
/* public AbstractOrderHandler getAbstractHandler(String handlerName){
return map2.get(handlerName);
}*/
public void handle(int stage, GreenChannelOrder ride) {
boolean handle = false;
for (AbstractOrderHandler baseHandler : baseHandlers) {
if (!handle) {
handle = baseHandler.doHandler(stage, ride);
}
}
}
}
步骤三
创建具体的职责处理类
1)预置订单处理器
package com.example.demo.designmodel.chain3;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* @author: robin
* @date: 2020/8/6 4:46 PM
* @aphorism: "stay hungry, stay foolish"
*/
@Slf4j
@Component
public class PreOrderHandler implements AbstractOrderHandler {
@Override
public Boolean doHandler(int stage, GreenChannelOrder ride) {
if (stage <= 1) { //预置订单处理职责
log.info("阶段1");
System.out.println("阶段1");
return false;
}
return false;//继续传递
}
@Override
public int getOrder() {
return 0;
}
}
2)开始订单处理器
package com.example.demo.designmodel.chain3;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* @author: robin
* @date: 2020/8/6 4:46 PM
* @aphorism: "stay hungry, stay foolish"
*/
@Slf4j
@Component
public class StartOrderHandler implements AbstractOrderHandler {
@Override
public Boolean doHandler(int stage, GreenChannelOrder ride) {
if (stage <= 2) {//开始订单处理职责
log.info("阶段2");
return true;
}
return false;
}
@Override
public int getOrder() {
return 1;
}
}
3)结束订单处理器
package com.example.demo.designmodel.chain3;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* @author: robin
* @date: 2020/8/6 4:46 PM
* @aphorism: "stay hungry, stay foolish"
*/
@Slf4j
@Component
public class FinishOrderHandler implements AbstractOrderHandler {
@Override
public Boolean doHandler(int stage, GreenChannelOrder ride) {
if (stage <= 3) {//结束订单处理职责
try {
log.info("阶段3");
} catch (Exception e) {
}
}
return true;
}
@Override
public int getOrder() {
return 2;
}
}
