微服务间的桥梁 Feign

pom 文件如下

    
        sdgt_parent
        com.baiyee
        0.0.1-SNAPSHOT
    
    4.0.0

    service_client
    com.baiyee
    pom
    
        service_cmn_client
    

    
        
            com.baiyee
            common_util
            0.0.1-SNAPSHOT
            provided
        

        
            com.baiyee
            model
            0.0.1-SNAPSHOT
            provided
        

        
            org.springframework.boot
            spring-boot-starter-web
            provided
        

        
        
            org.springframework.cloud
            spring-cloud-starter-openfeign
            provided
        
    

    
        service_client
        com.baiyee
        0.0.1-SNAPSHOT
    
    4.0.0

    service_cmn_client
    jar

@FeignClient(value = "service-cmn")
@Repository
public interface DictFeignClient {
    // 根据 dictcode 和 value 查询
    @GetMapping("/admin/cmn/dict/getName/{dictCode}/{value}")
    String getName(@PathVariable("dictCode") String dictCode, @PathVariable("value") String value);

    // 根据 value 查询
    @GetMapping("/admin/cmn/dict/getName/{value}")
    String getName(@PathVariable("value") String value);

    // 获取 dictCode 对应的节点
    @GetMapping("/admin/cmn/dict/getByDictCode/{dictCode}")
    int getByDictCode(@PathVariable("dictCode") String dictCode);
}

    org.springframework.cloud
    spring-cloud-starter-openfeign

    com.baiyee
    service_cmn_client
    0.0.1-SNAPSHOT
    compile

@SpringBootApplication
@ComponentScan(basePackages = "com.baiyee")
@EnableDiscoveryClient
@EnableFeignClients(basePackages = "com.baiyee")
public class    ServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceApplication.class, args);
    }
}

package com.baiyee.sdgt.obj.service.impl;

import com.baiyee.sdgt.cmn.client.DictFeignClient;
import com.baiyee.sdgt.common.utils.ChineseCalendarUtils;
import com.baiyee.sdgt.model.obj.*;
import com.baiyee.sdgt.obj.mapper.CompanyVisitMapper;
import com.baiyee.sdgt.obj.mapper.HospitalVisitMapper;
import com.baiyee.sdgt.obj.mapper.PharmacyVisitMapper;
import com.baiyee.sdgt.obj.mapper.TaskMapper;
import com.baiyee.sdgt.obj.repository.VisitRepository;
import com.baiyee.sdgt.obj.service.*;
import com.baiyee.sdgt.vo.obj.TaskDistributionVo;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;


