Timer定时器轮询拉取订单

自己根据工作中遇到的情况进行总结的，对其他人应该无用

package com.wanshun.drivingservice.task;

import com.wanshun.common.code.anwser.AnwserCode;
import com.wanshun.common.database.redis.RedisCache;
import com.wanshun.common.utils.JsonUtil;
import com.wanshun.common.utils.StringUtil;
import com.wanshun.im.client.clientao.ClientMessagePacketAo;
import com.wanshun.drivingservice.ao.VnInfoAo;
import com.wanshun.drivingservice.async.OrderPersistence;
import com.wanshun.drivingservice.constants.MqttUrlConstants;
import com.wanshun.drivingservice.constants.OrderStatus;
import com.wanshun.drivingservice.rpcao.driver.RpcDrivingDriverInfoAo;
import com.wanshun.drivingservice.rpcao.order.RpcCostEstimateAo;
import com.wanshun.drivingservice.rpcao.order.RpcDriverPositionAo;
import com.wanshun.drivingservice.rpcao.order.RpcOrderTraceAo;
import com.wanshun.drivingservice.rpcao.order.RpcPollingOrderInfoAo;
import com.wanshun.drivingservice.rpcvo.driver.RpcDrivingDriverInfoVo;
import com.wanshun.drivingservice.rpcvo.order.*;
import com.wanshun.drivingservice.rpcvo.user.RpcCarOwnerInfoVo;
import com.wanshun.drivingservice.service.DrivingDriverService;
import com.wanshun.drivingservice.service.OrderService;
import com.wanshun.drivingservice.spingboot.SpringBeanLoader;
import com.wanshun.drivingservice.springboot.TimeConfig;
import com.wanshun.drivingservice.utils.DrivingDateUtil;
import com.wanshun.drivingservice.vo.PollingFailedData;
import com.wanshun.drivingservice.wrap.*;
import com.wanshun.im.client.clientapi.IMPushMessageService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
 * 车主下单后, 轮询拉取订单信息
 * E代驾接口地址
 * http://open.d.api.edaijia.cn/doc/
 */
public class PollingOrderTimerTask {
    private static Logger logger = LoggerFactory.getLogger(PollingOrderTimerTask.class);

    private OrderService orderService;
    private RedisCache redisCache;
    private OrderPersistence orderPersistence;
    //private VirtualNumInfoService virtualNumInfoService;
    private IMPushMessageService imPushMessageService;
    private RpcPollingOrderInfoAo pollingOrderInfoAo;
    private RpcCarOwnerInfoVo carOwnerInfo;
    private Timer taskTimer;
    private long period;
    private int mapType;
    private DrivingDriverService drivingDriverService;
    private String dutyCancelTime;
    private boolean isPushData;
    private RpcPollingOrderInfoDataVo pollingOrderInfo;

    public PollingOrderTimerTask(RpcPollingOrderInfoAo pollingOrderInfoAo, int mapType, long period) {
        this.pollingOrderInfoAo = pollingOrderInfoAo;
        this.orderService = SpringBeanLoader.getSpringBean(OrderService.class);
        this.redisCache = SpringBeanLoader.getSpringBean(RedisCache.class);
        this.orderPersistence = SpringBeanLoader.getSpringBean(OrderPersistence.class);
        this.drivingDriverService = SpringBeanLoader.getSpringBean(DrivingDriverService.class);
        //this.virtualNumInfoService = SpringBeanLoader.getSpringBean(VirtualNumInfoService.class);
        this.imPushMessageService = SpringBeanLoader.getSpringBean(IMPushMessageService.class);
        this.period = period;
        this.mapType = mapType;
        this.pollingOrderInfo = new RpcPollingOrderInfoDataVo();

    }

