近期我有个需求,需要实现类似流程功能。我们开发人员本身条件限制,他使用原始的数据库中间状态来实现,但是代码堆的非常多、上下文逻辑很混乱、BUG 多,没有达到预期设定的要求。
事后,我想了下,如果换做是我,我该怎么做?
分析此类业务的特点,流程,我想到了 责任链 。
责任链模式(Chain of Responsibility
)是设计模式的一种,属于 行为型设计模式
。
为请求创建了一个链,请求在链上被处理。通常某个处理器如果不能处理该请求,那么它会把相同的请求传给链上的下一个处理器。
如果一个请求需要经过多个处理步骤,将多个处理的步骤抽象成一条 执行链
,那么便可以使用责任链模式。
责任链的使用场景一般有:
在现实中,我们很多场景都使用到了责任链模式。
RBAC
模型 :多条件流程判断ERP
系统流程审批:总经理、销售总监、产品部经理、项目组长Java MVC
过滤器的底层实现 Filter
handler
定义处理请求的接口, handler
知道下一个处理者是谁,如果自己无法处理请求,就转给下一个处理者。
具体的处理者是处理请求的具体角色
请求者角色,就是向第一个具体的 handler
发送请求的角色,并连接好责任链。
public abstract class AbstractHandler {
/**
* 定义下一用当前抽象类来接收
*/
protected AbstractHandler next;
public void setNext(AbstractHandler next) {
this.next = next;
}
public abstract int handler();
}
@Slf4j
public class FirstPassHandler extends AbstractHandler{
static final int FIRST_SCOPE = 70;
@Override
public int handler() {
log.error("第一环节处理");
int score = first();
if(score>=FIRST_SCOPE){
log.error("处理完毕,交由下一环节处理");
if(this.next != null){
return this.next.handler();
}
}else{
log.error("处理不了,交由下一环节处理");
}
return score;
}
private int first(){
return FIRST_SCOPE;
}
}
@Slf4j
public class SecondPassHandler extends AbstractHandler{
static final int SECOND_SCOPE = 80;
@Override
public int handler() {
log.error("第二环节处理");
int score = second();
if(score>=SECOND_SCOPE){
log.error("处理完毕,交由下一环节处理");
if(this.next != null){
return this.next.handler();
}
}else{
log.error("处理不了,交由下一环节处理");
}
return score;
}
private int second(){
return SECOND_SCOPE;
}
}
@Slf4j
public class ThirdPassHandler extends AbstractHandler{
static final int THIRD_SCOPE = 90;
@Override
public int handler() {
log.error("第三环节处理");
int score = third();
if(score>=THIRD_SCOPE){
log.error("处理完毕,交由下一环节处理");
if(this.next != null){
return this.next.handler();
}
}else{
log.error("处理不了,交由下一环节处理");
}
return score;
}
private int third(){
return THIRD_SCOPE;
}
}
@DisplayName("责任链模式")
@Test
public void testChain() {
FirstPassHandler firstPassHandler = new FirstPassHandler();
SecondPassHandler secondPassHandler = new SecondPassHandler();
ThirdPassHandler thirdPassHandler = new ThirdPassHandler();
firstPassHandler.setNext(secondPassHandler);
secondPassHandler.setNext(thirdPassHandler);
firstPassHandler.handler();
}
这种方式,有点不好,每次都需要 客户端 自己维护这样的关系,不是非常合理,而且很多时候人家客户端不想知道这个过程。
在上述样例中,我们可以将关系维护到配置文件中或者一个枚举中。此处用枚举作为实现方式来演示如何动态的配置请求链并且将每个请求者形成一条调用链。
@Data
@AllArgsConstructor
public class FilterEntity {
/**
* handlerId
*/
private Integer handlerId;
/**
* 处理器名称
*/
private String name;
/**
* 处理器 包名 + 类名
*/
private String conference;
/**
* 上一个处理器
*/
private Integer preHandlerId;
/**
* 下一个处理器
*/
private Integer nextHandlerId;
}
public enum FilterEnum {
FIRST_HANDLER(new FilterEntity(1, "首要处理环节", FirstFilterHandler.class.getName(), null, 2)),
SECOND_HANDLER(new FilterEntity(2, "二次处理环节", SecondFilterHandler.class.getName(), 1, 3)),
THIRD_HANDLER(new FilterEntity(3, "三次处理环节", ThirdFilterHandler.class.getName(), 2, null));
FilterEntity filterEntity;
public FilterEntity getGameEntity() {
return filterEntity;
}
FilterEnum(FilterEntity filterEntity) {
this.filterEntity = filterEntity;
}
}
这里将处理环节利用枚举,将前后依赖顺序进行定义。
public interface FilterDao {
/**
* 根据 handlerId 获取配置项
* @param handlerId
* @return
*/
FilterEntity getGameEntity(Integer handlerId);
/**
* 获取第一个处理者
* @return
*/
FilterEntity getFirstGameEntity();
}
public class FilterImpl implements FilterDao {
/**
* 初始化,将枚举中配置的handler初始化到map中,方便获取
*/
private static Map<Integer, FilterEntity> gatewayEntityMap = new HashMap<>();
static {
FilterEnum[] values = FilterEnum.values();
for (FilterEnum value : values) {
FilterEntity gatewayEntity = value.getGameEntity();
gatewayEntityMap.put(gatewayEntity.getHandlerId(), gatewayEntity);
}
}
@Override
public FilterEntity getGameEntity(Integer handlerId) {
return gatewayEntityMap.get(handlerId);
}
@Override
public FilterEntity getFirstGameEntity() {
for (Map.Entry<Integer, FilterEntity> entry : gatewayEntityMap.entrySet()) {
FilterEntity value = entry.getValue();
// 没有上一个handler的就是第一个
if (value.getPreHandlerId() == null) {
return value;
}
}
return null;
}
}
public abstract class AbstractFilterHandler {
/**
* 定义下一用当前抽象类来接收
*/
protected AbstractFilterHandler next;
public void setNext(AbstractFilterHandler next) {
this.next = next;
}
public abstract int handler();
}
@Slf4j
public class FirstFilterHandler extends AbstractFilterHandler {
static final int FIRST_SCOPE = 70;
@Override
public int handler() {
log.error("第一环节处理");
int score = first();
if(score>=FIRST_SCOPE){
log.error("处理完毕,交由下一环节处理");
if(this.next != null){
return this.next.handler();
}
}else{
log.error("处理不了,交由下一环节处理");
}
return score;
}
private int first(){
return FIRST_SCOPE;
}
}
@Slf4j
public class SecondFilterHandler extends AbstractFilterHandler {
static final int SECOND_SCOPE = 80;
@Override
public int handler() {
log.error("第二环节处理");
int score = second();
if(score>=SECOND_SCOPE){
log.error("处理完毕,交由下一环节处理");
if(this.next != null){
return this.next.handler();
}
}else{
log.error("处理不了,交由下一环节处理");
}
return score;
}
private int second(){
return SECOND_SCOPE;
}
}
@Slf4j
public class ThirdFilterHandler extends AbstractFilterHandler {
static final int THIRD_SCOPE = 90;
@Override
public int handler() {
log.error("第三环节处理");
int score = third();
if(score>=THIRD_SCOPE){
log.error("处理完毕,交由下一环节处理");
}else{
log.error("处理不了,交由下一环节处理");
if(this.next != null){
return this.next.handler();
}
}
return score;
}
private int third(){
return THIRD_SCOPE;
}
}
@Slf4j
public class FilterHandlerEnumFactory {
private static FilterDao filterDao = new FilterImpl();
/**
* 提供静态方法,获取第一个handler
*
* @return AbstractFilterHandler
* @author Sam
* @date 2022/8/4-23:50
**/
public static AbstractFilterHandler getFirstHandler() {
FilterEntity firstGatewayEntity = filterDao.getFirstGameEntity();
AbstractFilterHandler firstAbstractFilterHandler = newGatewayHandler(firstGatewayEntity);
if (firstAbstractFilterHandler == null) {
return null;
}
FilterEntity tempFilterEntity = firstGatewayEntity;
Integer nextHandlerId = null;
AbstractFilterHandler tempHandler = firstAbstractFilterHandler;
// 迭代遍历所有handler,以及将它们链接起来
while ((nextHandlerId = tempFilterEntity.getNextHandlerId()) != null) {
FilterEntity filterEntity = filterDao.getGameEntity(nextHandlerId);
AbstractFilterHandler abstractFilterHandler = newGatewayHandler(filterEntity);
tempHandler.setNext(abstractFilterHandler);
tempHandler = abstractFilterHandler;
tempFilterEntity = filterEntity;
log.warn("Init GatewayHandler", tempFilterEntity.getHandlerId());
}
// 返回第一个handler
return firstAbstractFilterHandler;
}
/**
* 反射实体化具体的处理者
*
* @param filterEntity
* @return AbstractFilterHandler
*/
private static AbstractFilterHandler newGatewayHandler(FilterEntity filterEntity) {
try {
String clazzName = filterEntity.getConference();
log.error(clazzName);
Class<?> clazz = Class.forName(clazzName);
return (AbstractFilterHandler) clazz.newInstance();
} catch (IllegalAccessException | InstantiationException | ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
}
@DisplayName("责任链模式-工厂")
@Test
public void testChainFactory() {
AbstractFilterHandler handler = FilterHandlerEnumFactory.getFirstHandler();
handler.handler();
}
通过枚举以及抽象工厂,我们将每个处理器连接起来,让客户端只关系自己的诉求部分,具体实现逻辑交由枚举来定义。这样做简化客户端的业务。相对来说比较友好,而且容易拓展。