@Service
public class TaskServiceImpl extends ServiceImpl implements TaskService {
    @Autowired
    private HospitalService hospitalService;
    @Autowired
    private CompanyService companyService;
    @Autowired
    private PharmacyService pharmacyService;
    @Autowired
    private HospitalVisitService hospitalVisitService;
    @Autowired
    private CompanyVisitService companyVisitService;
    @Autowired
    private PharmacyVisitService pharmacyVisitService;
    @Autowired
    private HospitalVisitMapper hospitalVisitMapper;
    @Autowired
    private CompanyVisitMapper companyVisitMapper;
    @Autowired
    private PharmacyVisitMapper pharmacyVisitMapper;
    @Autowired
    private VisitRepository visitRepository;
    @Autowired
    private DictFeignClient dictFeignClient;

    
    @Override
    public void distributeTask(TaskDistributionVo taskDistributionVo) {
        List taskList = new ArrayList<>();
        // 清空任务
        this.getbaseMapper().clearTask();
        hospitalVisitMapper.clear();
        companyVisitMapper.clear();
        pharmacyVisitMapper.clear();
        visitRepository.deleteAll();
        // 初始化任务
        initTask(taskDistributionVo, taskList);
        this.saveBatch(taskList);


        // 拜访平均时间，默认为 30 分钟
        int visitTime = dictFeignClient.getByDictCode("11");
        // 同区域移动平均时间，默认为 20 分钟
        int shortMoveTime = dictFeignClient.getByDictCode("12");
        // 不同区域移动平均时间，默认为 45 分钟
        int longMoveTime = dictFeignClient.getByDictCode("13");
        // 拜访时间幅度，默认为 10 分钟
        int visitTimeRange = dictFeignClient.getByDictCode("111");
        // 同区域移动时间幅度，默认为 5 分钟
        int shortMoveTimeRange = dictFeignClient.getByDictCode("121");
        // 不同区域移动时间幅度，默认为 10 分钟
        int longMoveTimeRange = dictFeignClient.getByDictCode("131");

        // 获得年份
        String year = taskDistributionVo.getDate().substring(0, 4);
        // 获得月份
        String month = taskDistributionVo.getDate().substring(5, 7);

        Calendar currentDate = Calendar.getInstance();
        // 设置开始扫描时间
        currentDate.set(Integer.parseInt(year), Integer.parseInt(month) - 1, 1);
        // 任务月份
        int taskMonth = currentDate.get(Calendar.MONTH);
        // 循环一天
        while (true) {
            // 日期字符串表示
            String calendar = currentDate.get(Calendar.YEAR) + "-" + (currentDate.get(Calendar.MONTH) + 1) + "-" + currentDate.get(Calendar.DATE);
            ChineseCalendarUtils cc = new ChineseCalendarUtils();
            // 如果是工作日，就可以安排任务
            if (cc.isWorkday(calendar)) {
                // 按照省、市、区排序
                QueryWrapper queryWrapper = new QueryWrapper<>();
                queryWrapper.orderByDesc("PROVINCE", "CITY", "DISTRICT", "COUNT");
                List tasks = this.getbaseMapper().selectList(queryWrapper);
                List segments = new ArrayList<>();
                // 初始化分段
                initSegment(tasks, segments);
                // 依据 maxCount 对 segments 降序
                Collections.sort(segments);
                List taskAfterSortList = new ArrayList<>();
                // 对 tasks 进行重排，重排结果保存到 taskAfterSortList
                reSortTask(tasks, segments, taskAfterSortList);
                // 重排后
                // 记录一次任务
                int i = 0;
                Calendar erreryDay = Calendar.getInstance();
                erreryDay.set(currentDate.get(Calendar.YEAR), currentDate.get(Calendar.MONTH), currentDate.get(Calendar.DATE), 8, 0, 0);
                while (true) {
                    if (erreryDay.get(Calendar.HOUR_OF_DAY) > 18 || i >= taskAfterSortList.size()) {
                        break;
                    }

                    Task task = taskAfterSortList.get(i);
                    if (task.getCount() == 0) {
                        i++;
                        continue;
                    }
                    // 拜访类型
                    Integer type = task.getType();
                    // 拜访名称
                    String name = task.getName();
                    // 记录开始拜访时间
                    if (erreryDay.get(Calendar.HOUR_OF_DAY) >= 12 && erreryDay.get(Calendar.HOUR_OF_DAY) < 14) {
                        erreryDay.set(Calendar.HOUR_OF_DAY, 14);
                    }
                    Date startDate = erreryDay.getTime();
                    Random random = new Random();
                    Date endDate;
                    Visit visit = new Visit();
                    // 医院拜访
                    if (type == 1) {
                        HospitalVisit hospitalVisit = new HospitalVisit();
                        hospitalVisit.setName(name);
                        visit.setName(name);
                        hospitalVisit.setStartTime(startDate);
                        visit.setStartTime(startDate);
                        erreryDay.add(Calendar.MINUTE, visitTime + random.nextInt(2 * visitTimeRange + 1) - visitTimeRange);
                        endDate = erreryDay.getTime();
                        hospitalVisit.setEndTime(endDate);
                        visit.setEndTime(endDate);
                        if (erreryDay.get(Calendar.HOUR_OF_DAY) < 18) {
                            hospitalVisitService.save(hospitalVisit);
                            visitRepository.save(visit);
                            task.setCount(task.getCount() - 1);
                            System.out.println(hospitalVisit);
                        } else {
                            break;
                        }
                    } else if (type == 2) { // 公司拜访
                        CompanyVisit companyVisit = new CompanyVisit();
                        companyVisit.setName(name);
                        visit.setName(name);
                        companyVisit.setStartTime(startDate);
                        visit.setStartTime(startDate);
                        erreryDay.add(Calendar.MINUTE, visitTime + random.nextInt(2 * visitTimeRange + 1) - visitTimeRange);
                        endDate = erreryDay.getTime();
                        companyVisit.setEndTime(endDate);
                        visit.setEndTime(endDate);
                        if (erreryDay.get(Calendar.HOUR_OF_DAY) < 18) {
                            companyVisitService.save(companyVisit);
                            visitRepository.save(visit);
                            task.setCount(task.getCount() - 1);
                            System.out.println(companyVisit);
                        } else {
                            break;
                        }
                    } else { // 药房拜访
                        PharmacyVisit pharmacyVisit = new PharmacyVisit();
                        pharmacyVisit.setName(name);
                        visit.setName(name);
                        pharmacyVisit.setStartTime(startDate);
                        visit.setStartTime(startDate);
                        erreryDay.add(Calendar.MINUTE, visitTime + random.nextInt(2 * visitTimeRange + 1) - visitTimeRange);
                        endDate = erreryDay.getTime();
                        pharmacyVisit.setEndTime(endDate);
                        visit.setEndTime(endDate);
                        if (erreryDay.get(Calendar.HOUR_OF_DAY) < 18) {
                            pharmacyVisitService.save(pharmacyVisit);
                            visitRepository.save(visit);
                            System.out.println(pharmacyVisit);
                            task.setCount(task.getCount() - 1);
                        } else {
                            break;
                        }
                    }
                    this.saveOrUpdate(task);
                    if (i + 1 >= task.getCount()) {
                        continue;
                    }
                    if (taskAfterSortList.get(i + 1).getDistrict().equals(taskAfterSortList.get(i).getDistrict())) {
                        erreryDay.add(Calendar.MINUTE, shortMoveTime + random.nextInt(2 * shortMoveTimeRange + 1) - shortMoveTimeRange);
                    } else {
                        erreryDay.add(Calendar.MINUTE, longMoveTime + random.nextInt(2 * longMoveTimeRange + 1) - longMoveTimeRange);
                    }
                    i++;
                }
            }

            // 日期加1天
            currentDate.add(Calendar.DATE, 1);
            // 跨月结束
            if (taskMonth != currentDate.get(Calendar.MONTH)) {
                break;
            }
        }
    }

    
    private void reSortTask(List tasks, List segments, List taskAfterSortList) {
        for (Segment segment : segments) {
            int from = segment.getFrom();
            int end = segment.getEnd();
            for (int i = from; i <= end; i++) {
                taskAfterSortList.add(tasks.get(i));
            }
        }
    }

    
    private void initSegment(List tasks, List segments) {
        for (int i = 0; i < tasks.size(); i++) {
            int headIndex = i;
            int tailIndex = i + 1;
            Task tasktHead = tasks.get(headIndex);
            if (tailIndex == tasks.size()) {
                Segment segment = new Segment();
                segment.setFrom(headIndex);
                segment.setEnd(headIndex);
                segment.setMaxCount(tasks.get(headIndex).getCount());
                segments.add(segment);
                break;
            }

            while (true) {
                Task taskTail;
                if (tailIndex != tasks.size()) {
                    taskTail = tasks.get(tailIndex);
                    if (!tasktHead.getDistrict().equals(taskTail.getDistrict())) {
                        Segment segment = new Segment();
                        segment.setFrom(headIndex);
                        segment.setEnd(tailIndex - 1);
                        segment.setMaxCount(tasks.get(headIndex).getCount());
                        segments.add(segment);
                        i = tailIndex - 1;
                        break;
                    }
                } else {
                    Segment segment = new Segment();
                    segment.setFrom(headIndex);
                    segment.setEnd(tasks.size() - 1);
                    segment.setMaxCount(tasks.get(headIndex).getCount());
                    segments.add(segment);
                    i = tasks.size() - 1;
                    break;
                }
                tailIndex++;
            }
        }
    }

    
    private void initTask(TaskDistributionVo taskDistributionVo, List taskList) {
        // 医院拜访次数
        int count1 = taskDistributionVo.getCount1();
        List hospitalList = hospitalService.list();
        // 平均每一个医院拜访次数
        int avgHospitalCount = count1 / hospitalList.size();
        int plusHospitalCount = count1 % hospitalList.size();
        for (Hospital hospital : hospitalList) {
            Task task = new Task();
            task.setName(hospital.getName());
            task.setProvince(hospital.getProvince());
            task.setCity(hospital.getCity());
            task.setDistrict(hospital.getDistrict());
            task.setType(1);
            if (plusHospitalCount > 0) {
                task.setCount(avgHospitalCount + 1);
                plusHospitalCount--;
            } else {
                task.setCount(avgHospitalCount);
            }
            taskList.add(task);
        }

        // 公司拜访次数
        int count2 = taskDistributionVo.getCount2();
        List companyList = companyService.list();
        // 平均每一个公司拜访次数
        int avgCompanyCount = count2 / companyList.size();
        int plusCompanyCount = count2 % companyList.size();
        for (Company company : companyList) {
            Task task = new Task();
            task.setName(company.getName());
            task.setProvince(company.getProvince());
            task.setCity(company.getCity());
            task.setDistrict(company.getDistrict());
            task.setType(2);
            if (plusCompanyCount > 0) {
                task.setCount(avgCompanyCount + 1);
                plusCompanyCount--;
            } else {
                task.setCount(avgCompanyCount);
            }
            taskList.add(task);
        }

        // 药房拜访次数
        int count3 = taskDistributionVo.getCount3();
        List pharmacyList = pharmacyService.list();
        // 平均每一个药房拜访次数
        int avgPharmacyCount = count3 / pharmacyList.size();
        int plusPharmacyCount = count3 % pharmacyList.size();
        for (Pharmacy pharmacy : pharmacyList) {
            Task task = new Task();
            task.setName(pharmacy.getName());
            task.setProvince(pharmacy.getProvince());
            task.setCity(pharmacy.getCity());
            task.setDistrict(pharmacy.getDistrict());
            task.setType(3);
            if (plusPharmacyCount > 0) {
                task.setCount(avgPharmacyCount + 1);
                plusPharmacyCount--;
            } else {
                task.setCount(avgPharmacyCount);
            }
            taskList.add(task);
        }
    }
}