    public void start() {
        this.taskTimer = new Timer();
        this.taskTimer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                String bookingId = redisCache.get(pollingOrderInfoAo.getBookingId());
                logger.info("PollingOrderTimerTask>>>>预约订单号==============" + bookingId);
                if(StringUtil.isEmpty(pollingOrderInfoAo.getBookingId())) {
                    logger.info("bookingId: {} PollingOrderTimerTask", pollingOrderInfoAo.getBookingId());
                    stop();
                    return;
                }

                try {
                    pollingOrderInfo = orderService.getPollingOrderInfo(pollingOrderInfoAo);
                    logger.info("车主下单后, 定时拉取订单信息: {}", pollingOrderInfo);

                    if(pollingOrderInfo != null && "0".equals(pollingOrderInfo.getCode())) {

                        //获取e代驾拉取订单接口数据并启动当前订单接口定时拉取
                        getPollingOrderInfo(pollingOrderInfo);

                    }else if (pollingOrderInfo == null){//如果e代驾拉去订单接口返回为空则重新请求

                        pollingOrderInfo = orderService.getPollingOrderInfo(pollingOrderInfoAo);
                        logger.info("车主下单后, 定时拉取订单信息: {}", pollingOrderInfo);

                        if(pollingOrderInfo != null && "0".equals(pollingOrderInfo.getCode())) {

                            //获取e代驾拉取订单接口数据并启动当前订单接口定时拉取
                            getPollingOrderInfo(pollingOrderInfo);
                        }
                    }
                }catch (Exception e){
                    logger.info("获取e代驾拉取订单接口信息失败");
                    e.printStackTrace();
                }

            }
        }, 0, this.period);
    }

    /**
     * 获取e代驾拉取订单接口数据并启动当前订单接口定时拉取
     * @param pollingOrderInfo
     */
    private void getPollingOrderInfo(RpcPollingOrderInfoDataVo pollingOrderInfo){
        /**
         * pollingState的取值
         * 0 继续请求
         * 1 派单失败
         * 2 司机已接单
         */
        final String pollingState = pollingOrderInfo.getData().getPollingState();

        if("1".equals(pollingState)) {//派单失败
            logger.info("------ 派单失败 -------");
            RpcDrivingOrderDetailVo drivingOrderDetailVo = orderService.getCurrentOrder(pollingOrderInfoAo.getBookingId());
            if(drivingOrderDetailVo == null){
                stop();
            }else {
                //更新数据库状态
                orderPersistence.updateDrivingOrderStatus(pollingOrderInfoAo.getBookingId(),drivingOrderDetailVo.getOrderId());

                PollingFailedData pollingFailedData = new PollingFailedData();
                pollingFailedData.setBookingId(pollingOrderInfoAo.getBookingId());
                pollingFailedData.setOrderStatus(190);

                ClientMessagePacketAo imPacket = new ClientMessagePacketAo();
                imPacket.setTtl(10 * 60);
                imPacket.setId(Long.parseLong(pollingOrderInfoAo.getUserId()));
                imPacket.setData(pollingFailedData);
                imPacket.setAnwserCode(new AnwserCode(190, "派单失败"));

                logger.info("派单失败: {}", JsonUtil.toJson(imPacket));

//                rpcPassengerGateWayService.publishBusinessMsg(MqttUrlConstants.POLLING_ORDER, packet);
                imPacket.setUrl(MqttUrlConstants.POLLING_ORDER);
                imPushMessageService.publishBusinessMsg(imPacket);
                stop();
            }

        } else if("2".equals(pollingState)) {//司机已接单
            logger.info("------ 司机已接单 -------");

            stop();

            dutyCancelTime = DrivingDateUtil.getCurrentTimeAfterMinutes(3);

            if(!isPushData){

                RpcDriverPositionAo driverPositionAo = new RpcDriverPositionAo();
                driverPositionAo.setBookingId(pollingOrderInfoAo.getBookingId());
                driverPositionAo.setDriverId(pollingOrderInfo.getData().getDriverId());
                driverPositionAo.setOrderId(pollingOrderInfo.getData().getOrderId());
                driverPositionAo.setUserId(pollingOrderInfoAo.getUserId());

                RpcOrderTraceAo orderTraceAo = new RpcOrderTraceAo();
                orderTraceAo.setOrderId(pollingOrderInfo.getData().getOrderId());
                orderTraceAo.setStart(System.currentTimeMillis() / 1000);
                orderTraceAo.setBookingId(pollingOrderInfoAo.getBookingId());
                orderTraceAo.setDriverId(pollingOrderInfo.getData().getDriverId());
                orderTraceAo.setUserId(pollingOrderInfoAo.getUserId());

                /**
                 * dutyCancelTime
                 */
                redisCache.set(pollingOrderInfoAo.getUserId() + "_dutyCancelTime", dutyCancelTime, 24 * 60 * 60);

                /**
                 * 获取起始地点的经纬度和目的地的经纬度
                 * 调用预估费接口获取预估费
                 */
                RpcGetUpAndDestVo orderStartDestLatLon = orderPersistence.getOrderStartDestLatLon(pollingOrderInfoAo.getBookingId());

                RpcCostEstimateAo costEstimateAo = new RpcCostEstimateAo();
                costEstimateAo.setMapType(mapType);
                costEstimateAo.setUserId(pollingOrderInfoAo.getUserId());
                costEstimateAo.setStartLng(orderStartDestLatLon.getStartLon());
                costEstimateAo.setStartLat(orderStartDestLatLon.getStartLat());
                costEstimateAo.setEndLng(orderStartDestLatLon.getDestLon());
                costEstimateAo.setEndLat(orderStartDestLatLon.getDestLat());

                //获取预估费
                RpcCostEstimateDataVo costEstimate = orderService.getCostEstimate(costEstimateAo);
                EstimateFeeWrap estimateFeeWrap = new EstimateFeeWrap();

                if(costEstimate != null && costEstimate.getCode() == 0) {
                    estimateFeeWrap.setFee(String.valueOf(costEstimate.getData().getFee()));
                    estimateFeeWrap.setFeeDetail(costEstimate.getData().getFeeDetail());
                }

                //获取司机信息
                RpcDriverPositionDataVo driverPositionDataVo = orderService.getDriverPosition(driverPositionAo);
                RpcDriverPositionVo driver = driverPositionDataVo.getData().getDriver();
                logger.info("PollingOrderTimerTask,e代驾当前订单司机位置接口中的司机信息，driver" + JsonUtil.toJson(driver));

                //如果后台kafka消息队列中在数据库中存储了订单状态数据则在task中不再存储
                if(StringUtil.isEmpty(redisCache.get(pollingOrderInfoAo.getBookingId() + 301))){
                    /**
                     * 更新订单状态和订单ID
                     */
                    orderPersistence.updateOrderOrderStatusAndOrderId(pollingOrderInfo.getData().getOrderId(),pollingOrderInfoAo.getBookingId(),pollingOrderInfo.getData().getDriverId(),OrderStatus.ORDER_STATUS_RECEIVED,JsonUtil.toJson(estimateFeeWrap),driverPositionDataVo.getData().getDriver().getPhone());
                }

                //查询司机信息
                RpcDrivingDriverInfoVo rpcDrivingDriverInfoVo = drivingDriverService.getDriverInfo(driver.getDriverId());
                logger.info("PollingOrderTimerTask,查询司机信息，rpcDrivingDriverInfoVo :" + JsonUtil.toJson(rpcDrivingDriverInfoVo));
                if(rpcDrivingDriverInfoVo == null){
                    //将司机信息存入数据库
                    RpcDrivingDriverInfoAo rpcDrivingDriverInfoAo = new RpcDrivingDriverInfoAo();
                    rpcDrivingDriverInfoAo.setName(driver.getName());
                    rpcDrivingDriverInfoAo.setPhone(driver.getPhone());
                    rpcDrivingDriverInfoAo.setNewLevel(driver.getNewLevel());
                    rpcDrivingDriverInfoAo.setDrivingAge(Integer.parseInt(driver.getYear()));
                    rpcDrivingDriverInfoAo.setDriverNo(driver.getDriverId());
                    rpcDrivingDriverInfoAo.setDriverUrl(driver.getPictureSmall());

                    rpcDrivingDriverInfoAo.setGoback(0);
                    rpcDrivingDriverInfoAo.setServiceTimes(0);
                    rpcDrivingDriverInfoAo.setState(0);
                    rpcDrivingDriverInfoAo.setLowOpinionTimes(0);
                    rpcDrivingDriverInfoAo.setHighOpinionTimes(0);
                    rpcDrivingDriverInfoAo.setRecommand(0);
                    rpcDrivingDriverInfoAo.setRole(0);
                    rpcDrivingDriverInfoAo.setIsRemote(0);
                    rpcDrivingDriverInfoAo.setReadyInTime(0);
                    rpcDrivingDriverInfoAo.setUpdatetime(new Date());
                    rpcDrivingDriverInfoAo.setCreateTime(new Date());

                    drivingDriverService.addDriverInfo(rpcDrivingDriverInfoAo);
                }

                //如果e代驾司机的当前订单接口星级和手机号与数据库不同则更改
                if(rpcDrivingDriverInfoVo != null && driver != null){
                    if((!rpcDrivingDriverInfoVo.getNewLevel().equals(driver.getNewLevel())) || (!rpcDrivingDriverInfoVo.getPhone().equals(driver.getPhone()))){
                        RpcDrivingDriverInfoAo rpcDrivingDriverInfoAo = new RpcDrivingDriverInfoAo();
                        rpcDrivingDriverInfoAo.setNewLevel(driver.getNewLevel());
                        rpcDrivingDriverInfoAo.setPhone(driver.getPhone());
                        rpcDrivingDriverInfoAo.setDriverNo(driver.getDriverId());

                        logger.info("如果e代驾司机的当前订单接口星级和手机号与数据库不同则更改,数据更改的入参，rpcDrivingDriverInfoAo==" + JsonUtil.toJson(rpcDrivingDriverInfoAo));
                        drivingDriverService.updateDriverDetail(rpcDrivingDriverInfoAo);
                    }
                }

                try {
                    /**
                     * 绑定司机虚拟号
                     */
                    VnInfoAo vnInfoAo = new VnInfoAo();
                    vnInfoAo.setUserId(Long.parseLong(pollingOrderInfoAo.getUserId()));
                    vnInfoAo.setOrderId(carOwnerInfo.getDrivingOrderId());
                    vnInfoAo.setDriverPhone(driverPositionDataVo.getData().getDriver().getPhone());

                    //virtualNumInfoService.updateNoDriver(vnInfoAo);
                }catch (Exception e){
                    logger.error("绑定车主用户虚拟号失败，则用用户自身手机号");
                }

                /**
                 * bookingId存入缓存
                 */
                redisCache.set(pollingOrderInfoAo.getBookingId(),pollingOrderInfoAo.getBookingId(),24 * 60 * 60);

                /**
                 * 司机接单, 轮询获取实施费用和轨迹
                 */
                new OrderDriverTimerTask(orderTraceAo, driverPositionAo, mapType, TimeConfig.ACTUAL_ORDER_DRIVER_TIME_DISTANCE).start();

                isPushData = true;
            }
        }
    }

    public void stop() {
        this.redisCache.deleteKey(this.pollingOrderInfoAo.getBookingId());

        if(this.taskTimer != null) {
            this.taskTimer.cancel();
            this.taskTimer = null;
        }
    }

}