使用策略模式完成不同状态的流转

1 前端分发器

boolean limitMakeAppoint = limitScheduleDispatch.handleDispatchProcessor(LimitAppointConverter.getLimitParam(order), LimitScheduleAction.MAKE_APPOINT.getAction());

2 策略分发器

import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;


@Slf4j
@Component
public class LimitScheduleDispatch {

    @Resource
    private BaseLimitScheduleFactory baseLimitScheduleFactory;

    /**
     * 策略分发器
     *
     * @param limitAppointParam
     * @param action
     */
    public boolean handleDispatchProcessor(LimitAppointDTO limitAppointParam, String action) {
        log.info("LimitScheduleDispatch-handleDispatchProcessor limitAppointParam:{},action:{}", JSONUtil.toJsonStr(limitAppointParam), action);
        try {
            List<LimitScheduleProcessor> scheduleProcessors = baseLimitScheduleFactory.getScheduleProcessor(action);
            if (CollectionUtils.isEmpty(scheduleProcessors)) {
                log.warn("LimitScheduleDispatch-handleDispatchProcessor scheduleProcessor isEmpty");
                return true;
            }
            for (LimitScheduleProcessor scheduleProcessor : scheduleProcessors) {
                return scheduleProcessor.handleLimitScheduleAndRecordOrder(limitAppointParam);
            }
        } catch (Exception e) {
            log.error("LimitScheduleDispatch-handleDispatchProcessor error : " , e);
        }
        return true;
    }

}

3 分发节点

public enum LimitScheduleAction {

    MAKE_APPOINT("makeAppoint","预约" , MakeAppointLimitScheduleProcessor.class),

    RESCHEDULE_APPOINT("rescheduleAppoint","改期", RescheduleAppointLimitScheduleProcessor.class),

    CANCEL_APPOINT("cancelAppoint","取消", CancelAppointLimitScheduleProcessor.class);

    private String action;

    private String desc;

    private Class <? extends LimitScheduleProcessor> clazz;

    LimitScheduleAction(String action, String desc, Class<? extends LimitScheduleProcessor> clazz) {
        this.action = action;
        this.desc = desc;
        this.clazz = clazz;
    }

    public String getAction() {
        return action;
    }

    public void setAction(String action) {
        this.action = action;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public Class<? extends LimitScheduleProcessor> getClazz() {
        return clazz;
    }

    public void setClazz(Class<? extends LimitScheduleProcessor> clazz) {
        this.clazz = clazz;
    }
}

4 制造工厂

import cn.hutool.core.date.DateUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.compress.utils.Lists;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.*;


@Slf4j
@Component
public class BaseLimitScheduleFactory{

    @Resource
    private ReservationLimitService reservationLimitService;


    /**
     * 注入Bean
     */
    @Resource
    private List<LimitScheduleProcessor> limitScheduleProcessors;


    /**
     * 获取全部处理器
     *
     * @param action
     * @return
     */
    protected List<LimitScheduleProcessor> getScheduleProcessor(String action) {
        List<LimitScheduleProcessor> targetProcessor = Lists.newArrayList();
        for (LimitScheduleProcessor processor : limitScheduleProcessors) {
            if (Objects.equals(action, processor.getLimitScheduleAction().getAction())) {
                targetProcessor.add(processor);
            }
        }
        return targetProcessor;
    }


    /**
     *
     * @param limitAppointParam
     */
    public boolean releaseLimitSchedule(LimitAppointDTO limitAppointParam) {
        try {
            AddReservationLimitReq addReservationLimitReq = new AddReservationLimitReq();
            addReservationLimitReq.setOrderId(limitAppointParam.getOrderId());
            addReservationLimitReq.setPartnerId(Long.valueOf(limitAppointParam.getPartnerId()));
            addReservationLimitReq.setIsProxy(limitAppointParam.getAppointType());
            addReservationLimitReq.setCardNo(limitAppointParam.getCardNo());
            addReservationLimitReq.setAppointDate(DateUtil.format(limitAppointParam.getNewAppointDate(),"yyyy-MM-dd"));
            addReservationLimitReq.setPackageCode(limitAppointParam.getPackageCode());
            addReservationLimitReq.setTimeSupportMode(com.pajk.widget.date.DateUtil.isMorning(limitAppointParam.getNewAppointDate()) ? 1 : 2);
            return reservationLimitService.addReservationLimit(addReservationLimitReq);
        } catch (Exception e) {
            log.error("BaseLimitScheduleFactory-releaseLimitSchedule error : ", e);
            return true;
        }
    }

    /**
     *
     * @param limitAppointParam
     */
    public boolean deductionsLimitSchedule(LimitAppointDTO limitAppointParam) {
        try {
            ReduceReservationLimitReq reduceReservationLimitReq = new ReduceReservationLimitReq();
            reduceReservationLimitReq.setOrderId(limitAppointParam.getOrderId());
            reduceReservationLimitReq.setPartnerId(Long.valueOf(limitAppointParam.getPartnerId()));
            reduceReservationLimitReq.setIsProxy(limitAppointParam.getAppointType());
            reduceReservationLimitReq.setCardNo(limitAppointParam.getCardNo());
            reduceReservationLimitReq.setAppointDate(DateUtil.format(limitAppointParam.getNewAppointDate(),"yyyy-MM-dd"));
            reduceReservationLimitReq.setPackageCode(limitAppointParam.getPackageCode());
            reduceReservationLimitReq.setTimeSupportMode(com.pajk.widget.date.DateUtil.isMorning(limitAppointParam.getNewAppointDate()) ? 1 : 2);
            return reservationLimitService.reduceReservationLimit(reduceReservationLimitReq);
        } catch (Exception e) {
            log.error("BaseLimitScheduleFactory-deductionsLimitSchedule error : ", e);
            return true;
        }
    }

    /**
     *
     * @param limitAppointParam
     */
    public void recordOrderLimitSchedule(LimitAppointDTO limitAppointParam) {

    }
}

5 接口处理器

import java.util.*;


public interface LimitScheduleProcessor {

    LimitScheduleAction getLimitScheduleAction();

    List<LimitSchedule> getLimitSchedule(Long partnerId);

    boolean handleLimitScheduleAndRecordOrder(LimitAppointDTO limitAppointParam);

}

6 实现子类

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.List;


@Slf4j
@Component
public class MakeAppointLimitScheduleProcessor extends BaseLimitScheduleFactory implements LimitScheduleProcessor{

    @Override
    public LimitScheduleAction getLimitScheduleAction() {
        return LimitScheduleAction.MAKE_APPOINT;
    }

    @Override
    public List<LimitSchedule> getLimitSchedule(Long partnerId) {
        return null;
    }

    @Override
    public boolean handleLimitScheduleAndRecordOrder(LimitAppointDTO limitAppointParam) {
        return this.deductionsLimitSchedule(limitAppointParam);
    }

}