责任链模式

在消费金融的授信流程中，要顺序调用多个外部风控系统，这里可以使用责任链模式来顺序依次调用多个节点。

1，先定义抽象节点

package com.sfpay.eciqs.core.flow.node;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.sfpay.eciqs.core.flow.node.domain.FlowParam;

public abstract class AbstractNode  extends AbstractUpdateNode{

    
   private Logger logger = LoggerFactory.getLogger(getClass());
    
   private boolean startNextNode=true;

   public void start(FlowParam flowParam)
   {
      startNextNode = this.excute(flowParam);
       
      if(this.getNextNode() ==null )
      {
          logger.info("下一节点为空！");
          return;
      }
      if(!startNextNode)
      {
          logger.info("excute() 返回false。流程结束！");
          return;
      }
      this.getNextNode().start(flowParam);
   }
  
   /**
     * 返回true是继续执行下一环节，
     * 返回false结束流程
     * @return
     */
   abstract public boolean excute(FlowParam flowParam);
   

   //动态设置下一个节点
   abstract public void setNextNode(AbstractNode nextNode);
   
   //动态设置下一个节点
   abstract public AbstractNode getNextNode();


}

2,第一个节点，nextNode中引用了下一个节点

/**
 * 开启员工贷授信流程*/
@Service("startCreditFlow")
public class StartCreditFlowNode  extends AbstractNode{

    @Resource(name = "accessOneNode") 
    public AbstractNode nextNode;
    @Override
    public boolean excute(FlowParam flowParam) 
    {
        System.out.println("开始流程节点");
        return true;
    }

    
    public void setNextNode(AbstractNode nextNode) {
        
    }

    @Override
    public AbstractNode getNextNode() {
        // TODO Auto-generated method stub
        return nextNode;
    }

}

3 ，第二个节点

/**
 * 基本准入
 */
@Service("accessOneNode")
@Scope("prototype")
public class AccessOneNode extends AbstractNode {

    @Resource(name = "baiqishiNode")
    public AbstractNode nextNode;


    @Override
    public boolean excute(FlowParam flowParam) {
        logger.info("开始执行基本准入节点");
        //业务逻辑
        
    }


    @Override
    public void setNextNode(AbstractNode nextNode) {
        this.nextNode = nextNode;
    }

    @Override
    public AbstractNode getNextNode() {
        return nextNode;
    }

}

依次执行第三、四个节点，直到下一个节点为空为止。

入口 

@Autowired
    public AbstractNode startCreditFlow;

/**
     * 异步处理实时授信过程
     * @param flowParam
     */
    private void process(final FlowParam flowParam) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    logger.info("startCreditFlow.start() start，applyNo=[{}],product=[{}]", flowParam.getApplyNo(), flowParam.getProduct());
                    //启动流程，各个节点处理
                    startCreditFlow.start(flowParam);
                 } catch (Exception e) {
                    logger.error(e.getMessage(), e);
                }
            }
        });
        executorService.shutdown();
    }