新的计算逻辑提交

src/main/java/com/neotel/webbox/capacitynew/BoxRestControllerNew.java

+package com.neotel.webbox.capacitynew;
+
+import com.neotel.webbox.capacity.bean.ReelItem;
+import com.neotel.webbox.capacitynew.bean.BoxData;
+import com.neotel.webbox.capacitynew.bean.BoxResult;
+import com.neotel.webbox.capacitynew.bean.ReelData;
+import com.neotel.webbox.capacitynew.bean.RequestItem;
+import com.neotel.webbox.capacitynew.data.BaseDataCacheNew;
+import com.neotel.webbox.capacitynew.method.AssignMethod;
+import com.neotel.webbox.capacitynew.bean.ResultBean;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.*;
+
+@Slf4j
+@RestController
+@RequestMapping("/box")
+public class BoxRestControllerNew {
+
+    /**
+     * 获取料仓基本数据
+     *
+     * @return
+     */
+    @RequestMapping("/baseData")
+    public ResultBean baseData() {
+        Map<String, Object> map = new HashMap<>();
+        List<BoxData> boxDataList = new ArrayList<>(BaseDataCacheNew.getBoxDataList());
+        boxDataList.sort(Comparator.comparing(BoxData::getBoxName));
+        map.put("boxDataList", boxDataList);
+        Collection<ReelData> reelNameList = BaseDataCacheNew.getReelDataList();
+        Map<Integer, List<Integer>> reelSizeMap = new HashMap<>();
+        for (ReelData reelData : reelNameList) {
+            int reelSize = reelData.getReelSize();
+            List<Integer> reelHeightList = reelSizeMap.get(reelSize);
+            if (reelHeightList == null) {
+                reelHeightList = new ArrayList<>();
+            }
+            int reelHeight = reelData.getReelHeight();
+            reelHeightList.add(reelHeight);
+            reelHeightList.sort(new Comparator<Integer>() {
+                @Override
+                public int compare(Integer o1, Integer o2) {
+                    return o1 - o2;
+                }
+            });
+            reelSizeMap.put(reelSize, reelHeightList);
+        }
+        map.put("reelSizeMap", reelSizeMap);
+        return ResultBean.newOkResult(map);
+    }
+
+
+    @RequestMapping("/capacity")
+    public ResultBean capacityCalculation(@RequestBody Map<String, String> paramMap) {
+        try {
+            //获取到料仓数据
+            String boxName = paramMap.get("boxName");
+            log.info("收到计算料仓数量请求:" + boxName);
+            BoxData boxData = BaseDataCacheNew.getBoxData(boxName);
+            if (boxData == null) {
+                String msg = "未找到" + boxName + "对应的料仓";
+                log.warn(msg);
+                return ResultBean.newErrorResult(101, msg);
+            }
+            //获取到料盘数据
+            List<RequestItem> requestList = new ArrayList<>();
+            for (Map.Entry<String, String> item : paramMap.entrySet()) {
+                if (item.getKey().equals("boxName")) {
+                    continue;
+                }
+                ReelData reelData = BaseDataCacheNew.getReelData(item.getKey());
+                if (reelData == null) {
+                    String msg = "未找到" + boxName + "对应的料盘" + item.getKey();
+                    log.warn(msg);
+                    return ResultBean.newErrorResult(102, msg);
+                }
+                log.info("料盘需求" + item.getKey() + ":" + item.getValue());
+
+                int num = Integer.valueOf(item.getValue());
+                requestList.add(new RequestItem(num, reelData));
+            }
+            if (requestList.isEmpty()) {
+                String msg = "Params Error";
+                log.warn(msg);
+                return ResultBean.newErrorResult(102, msg);
+            }
+
+            BoxResult boxResult = AssignMethod.averageCapacityToBox(boxData, requestList);
+            log.info("方案一共需要" + boxResult.getBoxList().size() + "个料仓");
+            for (ReelItem reelItem : boxResult.getReelItemList()) {
+                log.info(reelItem.getSizeStr() + " 料盘需求:" + reelItem.getNeedNum() + " 容量:" + reelItem.getCapacity());
+            }
+
+            Map<String, Object> resultMap = new HashMap<>();
+            resultMap.put("boxCount", boxResult.getBoxList().size());
+            List<Map<String, Object>> capacityItems = new ArrayList<>();
+            for (ReelItem reelItem : boxResult.getReelItemList()) {
+                Map<String, Object> dataMap = new HashMap<>();
+                int needNum = reelItem.getNeedNum();
+                int capacity = reelItem.getCapacity();
+                int w = reelItem.getW();
+                int h = reelItem.getH();
+                dataMap.put("w", w);
+                dataMap.put("h", h);
+                dataMap.put("capacity", capacity);
+                dataMap.put("needNum", needNum);
+                capacityItems.add(dataMap);
+            }
+            resultMap.put("boxName", boxName);
+            resultMap.put("capacityItems", capacityItems);
+            return ResultBean.newOkResult(resultMap);
+        } catch (Exception e) {
+            log.error("计算料仓数量时发生异常", e);
+            return ResultBean.newErrorResult(500, "Error");
+        }
+    }
+}

src/main/java/com/neotel/webbox/capacitynew/bean/BoxData.java

+package com.neotel.webbox.capacitynew.bean;
+
+import com.alibaba.excel.annotation.ExcelIgnore;
+import com.alibaba.excel.annotation.ExcelProperty;
+import com.alibaba.excel.util.NumberUtils;
+import com.neotel.webbox.util.NumberUtil;
+import lombok.Getter;
+import lombok.Setter;
+
+
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Setter
+@Getter
+public class BoxData {
+
+    /**
+     * 料仓名称
+     */
+    @ExcelProperty("料仓名称")
+    private String boxName;
+
+    /**
+     * 料仓高度
+     */
+    @ExcelProperty("料仓高度")
+    private int boxHeight;
+
+    /**
+     * 料仓不可用高度
+     */
+    @ExcelProperty("不可用高度")
+    private int boxInvalidHeight;
+
+
+    /**
+     * 列数
+     */
+    @ExcelProperty("标准列数")
+    private int columnCount;
+
+
+    /**
+     * 料仓特殊列
+     */
+    @ExcelIgnore
+    private Map<String, List<BoxSpecialColumnContent>> boxSpecialColumnMap;
+
+
+    /**
+     * 是否有效
+     *
+     * @return
+     */
+    public boolean isValid() {
+        return !boxName.isEmpty()
+                && boxHeight >= 1000
+                && boxInvalidHeight >= 100
+                && columnCount >= 1;
+    }
+
+    public int getBoxPureSizeCapacity(ReelData reelData) {
+        //每一列可放料盘数量
+        int columnPureSizeCapacity = getColumnPureSizeCapacity(reelData.getPressHeight(), reelData);
+        //特殊列上部可放料盘数量
+        int boxSpecialColumnUpCapacityTotal = getBoxSpecialColumnUpCapacityTotal(getBoxSpecialColumnMap(), reelData.getPressHeight(), reelData);
+        //特殊列下部可放料盘数量
+        int boxSpecialColumnCapacityTotal = getBoxSpecialColumnCapacityTotal(getBoxSpecialColumnMap(), reelData);
+        int total = getColumnCount() * columnPureSizeCapacity + boxSpecialColumnUpCapacityTotal + boxSpecialColumnCapacityTotal;
+        return total;
+    }
+
+
+    /**
+     * 获取特殊列上部可放入料盘大小
+     *
+     * @param pressHeight
+     * @param reelData
+     * @return
+     */
+    public int getBoxSpecialColumnUpCapacityTotal(Map<String, List<BoxSpecialColumnContent>> boxSpecialColumnMap, int pressHeight, ReelData reelData) {
+        int boxSpecialColumnUpCapacity = 0;
+        if (boxSpecialColumnMap != null && boxSpecialColumnMap.size() > 0) {
+            boxFillSpecialColumnHeight(boxSpecialColumnMap, reelData);
+            for (Map.Entry<String, List<BoxSpecialColumnContent>> entry : boxSpecialColumnMap.entrySet()) {
+                List<BoxSpecialColumnContent> boxSpecialColumnContentList = entry.getValue();
+                if (boxSpecialColumnContentList != null && boxSpecialColumnContentList.size() > 0) {
+                    //减去（可用+不可用的）,得到可用高度,取放入的数量
+                    int boxSpecialColumnHeightTotal = boxSpecialColumnContentList.stream().mapToInt(BoxSpecialColumnContent::getHeight).sum();
+                    int boxSpecialColumnUpHeight = getBoxSpecialColumnUpHeightTotal(boxSpecialColumnHeightTotal, pressHeight);
+                    boxSpecialColumnUpCapacity += getColumnPureSizeCapacity(boxSpecialColumnUpHeight, reelData.getReelSize(), reelData.getReelSlotHeight());
+                }
+            }
+        }
+        return boxSpecialColumnUpCapacity;
+    }
+
+
+    /**
+     * 特殊列上方可用空间(总高度 - 特殊列可用不可用高度 - 下方高度 - 压紧高度)
+     */
+    public int getBoxSpecialColumnUpHeightTotal(int boxSpecialColumnHeightTotal, int pressHeight) {
+        int columnValidHeight = getBoxHeight() - boxSpecialColumnHeightTotal - getBoxInvalidHeight() - pressHeight;
+        return columnValidHeight;
+    }
+
+    /**
+     * 获取特殊列可用高度,所能放的数量
+     *
+     * @param boxSpecialColumnMap
+     * @param reelData
+     * @return
+     */
+    public int getBoxSpecialColumnCapacityTotal(Map<String, List<BoxSpecialColumnContent>> boxSpecialColumnMap, ReelData reelData) {
+        int boxSpecialColumnCapacity = 0;
+        if (boxSpecialColumnMap != null && boxSpecialColumnMap.size() > 0) {
+            //加载料仓与料盘之间的数据
+            boxSpecialColumnMap = boxFillSpecialColumnHeight(boxSpecialColumnMap, reelData);
+            //循环每列可以放下的高度
+            for (Map.Entry<String, List<BoxSpecialColumnContent>> entry : boxSpecialColumnMap.entrySet()) {
+                List<BoxSpecialColumnContent> boxSpecialColumnContentList = entry.getValue();
+                if (boxSpecialColumnContentList != null && boxSpecialColumnContentList.size() > 0) {
+                    for (BoxSpecialColumnContent boxSpecialColumnContent : boxSpecialColumnContentList) {
+                        if ("可用".equals(boxSpecialColumnContent.getTitle())) {
+                            boxSpecialColumnCapacity += getColumnPureSizeCapacity(boxSpecialColumnContent.getHeight(), reelData.getReelSize(), reelData.getReelSlotHeight());
+                        }
+                    }
+                }
+            }
+        }
+        return boxSpecialColumnCapacity;
+    }
+
+
+    /**
+     * 获取特殊列可用高度,所能放的数量(单个)
+     *
+     * @param boxSpecialColumnContentList
+     * @param reelData
+     * @return
+     */
+    public int getBoxSingleSpecialColumnCapacity(List<BoxSpecialColumnContent> boxSpecialColumnContentList, ReelData reelData) {
+        int boxSingleSpecialColumnCapacity = 0;
+        //循环每列可以放下的高度
+        if (boxSpecialColumnContentList != null && boxSpecialColumnContentList.size() > 0) {
+            for (BoxSpecialColumnContent boxSpecialColumnContent : boxSpecialColumnContentList) {
+                if ("可用".equals(boxSpecialColumnContent.getTitle())) {
+                    boxSingleSpecialColumnCapacity += getColumnPureSizeCapacity(boxSpecialColumnContent.getHeight(), reelData.getReelSize(), reelData.getReelSlotHeight());
+                }
+            }
+
+        }
+        return boxSingleSpecialColumnCapacity;
+    }
+
+
+    /**
+     * 获取到特殊列(单列)可用的总高度
+     *
+     * @param boxSpecialColumnContentList
+     * @return
+     */
+    public int getBoxSingleSpecialColumnHeight(List<BoxSpecialColumnContent> boxSpecialColumnContentList) {
+        return boxSpecialColumnContentList.stream().filter(boxSpecialColumnContent -> boxSpecialColumnContent.getTitle().equals("可用")).mapToInt(BoxSpecialColumnContent::getHeight).sum();
+    }
+
+
+    /**
+     * 料仓特殊列取值 与 料盘关联
+     *
+     * @param boxSpecialColumnMap
+     * @param reelData
+     * @return
+     */
+    public static Map<String, List<BoxSpecialColumnContent>> boxFillSpecialColumnHeight(Map<String, List<BoxSpecialColumnContent>> boxSpecialColumnMap, ReelData reelData) {
+        if (boxSpecialColumnMap != null && boxSpecialColumnMap.size() > 0) {
+            for (Map.Entry<String, List<BoxSpecialColumnContent>> entry : boxSpecialColumnMap.entrySet()) {
+                String boxSpecialColumnTitle = entry.getKey();
+                //获取到特殊列的值
+                List<BoxSpecialColumnContent> boxSpecialColumnContentList = entry.getValue();
+                if (boxSpecialColumnContentList != null && boxSpecialColumnContentList.size() > 0) {
+                    for (BoxSpecialColumnContent boxSpecialColumnContent : boxSpecialColumnContentList) {
+                        getBoxSpecialColumnHeight(boxSpecialColumnContent, reelData);
+                    }
+                }
+            }
+        }
+        return boxSpecialColumnMap;
+    }
+
+    /**
+     * 特殊列进行转换,文本的转成数值
+     *
+     * @param boxSpecialColumnContent
+     * @return
+     */
+    public static BoxSpecialColumnContent getBoxSpecialColumnHeight(BoxSpecialColumnContent boxSpecialColumnContent, ReelData reelData) {
+        //先看料仓里是否配置,如果没有配置的话  就取料盘数据
+        int height = 0;
+        if (NumberUtil.isInteger(boxSpecialColumnContent.getValue())) {
+            height = (int) Double.parseDouble(boxSpecialColumnContent.getValue());
+        } else {
+            Map<String, Integer> boxSpecialColumn = reelData.getBoxSpecialColumn();
+            Integer boxSpecialColumnHeight = boxSpecialColumn.get(boxSpecialColumnContent.getValue());
+            if (boxSpecialColumnHeight != null) {
+                height = boxSpecialColumnHeight;
+            }
+        }
+        boxSpecialColumnContent.setHeight(height);
+        return boxSpecialColumnContent;
+    }
+
+
+    /**
+     * 获取标准列可放入料盘数量
+     *
+     * @param pressHeight
+     * @param reelData
+     * @return
+     */
+    public int getColumnPureSizeCapacity(int pressHeight, ReelData reelData) {
+        //标准列可用高度
+        int columnValidHeight = getColumnValidHeight(pressHeight);
+        return getColumnPureSizeCapacity(columnValidHeight, reelData.getReelSize(), reelData.getReelSlotHeight()/*, false*/);
+    }
+
+
+    /**
+     * 根据可用空间和料盘尺寸计算料盘容量
+     *
+     * @param reelSize        料盘尺寸
+     * @param validHeight     可用高度
+     * @param reelSpaceHeight 单个格子占用高度
+     * @return 容量
+     */
+    public int getColumnPureSizeCapacity(int validHeight, int reelSize, int reelSpaceHeight/*, boolean isDoorDown*/) {
+        int countPerColumn = validHeight / reelSpaceHeight;
+        //如果不是入料口下方,每一列上部可多放一盘
+        //if (!isDoorDown) {
+            if (reelSize == 7 || validHeight % reelSpaceHeight != 0) {
+                //如果有空余可以再放一盘,7寸盘可以多放一盘
+                countPerColumn = countPerColumn + 1;
+            }
+       // }
+        //每个格子可放料盘数,7寸盘为2盘,其他为1
+        int countPerUnit = 1;
+        if (reelSize == 7) {
+            countPerUnit = 2;
+        }
+        int capacity = countPerColumn * countPerUnit;
+        return capacity;
+    }
+
+
+    /**
+     * 料仓列可用高度,总高-不可用高度(下方电气板) - 压紧轴占用高度
+     */
+    public int getColumnValidHeight(int pressHeight) {
+        return getBoxHeight() - getBoxInvalidHeight() - pressHeight;
+    }
+
+    /**
+     * 获取到料仓总可用高度
+     *
+     * @param maxPressHeight
+     * @param requestList
+     * @return
+     */
+    public int getTotalValidHeight(int maxPressHeight, List<RequestItem> requestList) {
+        return this.getColumnCount() * getColumnValidHeight(maxPressHeight) + getBoxSpecialColumnValidHeightTotal(getBoxSpecialColumnMap(),requestList) + getBoxSpecialColumnUpValidHeightTotal(getBoxSpecialColumnMap(), requestList, maxPressHeight);
+    }
+
+
+    /**
+     * 获取特殊列上部有效高度
+     *
+     * @param boxSpecialColumnMap
+     * @return
+     */
+    public int getBoxSpecialColumnUpValidHeightTotal(Map<String, List<BoxSpecialColumnContent>> boxSpecialColumnMap, List<RequestItem> requestList, int maxPressHeight) {
+        int boxSpecialColumnUpHeightTotal = 0;
+        if (boxSpecialColumnMap != null && boxSpecialColumnMap.size() > 0) {
+            //循环特殊列
+            for (Map.Entry<String, List<BoxSpecialColumnContent>> map : boxSpecialColumnMap.entrySet()) {
+                int singleBoxSpecialColumnUpValidHeight = getBoxHeight();
+                List<BoxSpecialColumnContent> boxSpecialColumnContentList = map.getValue();
+                int tempValidHeight = 0;
+                for (RequestItem requestItem : requestList) {
+                    for (BoxSpecialColumnContent boxSpecialColumnContent : boxSpecialColumnContentList) {
+                        getBoxSpecialColumnHeight(boxSpecialColumnContent, requestItem.getReelData());
+                    }
+                    int specialColumnValidHeight = boxSpecialColumnContentList.stream().mapToInt(BoxSpecialColumnContent::getHeight).sum();
+                    tempValidHeight = getBoxSpecialColumnUpHeightTotal(specialColumnValidHeight, maxPressHeight);
+                    if (tempValidHeight < singleBoxSpecialColumnUpValidHeight) {
+                        singleBoxSpecialColumnUpValidHeight = tempValidHeight;
+                    }
+                }
+                boxSpecialColumnUpHeightTotal += singleBoxSpecialColumnUpValidHeight;
+            }
+        }
+        return boxSpecialColumnUpHeightTotal;
+    }
+
+
+    /**
+     * 获取特殊列上部有效高度(单列)
+     *
+     * @param boxSpecialColumnContentList
+     * @param maxPressHeight
+     * @return
+     */
+    public int getBoxSingleSpecialColumnUpValidHeight(List<BoxSpecialColumnContent> boxSpecialColumnContentList, int maxPressHeight) {
+        int specialColumnHeight = boxSpecialColumnContentList.stream().mapToInt(BoxSpecialColumnContent::getHeight).sum();
+        return getBoxSpecialColumnUpHeightTotal(specialColumnHeight, maxPressHeight);
+    }
+
+
+    /**
+     * 获取特殊列可用总高度
+     *
+     * @param boxSpecialColumnMap
+     * @return
+     */
+    public int getBoxSpecialColumnValidHeightTotal(Map<String, List<BoxSpecialColumnContent>> boxSpecialColumnMap,List<RequestItem> requestList) {
+        //获取到可用高度
+        int specialColumnValidHeight = 0;
+        if (boxSpecialColumnMap != null && boxSpecialColumnMap.size() > 0) {
+            //每个料仓可用高度是一样的,在这里只取第一个
+            boxSpecialColumnMap = boxFillSpecialColumnHeight(boxSpecialColumnMap,requestList.get(0).getReelData());
+            for (Map.Entry<String, List<BoxSpecialColumnContent>> entry : boxSpecialColumnMap.entrySet()) {
+                List<BoxSpecialColumnContent> specialColumnContentList = entry.getValue();
+                specialColumnValidHeight += specialColumnContentList.stream().filter(boxSpecialColumnContent -> boxSpecialColumnContent.getTitle().equals("可用")).mapToInt(BoxSpecialColumnContent::getHeight).sum();
+            }
+        }
+        return specialColumnValidHeight;
+    }
+}

src/main/java/com/neotel/webbox/capacitynew/bean/BoxResult.java

+package com.neotel.webbox.capacitynew.bean;
+
+import com.neotel.webbox.capacity.bean.ReelItem;
+import com.neotel.webbox.capacitynew.box.Box;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+@Getter
+@Setter
+public class BoxResult {
+
+    private List<Box> boxList;
+
+    private List<RequestItem> requestList = new ArrayList<>();
+
+    public List<ReelItem> getReelItemList() {
+        List<ReelItem> reelItemList = initRequestNum(requestList);
+        if (boxList != null) {
+            for (Box box : boxList) {
+                for (ReelItem boxReelItem : box.getCapacity().values()) {
+                    reelItemList = addBoxCapacityToResult(reelItemList, boxReelItem);
+                }
+            }
+        }
+        return reelItemList;
+    }
+
+
+    private List<ReelItem> addBoxCapacityToResult(List<ReelItem> reelItemList, ReelItem boxReelItem) {
+        for (ReelItem totalReelItem : reelItemList) {
+            if (totalReelItem.getSizeStr().equals(boxReelItem.getSizeStr())) {
+                totalReelItem.addCapacity(boxReelItem.getCapacity());
+                return reelItemList;
+            }
+        }
+        //未找到,新添加一个
+        reelItemList.add(boxReelItem);
+        return reelItemList;
+    }
+
+
+    private List<ReelItem> initRequestNum(Collection<RequestItem> requestList) {
+        List<ReelItem> reelItemList = new ArrayList<>();
+        for (RequestItem reelRequestItem : requestList) {
+            ReelItem reelItem = new ReelItem();
+            reelItem.setW(reelRequestItem.getReelData().getReelSize());
+            reelItem.setH(reelRequestItem.getReelData().getReelHeight());
+            reelItem.setNeedNum(reelRequestItem.getNum());
+            reelItemList.add(reelItem);
+        }
+        return reelItemList;
+    }
+}

src/main/java/com/neotel/webbox/capacitynew/bean/BoxSpecialColumnContent.java

+package com.neotel.webbox.capacitynew.bean;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 标题特殊列包含的内容
+ */
+@Getter
+@Setter
+public class BoxSpecialColumnContent {
+    /**
+     * 子所在位置
+     */
+    private Integer index;
+    /**
+     * 子标题
+     */
+    private String title;
+    /**
+     * 对应行内容
+     */
+    private String value;
+
+    /**
+     * 对应高度
+     */
+    private Integer height;
+}

src/main/java/com/neotel/webbox/capacitynew/bean/BoxTitle.java

+package com.neotel.webbox.capacitynew.bean;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+@Getter
+@Setter
+/**
+ * 料仓标题
+ */
+public class BoxTitle {
+    /**
+     * 标题名称
+     */
+    private String titleName;
+    /**
+     * 标题合并单元格列坐标集合
+     */
+    private List<Integer> mergeColumnIndexList;
+}

src/main/java/com/neotel/webbox/capacitynew/bean/ReelData.java

+package com.neotel.webbox.capacitynew.bean;
+
+import com.alibaba.excel.annotation.ExcelIgnore;
+import com.alibaba.excel.annotation.ExcelProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.Map;
+
+@Getter
+@Setter
+public class ReelData {
+
+    /**
+     * 料盘尺寸
+     */
+    @ExcelProperty("料盘尺寸")
+    private int reelSize;
+
+    /**
+     * 料盘高度
+     */
+    @ExcelProperty("料盘厚度")
+    private int reelHeight;
+
+    /**
+     * 压紧张开高度
+     */
+    @ExcelProperty("压紧张开高度")
+    private int pressHeight;
+
+    /**
+     * 料盘占用空间高度
+     */
+    @ExcelProperty("料格占用高度")
+    private int reelSlotHeight;
+
+    /**
+     * 最小模组单元
+     */
+    @ExcelIgnore
+    private int minUnit = 3;
+
+    /**
+     * 料仓特殊列,需要的数值信息,例如:入口碗:757
+     */
+    @ExcelIgnore
+    private Map<String,Integer> boxSpecialColumn;
+
+
+    /**
+     * 是否是7寸盘
+     */
+    public boolean is7Reel(){
+        return reelSize == 7;
+    }
+
+    public String getReelSizeStr(){
+        return reelSize + " x " + reelHeight;
+    }
+
+    public boolean isValid() {
+        return reelSize >= 7
+                && reelHeight >= 8
+                && pressHeight >= 10
+                && reelSlotHeight >= 10;
+    }
+}

src/main/java/com/neotel/webbox/capacitynew/bean/RequestItem.java

+package com.neotel.webbox.capacitynew.bean;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class RequestItem {
+
+    public RequestItem(int num, ReelData reelData) {
+        this.num = num;
+        this.reelData = reelData;
+    }
+
+    /**
+     * 需求数量
+     */
+    private int num;
+
+    /**
+     * 料盘数量
+     */
+    private ReelData reelData;
+
+    /**
+     * 需要纯料仓的数量
+     */
+    private int pureBoxCount;
+
+    /**
+     * 放完纯料仓后剩余数量
+     */
+    private int remainNum;
+
+    /**
+     * 剩余物料需要的总高度
+     */
+    public int getRemainNeedHeight(){
+        int reelCount = remainNum;
+        if(reelData.is7Reel()){
+            //7寸盘,每行放2个
+            reelCount = reelCount /2;
+            if(remainNum % 2 != 0){
+                reelCount = reelCount + 1;
+            }
+        }
+        return reelCount * reelData.getReelSlotHeight();
+    }
+
+    public String getReelSizeStr(){
+        return reelData.getReelSizeStr();
+    }
+
+
+
+}

src/main/java/com/neotel/webbox/capacitynew/bean/ResultBean.java

+package com.neotel.webbox.capacitynew.bean;
+
+public class ResultBean {
+
+    private int code;
+    private String msg;
+    private Object data;
+
+    public static ResultBean newOkResult(Object data){
+        ResultBean resultBean = new ResultBean();
+        resultBean.setMsg("OK");
+        resultBean.setData(data);
+        return resultBean;
+    }
+
+    public static ResultBean newErrorResult(int code, String msg){
+        ResultBean resultBean = new ResultBean();
+        resultBean.setCode(code);
+        resultBean.setMsg(msg);
+        resultBean.setData("");
+        return resultBean;
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public void setCode(int code) {
+        this.code = code;
+    }
+
+    public String getMsg() {
+        return msg;
+    }
+
+    public void setMsg(String msg) {
+        this.msg = msg;
+    }
+
+    public Object getData() {
+        return data;
+    }
+
+    public void setData(Object data) {
+        this.data = data;
+    }
+}

src/main/java/com/neotel/webbox/capacitynew/box/Box.java

+package com.neotel.webbox.capacitynew.box;
+
+import com.neotel.webbox.capacity.bean.ReelItem;
+import com.neotel.webbox.capacitynew.bean.BoxData;
+import com.neotel.webbox.capacitynew.bean.BoxSpecialColumnContent;
+import com.neotel.webbox.capacitynew.bean.RequestItem;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Getter
+@Setter
+public class Box {
+
+    /**
+     * 标准列数量
+     */
+    private int columnCount;
+
+    /**
+     * 标准列
+     */
+    private Column column;
+
+    /**
+     * 特殊列
+     */
+    private Map<String, Column> specialColumnMap;
+
+    /**
+     * 特殊列上部
+     */
+    private Map<String, Column> specialColumnUpMap;
+
+    public static Box newBox(BoxData boxData, List<RequestItem> requestList, int maxPressHeight) {
+        int validColumnHeight = boxData.getColumnValidHeight(maxPressHeight);
+        Box box = new Box();
+        //每台机器可用的高度是一样的,只取第一条即可
+        Map<String, Column> specialColumnMap = getSpecialColumnMap(boxData, requestList.get(0));
+        box.setSpecialColumnMap(specialColumnMap);
+
+        Map<String, Column> specialColumnUpMap = getSpecialColumnUpMap(boxData, requestList, maxPressHeight);
+        box.setSpecialColumnUpMap(specialColumnUpMap);
+
+        Column column = new Column(validColumnHeight);
+        box.setColumn(column);
+        return box;
+    }
+
+    private static Map<String, Column> getSpecialColumnUpMap(BoxData boxData, List<RequestItem> requestList, int maxPressHeight) {
+        Map<String, Column> specialColumnUpMap = new HashMap<>();
+        Map<String, List<BoxSpecialColumnContent>> boxSpecialColumnMap = boxData.getBoxSpecialColumnMap();
+        //开始对特殊列进行遍历,取特殊列最上方最小的
+        if (boxSpecialColumnMap != null && boxSpecialColumnMap.size() > 0) {
+            for (Map.Entry<String, List<BoxSpecialColumnContent>> entry : boxSpecialColumnMap.entrySet()) {
+                int boxSpecialColumnUpHeight = boxData.getBoxHeight();
+                for (RequestItem requestItem : requestList) {
+                    boxSpecialColumnMap = boxData.boxFillSpecialColumnHeight(boxSpecialColumnMap, requestItem.getReelData());
+                    List<BoxSpecialColumnContent> boxSpecialColumnContentList = entry.getValue();
+                    int boxSpecialColumnHeightTotal = boxSpecialColumnContentList.stream().mapToInt(BoxSpecialColumnContent::getHeight).sum();
+                    int boxSpecialColumnUpValidHeight = boxData.getBoxSpecialColumnUpHeightTotal(boxSpecialColumnHeightTotal, maxPressHeight);
+                    if (boxSpecialColumnUpHeight > boxSpecialColumnUpValidHeight) {
+                        boxSpecialColumnUpHeight = boxSpecialColumnUpValidHeight;
+                    }
+                }
+                if (boxSpecialColumnUpHeight != 0) {
+                    specialColumnUpMap.put(entry.getKey(), new Column(boxSpecialColumnUpHeight));
+                }
+            }
+        }
+        return specialColumnUpMap;
+    }
+
+    public static Map<String, Column> getSpecialColumnMap(BoxData boxData, RequestItem requestItem) {
+        Map<String, Column> specialColumnMap = new HashMap<>();
+        Map<String, List<BoxSpecialColumnContent>> boxSpecialColumnMap = boxData.getBoxSpecialColumnMap();
+        if (boxSpecialColumnMap != null && boxSpecialColumnMap.size() >0) {
+            boxSpecialColumnMap = boxData.boxFillSpecialColumnHeight(boxSpecialColumnMap, requestItem.getReelData());
+            for (Map.Entry<String, List<BoxSpecialColumnContent>> entry : boxSpecialColumnMap.entrySet()) {
+                int boxSpecialColumnValidHeight = boxData.getBoxSingleSpecialColumnHeight(entry.getValue());
+                specialColumnMap.put(entry.getKey(), new Column(boxSpecialColumnValidHeight));
+            }
+        }
+        return specialColumnMap;
+    }
+
+
+    /**
+     * 获取料仓的容量明细
+     */
+    public Map<String, ReelItem> getCapacity() {
+        Map<String, ReelItem> capacityMap = new HashMap<>();
+        for (int i = 0; i < getColumnCount(); i++) {
+            capacityMap = addToMap(capacityMap, column.getColumnCapacity());
+        }
+
+        for (Map.Entry<String, Column> entry : specialColumnMap.entrySet()) {
+            capacityMap = addToMap(capacityMap, entry.getValue().getColumnCapacity());
+        }
+
+        for (Map.Entry<String, Column> entry : specialColumnUpMap.entrySet()) {
+            capacityMap = addToMap(capacityMap, entry.getValue().getColumnCapacity());
+        }
+
+        return capacityMap;
+    }
+
+    private Map<String, ReelItem> addToMap(Map<String, ReelItem> capacityMap, Map<String, ReelItem> columnMap) {
+        for (Map.Entry<String, ReelItem> entry : columnMap.entrySet()) {
+            String sizeStr = entry.getKey();
+            ReelItem capacityItem = capacityMap.get(sizeStr);
+            if (capacityItem == null) {
+                capacityItem = new ReelItem();
+                capacityItem.setW(entry.getValue().getW());
+                capacityItem.setH(entry.getValue().getH());
+            }
+            int capacity = capacityItem.getCapacity() + entry.getValue().getCapacity();
+            capacityItem.setCapacity(capacity);
+            capacityMap.put(sizeStr, capacityItem);
+        }
+        return capacityMap;
+    }
+}

src/main/java/com/neotel/webbox/capacitynew/box/Column.java

+package com.neotel.webbox.capacitynew.box;
+
+import com.neotel.webbox.capacity.bean.ReelItem;
+import com.neotel.webbox.capacitynew.bean.ReelData;
+import lombok.Getter;
+import lombok.Setter;
+import org.apache.commons.compress.utils.Lists;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Getter
+@Setter
+public class Column {
+
+    public Column(int validHeight) {
+        this.validHeight = validHeight;  //可用高度
+        this.remainHeight = validHeight; //需要高度
+    }
+
+    private int validHeight;
+
+    private int remainHeight;
+
+    private List<SlotUnit> slotUnitList = Lists.newArrayList();
+
+    public SlotUnit getSlotUnit(ReelData reelData){
+        for (SlotUnit slotUnit : slotUnitList) {
+            if(slotUnit.getReelData().equals(reelData)){
+                return slotUnit;
+            }
+        }
+        return null;
+    }
+
+
+    public SlotUnit mergeSlotUnit(SlotUnit newSlotUnit){
+        if(newSlotUnit == null){
+            return null;
+        }
+        SlotUnit existSlotUnit = getSlotUnit(newSlotUnit.getReelData());
+        if(existSlotUnit != null){
+            int mergeCount = newSlotUnit.getReelCount() + existSlotUnit.getReelCount();
+            newSlotUnit.setReelCount(mergeCount);
+            remainHeight = remainHeight + existSlotUnit.getSlotHeight();
+            slotUnitList.remove(existSlotUnit);
+        }
+        return addSlotUnit(newSlotUnit);
+    }
+
+    /**
+     * 将模组加入列中, 返回加入结果,如果没放入返回null
+     */
+    public SlotUnit addSlotUnit(SlotUnit slotUnit){
+        if(slotUnit == null){
+            return null;
+        }
+        int slotHeight = slotUnit.getSlotHeight();
+        if(slotHeight > remainHeight){
+            return null;
+        }
+        remainHeight = remainHeight - slotHeight;
+        slotUnitList.add(slotUnit);
+        return slotUnit;
+    }
+
+    public Map<String, ReelItem> getColumnCapacity(){
+        Map<String,ReelItem> capacityMap = new HashMap<>();
+        for (SlotUnit slotUnit : getSlotUnitList()) {
+            String reelSizeStr = slotUnit.getReelData().getReelSizeStr();
+            ReelItem capacityItem = capacityMap.get(reelSizeStr);
+            if(capacityItem == null){
+                capacityItem = new ReelItem();
+                capacityItem.setW(slotUnit.getReelData().getReelSize());
+                capacityItem.setH(slotUnit.getReelData().getReelHeight());
+            }
+            int columnCapacity = slotUnit.getReelCount();
+            int capacity = capacityItem.getCapacity() + columnCapacity;
+            capacityItem.setCapacity(capacity);
+            capacityMap.put(reelSizeStr,capacityItem);
+        }
+        return capacityMap;
+    }
+}

src/main/java/com/neotel/webbox/capacitynew/box/SlotUnit.java

+package com.neotel.webbox.capacitynew.box;
+
+import com.neotel.webbox.capacitynew.bean.ReelData;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class SlotUnit {
+
+    public SlotUnit(ReelData reelData, int reelCount) {
+        this.reelData = reelData;
+        this.reelCount = reelCount;
+    }
+
+    private ReelData reelData; //料盘数据
+
+    private int reelCount; //料盘数量
+
+
+
+    public int getSlotHeight(){
+        int count = reelCount;
+        if(reelData.is7Reel()){
+            //7寸盘,一行摆2个
+            count = reelCount / 2;
+            if(count < reelData.getMinUnit()){
+                //小于最小单元,需要进行补充
+                count = reelData.getMinUnit();
+                reelCount = count * 2;
+            }else{
+                if(reelCount % 2 != 0){
+                    count = count + 1;
+                    reelCount = reelCount + 1;
+                }
+            }
+        }
+        int reelSlotHeight = reelData.getReelSlotHeight();
+        return count * reelSlotHeight;
+    }
+
+}

src/main/java/com/neotel/webbox/capacitynew/data/BaseDataCacheNew.java

+package com.neotel.webbox.capacitynew.data;
+
+import com.alibaba.excel.EasyExcel;
+import com.alibaba.excel.ExcelReader;
+import com.alibaba.excel.context.AnalysisContext;
+import com.alibaba.excel.event.AnalysisEventListener;
+import com.alibaba.excel.metadata.Cell;
+import com.alibaba.excel.metadata.data.CellData;
+import com.alibaba.excel.read.metadata.ReadSheet;
+import com.neotel.webbox.capacitynew.bean.BoxData;
+import com.neotel.webbox.capacitynew.bean.BoxSpecialColumnContent;
+import com.neotel.webbox.capacitynew.bean.BoxTitle;
+import com.neotel.webbox.capacitynew.bean.ReelData;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import org.springframework.util.ResourceUtils;
+
+import javax.annotation.PostConstruct;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.*;
+
+@Slf4j
+@Component
+public class BaseDataCacheNew {
+
+    /**
+     * 料仓基础数据
+     */
+    private static Map<String, BoxData> boxDataMap = new HashMap<>();
+
+    /**
+     * 料仓数据第一级标题
+     */
+    private static List<BoxTitle> boxFirstTitleList = new ArrayList<>();
+
+    /**
+     * 料仓数据第二级标题
+     */
+    private static List<BoxTitle> boxSecondTitleList = new ArrayList<>();
+
+    /**
+     * 料仓数据特殊列标题
+     */
+    private static Map<String, List<BoxSpecialColumnContent>> boxSpecialTitleMap = new HashMap<>();
+
+    /**
+     * 料仓标题循环计数
+     */
+    private static int boxTitleCount = 0;
+
+    /**
+     * 料盘基本数据
+     */
+    private static Map<String, ReelData> reelDataMap = new HashMap<>();
+
+    /**
+     * 料盘表头信息
+     */
+    private static Map<Integer, String> reelTitleMap = new HashMap<>();
+
+    @PostConstruct
+    public void readExcel() {
+        try {
+            InputStream fileStream = null;
+            File file = new File("data_new.xlsx");
+            if (file.exists()) {
+                log.info("加载包外数据文件:" + file.getAbsolutePath());
+                fileStream = new FileInputStream(file);
+            } else {
+                URL baseDir = ResourceUtils.getURL("classpath:data_new.xlsx");
+                fileStream = baseDir.openStream();
+                log.info("加载默认数据文件:" + baseDir.getPath());
+            }
+            try (ExcelReader excelReader = EasyExcel.read(fileStream).build()) {
+                //开始读取料仓基础数据
+                ReadSheet readSheet1 = EasyExcel.readSheet(0).head(BoxData.class).headRowNumber(3).registerReadListener(new AnalysisEventListener<BoxData>() {
+                    @Override
+                    public void invoke(BoxData data, AnalysisContext analysisContext) {
+                         //如果特殊列不为空,则进行操作
+                        if (boxSpecialTitleMap != null && !boxSpecialTitleMap.isEmpty()) {
+                            //获取到excel当前行的值
+                            Map<Integer, Cell> cellMap = analysisContext.readRowHolder().getCellMap();
+                            //开始循环遍历值三级标题
+                            for (Map.Entry<String, List<BoxSpecialColumnContent>> entry : boxSpecialTitleMap.entrySet()) {
+                                String specialColumnName = entry.getKey();  //特殊列标题名称
+                                List<BoxSpecialColumnContent> boxSpecialColumnContentList = entry.getValue(); //特殊列下的子标题与坐标
+                                if (boxSpecialColumnContentList != null && boxSpecialColumnContentList.size() > 0) {
+                                    List<BoxSpecialColumnContent> boxSpecialColumnContents = new ArrayList<>();
+                                    Map<String, List<BoxSpecialColumnContent>> boxSpecialColumnMap = new HashMap<>();
+                                    for (BoxSpecialColumnContent boxSpecialColumnContent : boxSpecialColumnContentList) {
+                                        Integer index = boxSpecialColumnContent.getIndex();
+                                        //根据第三级子标题中的下标,去找内容的值
+                                        CellData cellData = (CellData) cellMap.get(index);
+                                        if (cellData.getNumberValue() != null || cellData.getStringValue() != null) {
+                                            BoxSpecialColumnContent boxSpecialColumnContent1 = new BoxSpecialColumnContent();
+                                            boxSpecialColumnContent1.setTitle(boxSpecialColumnContent.getTitle());
+                                            boxSpecialColumnContent1.setIndex(index);
+                                            boxSpecialColumnContent1.setValue(cellData.getNumberValue() == null ? cellData.getStringValue() : cellData.getNumberValue() + "");
+                                            boxSpecialColumnContents.add(boxSpecialColumnContent1);
+                                        }
+                                    }
+                                    if (boxSpecialColumnContents != null && boxSpecialColumnContents.size() > 0) {
+                                        boxSpecialColumnMap.put(specialColumnName, boxSpecialColumnContents);
+                                        data.setBoxSpecialColumnMap(boxSpecialColumnMap);
+                                    }
+                                }
+                            }
+                        }
+                        if (!data.isValid()) {
+                            log.error("料仓表第{}行数据{}异常,忽略", analysisContext.getCurrentRowNum(), data.getBoxName());
+                        } else {
+                            log.info("加载到料仓{}数据", data.getBoxName());
+                            boxDataMap.put(data.getBoxName(), data);
+                        }
+                    }
+
+                    @Override
+                    public void doAfterAllAnalysed(AnalysisContext analysisContext) {
+                        log.info("料仓数据加载完成,共加载" + boxDataMap.size() + "条有效数据");
+                    }
+
+                    @Override
+                    public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
+                        BoxTitle boxTitle = new BoxTitle();
+                        List<Integer> mergeColumnIndexList = new ArrayList<>();
+                        // boxTitleCount = 0,1,2 分别代表 一,二,三级标题
+                        if (boxTitleCount == 0) {
+                            for (Map.Entry<Integer, String> entry : headMap.entrySet()) {
+                                Integer titleIndex = entry.getKey();
+                                String titleName = entry.getValue();
+                                if (titleName != null) {
+                                    if (boxTitle.getTitleName() != null) {
+                                        boxTitle.setMergeColumnIndexList(mergeColumnIndexList);
+                                        boxFirstTitleList.add(boxTitle);
+                                        //如果保存完之后,合并列数和标题内容给置空,给后续标题赋值
+                                        boxTitle = new BoxTitle();
+                                        mergeColumnIndexList = new ArrayList<>();
+                                    }
+                                    boxTitle.setTitleName(titleName);
+                                }
+                                mergeColumnIndexList.add(titleIndex);
+                            }
+                            //补一刀,防止后续出现标题一直为空,保存不到第一级标题中
+                            if (boxTitle.getTitleName() != null) {
+                                boxTitle.setMergeColumnIndexList(mergeColumnIndexList);
+                                boxFirstTitleList.add(boxTitle);
+                            }
+                        } else if (boxTitleCount == 1) {
+                            if (boxFirstTitleList != null && boxFirstTitleList.size() > 0) {
+                                int colNumCount = 0;
+                                for (BoxTitle boxFirstTitle : boxFirstTitleList) {
+                                    for (Map.Entry<Integer, String> entry : headMap.entrySet()) {
+                                        Integer titleIndex = entry.getKey();
+                                        String titleName = entry.getValue();
+                                        if (boxFirstTitle.getMergeColumnIndexList().contains(titleIndex)) {
+                                            if (titleName != null) {
+                                                colNumCount++;
+                                                if (boxTitle.getTitleName() != null) {
+                                                    boxTitle.setMergeColumnIndexList(mergeColumnIndexList);
+                                                    boxSecondTitleList.add(boxTitle);
+                                                    boxTitle = new BoxTitle();
+                                                    mergeColumnIndexList = new ArrayList<>();
+                                                }
+                                                boxTitle.setTitleName(titleName);
+                                            }
+                                            //判断是否从一开始就为空
+                                            if (colNumCount > 0) {
+                                                mergeColumnIndexList.add(titleIndex);
+                                            }
+                                        }
+                                    }
+                                    //和第一层标题一样,进行补一刀
+                                    if (boxTitle.getTitleName() != null) {
+                                        boxTitle.setMergeColumnIndexList(mergeColumnIndexList);
+                                        boxSecondTitleList.add(boxTitle);
+                                    }
+                                }
+                            }
+                        } else if (boxTitleCount == 2) {
+                            if (boxSecondTitleList != null && boxSecondTitleList.size() > 0) {
+                                for (BoxTitle boxSecondTitle : boxSecondTitleList) {
+                                    List<BoxSpecialColumnContent> specialColumnList = new ArrayList<>();
+                                    for (Map.Entry<Integer, String> entry : headMap.entrySet()) {
+                                        Integer titleIndex = entry.getKey();
+                                        String titleName = entry.getValue();
+                                        if (boxSecondTitle.getMergeColumnIndexList().contains(titleIndex) && titleName != null) {
+                                            BoxSpecialColumnContent specialColumnContent = new BoxSpecialColumnContent();
+                                            specialColumnContent.setTitle(titleName);
+                                            specialColumnContent.setIndex(titleIndex);
+                                            specialColumnList.add(specialColumnContent);
+                                        }
+                                    }
+                                    boxSpecialTitleMap.put(boxSecondTitle.getTitleName(), specialColumnList);
+                                }
+                            }
+                        }
+                        boxTitleCount++;
+                    }
+                }).build();
+
+                ReadSheet readSheet2 = EasyExcel.readSheet(1).head(ReelData.class).headRowNumber(1).registerReadListener(new AnalysisEventListener<ReelData>() {
+                    @Override
+                    public void invoke(ReelData reelData, AnalysisContext analysisContext) {
+                        Map<String, Integer> boxSpecialColumn = new HashMap<>();
+                        Map<Integer, Cell> cellMap = analysisContext.readRowHolder().getCellMap();
+                        if (reelTitleMap != null && !reelTitleMap.isEmpty()) {
+                            for (Map.Entry<Integer, String> reelDateHead : reelTitleMap.entrySet()) {
+                                Integer reelTitleIndex = reelDateHead.getKey(); //坐标
+                                String reelTitle = reelDateHead.getValue(); //表头
+                                CellData cellData = (CellData) cellMap.get(reelTitleIndex);
+                                if (cellData != null && cellData.getNumberValue() != null) {
+                                    boxSpecialColumn.put(reelTitle, cellData.getNumberValue().intValue());
+                                }
+                            }
+                        }
+                        if (boxSpecialColumn != null && !boxSpecialColumn.isEmpty()) {
+                            reelData.setBoxSpecialColumn(boxSpecialColumn);
+                        }
+                        if (reelData.isValid()) {
+                            log.info("加载到盘{}数据", reelData.getReelSizeStr());
+                            reelDataMap.put(reelData.getReelSizeStr(), reelData);
+                        } else {
+                            log.error("料仓表第{}行数据{}异常,忽略", analysisContext.getCurrentRowNum(), reelData.getReelSizeStr());
+                        }
+                    }
+
+                    @Override
+                    public void doAfterAllAnalysed(AnalysisContext analysisContext) {
+                        log.info("料盘数据加载完成,共加载" + reelDataMap.size() + "条有效数据");
+                    }
+
+                    @Override
+                    public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
+                        reelTitleMap.putAll(headMap);
+                    }
+                }).build();
+                // 这里注意 一定要把sheet1 sheet2 一起传进去，不然有个问题就是03版的excel 会读取多次，浪费性能
+                excelReader.read(readSheet1, readSheet2);
+            }
+        } catch (FileNotFoundException e) {
+            log.error("未找到数据文件", e);
+        } catch (Exception ex) {
+            log.error("读取数据异常", ex);
+        }
+    }
+
+    public static Collection<BoxData> getBoxDataList() {
+        return boxDataMap.values();
+    }
+
+    public static BoxData getBoxData(String boxName) {
+        return boxDataMap.get(boxName);
+    }
+
+    public static Collection<ReelData> getReelDataList() {
+        return reelDataMap.values();
+    }
+
+    public static ReelData getReelData(String boxName) {
+        return reelDataMap.get(boxName);
+    }
+}

src/main/java/com/neotel/webbox/capacitynew/method/AssignMethod.java

+package com.neotel.webbox.capacitynew.method;
+
+
+import com.neotel.webbox.capacitynew.bean.BoxData;
+import com.neotel.webbox.capacitynew.bean.BoxResult;
+import com.neotel.webbox.capacitynew.bean.ReelData;
+import com.neotel.webbox.capacitynew.bean.RequestItem;
+import com.neotel.webbox.capacitynew.box.Box;
+import com.neotel.webbox.capacitynew.box.Column;
+import com.neotel.webbox.capacitynew.box.SlotUnit;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+
+import static com.neotel.webbox.capacitynew.method.BasicMethod.*;
+
+@Slf4j
+public class AssignMethod {
+    public static BoxResult averageCapacityToBox(BoxData boxData, List<RequestItem> requestList) {
+        //最大的压紧张开高度
+        int maxPressHeight = 0;
+        //剩余放置料盘的总高度
+        int totalRemainNeedHeight = 0;
+        //是否只有一种料需求
+        boolean onlyOneRequest = requestList.size() == 1;
+        for (RequestItem requestItem : requestList) {
+            ReelData rd = requestItem.getReelData();
+            //纯放此料盘料仓容量
+            int pureBoxCapacity = boxData.getBoxPureSizeCapacity(requestItem.getReelData());
+            int pureBoxCount = requestItem.getNum() / pureBoxCapacity;
+            int remainNum = requestItem.getNum() % pureBoxCapacity;
+            if (onlyOneRequest) {
+                log.info("只有一种规格物料,使用纯料仓");
+                if (remainNum > 0) {
+                    remainNum = 0;
+                    pureBoxCount = pureBoxCount + 1;
+                }
+            }
+            requestItem.setPureBoxCount(pureBoxCount);
+            requestItem.setRemainNum(remainNum);
+            log.info("料盘[" + rd.getReelSizeStr() + "]总需求:" + requestItem.getNum() + "需要纯料仓" + pureBoxCount + "个,每个料仓可放:" + pureBoxCapacity + "盘,剩余:" + remainNum + "盘需要放到混合仓");
+
+            totalRemainNeedHeight = totalRemainNeedHeight + requestItem.getRemainNeedHeight();
+            if (rd.getPressHeight() > maxPressHeight) {
+                maxPressHeight = rd.getPressHeight();
+            }
+        }
+
+        List<Box> mixBoxList = new ArrayList<>();
+        //判断是否需要混合仓
+        if (!onlyOneRequest) {
+            //获取到料仓可用数量
+            int mixBoxTotalValidHeight = boxData.getTotalValidHeight(maxPressHeight, requestList);
+            //估算混合仓数量
+            Float estimateMixBoxCount =   totalRemainNeedHeight / (mixBoxTotalValidHeight * 1.1f);
+            int mixBoxCount = estimateMixBoxCount.intValue();
+            if (estimateMixBoxCount - mixBoxCount > 0) {
+                mixBoxCount = mixBoxCount + 2;
+            }
+            log.info("剩余物料需要 " + mixBoxCount + " 个混合仓");
+            for (int i = 1; i <= mixBoxCount; i++) {
+                mixBoxList.add(Box.newBox(boxData, requestList, maxPressHeight));
+            }
+            //从需求大到小排序,优先满足大需求
+            requestList.sort((o1, o2) -> o2.getNum() - o1.getNum());
+            //正常列可用高度
+            int columnValidHeight = boxData.getColumnValidHeight(maxPressHeight);
+            //标准列
+            Column column = new Column(columnValidHeight);
+            //先每列均分,如果有剩余,安排到料仓口的上下位置
+            for (RequestItem requestItem : requestList) {
+                int totalRemainNum = requestItem.getRemainNum();  //剩余料盘的数量
+                int totalColumn = mixBoxList.size() * boxData.getColumnCount(); //标准列总数
+                int countPerColumn = totalRemainNum / totalColumn; //每列填充的数量
+                int assignReelCount = 0;
+                if (requestItem.getReelData().is7Reel()) {
+                    //7寸盘会填充,这里不需要填充
+                    countPerColumn = countPerColumn / 2 * 2;
+                }
+                SlotUnit slotUnit = getValidSlotUnit(countPerColumn, requestItem.getReelData(), column.getRemainHeight());
+                slotUnit = column.addSlotUnit(slotUnit);
+                //为null表示一个没填充进去, 不为null可能只填充了一部分
+                if (slotUnit != null) {
+                    assignReelCount = slotUnit.getReelCount() * totalColumn;
+                    log.info("添加" + assignReelCount + "个" + requestItem.getReelSizeStr() + "料盘到标准列,每列" + slotUnit.getReelCount() + "个料盘");
+                }
+                //没有安排的料盘,安排到特殊列
+                int notArrangedNum = totalRemainNum - assignReelCount;
+                for (Box box : mixBoxList) {
+                    Map<String, Column> specialColumnMap = box.getSpecialColumnMap();
+                    if (specialColumnMap != null && specialColumnMap.size() > 0) {
+                        for (Map.Entry<String, Column> entry : specialColumnMap.entrySet()) {
+                            SlotUnit singleSpecialColumnAddUnit = getValidSlotUnit(notArrangedNum, requestItem.getReelData(), entry.getValue().getRemainHeight());
+                            singleSpecialColumnAddUnit = entry.getValue().addSlotUnit(singleSpecialColumnAddUnit);
+                            if (singleSpecialColumnAddUnit != null) {
+                                log.info("添加" + singleSpecialColumnAddUnit.getReelCount() + "个" + requestItem.getReelSizeStr() + "料盘到" + entry.getKey());
+                                notArrangedNum = notArrangedNum - singleSpecialColumnAddUnit.getReelCount();
+                            }
+                        }
+                    }
+
+                    Map<String, Column> specialColumnUpMap = box.getSpecialColumnUpMap();
+                    if (specialColumnUpMap != null && specialColumnUpMap.size() > 0) {
+                        for (Map.Entry<String, Column> entry : specialColumnUpMap.entrySet()) {
+                            SlotUnit singleSpecialColumnUpAddUnit = getValidSlotUnit(notArrangedNum, requestItem.getReelData(), entry.getValue().getRemainHeight());
+                            singleSpecialColumnUpAddUnit = entry.getValue().addSlotUnit(singleSpecialColumnUpAddUnit);
+                            if (singleSpecialColumnUpAddUnit != null) {
+                                log.info("添加" + singleSpecialColumnUpAddUnit.getReelCount() + "个" + requestItem.getReelSizeStr() + "料盘到" + entry.getKey());
+                                notArrangedNum = notArrangedNum - singleSpecialColumnUpAddUnit.getReelCount();
+                            }
+                        }
+                    }
+                }
+                requestItem.setRemainNum(notArrangedNum);
+                if (notArrangedNum > 0) {
+                    //还有未安排的料盘,如果标准列有位置就添加进去,如果没有那就是放不下了
+                    log.warn("" + notArrangedNum + "个" + requestItem.getReelSizeStr() + "无处安放");
+                }
+            }
+
+            //填充料盘(需求数量最多的)
+            RequestItem fillRequestItem = null;
+            //用剩余的空间去放还未满足的料盘
+            for (RequestItem requestItem : requestList) {
+                if (fillRequestItem == null || requestItem.getNum() > fillRequestItem.getNum()) {
+                    fillRequestItem = requestItem;
+                }
+                int remainNum = requestItem.getRemainNum();
+                int addCount = fillToColumn(column, remainNum, requestItem.getReelData());
+                if (addCount > 0) {
+                    remainNum = remainNum - addCount;
+                    requestItem.setRemainNum(remainNum);
+                    log.info("添加" + addCount + "个" + requestItem.getReelSizeStr() + "料盘到标准列,无处安放料盘数为:" + remainNum);
+                }
+                if (remainNum > 0) {
+                    for (Box box : mixBoxList) {
+                        Map<String, Column> specialColumnMap = box.getSpecialColumnMap();
+                        if (specialColumnMap != null && specialColumnMap.size() > 0) {
+                            if (specialColumnMap != null && specialColumnMap.size() > 0) {
+                                for (Map.Entry<String, Column> entry : specialColumnMap.entrySet()) {
+                                    addCount = fillToColumn(entry.getValue(), remainNum, requestItem.getReelData());
+                                    if (addCount > 0) {
+                                        remainNum = remainNum - addCount;
+                                        requestItem.setRemainNum(remainNum);
+                                        log.info("添加" + addCount + "个" + requestItem.getReelSizeStr() + "料盘到" + entry.getKey() + ",无处安放料盘数为:" + remainNum);
+                                    }
+                                }
+                            }
+                        }
+
+                        Map<String, Column> specialColumnUpMap = box.getSpecialColumnUpMap();
+                        if (specialColumnUpMap != null && specialColumnUpMap.size() > 0) {
+                            if (specialColumnUpMap != null && specialColumnUpMap.size() > 0) {
+                                for (Map.Entry<String, Column> entry : specialColumnUpMap.entrySet()) {
+                                    addCount = fillToColumn(entry.getValue(), remainNum, requestItem.getReelData());
+                                    if (addCount > 0) {
+                                        remainNum = remainNum - addCount;
+                                        requestItem.setRemainNum(remainNum);
+                                        log.info("添加" + addCount + "个" + requestItem.getReelSizeStr() + "料盘到" + entry.getKey() + ",无处安放料盘数为:" + remainNum);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            //进行填充
+            int fillCount = fillToColumn(column, -1, fillRequestItem.getReelData());
+            if (fillCount > 0) {
+                log.info("填充" + fillCount + "个" + fillRequestItem.getReelSizeStr() + "料盘到标准列,标准列空闲高度为:" + column.getRemainHeight());
+            } else {
+                log.info("标准列空闲高度为: " + column.getRemainHeight() + " ");
+            }
+            for (Box box : mixBoxList) {
+                Map<String, Column> specialColumnUpMap = box.getSpecialColumnUpMap();
+                if (specialColumnUpMap != null && specialColumnUpMap.size() > 0) {
+                    for (Map.Entry<String, Column> entry : specialColumnUpMap.entrySet()) {
+                        fillCount = fillToColumn(entry.getValue(), -1, fillRequestItem.getReelData());
+                        if (fillCount > 0) {
+                            log.info("填充" + fillCount + "个" + fillRequestItem.getReelSizeStr() + "料盘到" + entry.getKey() + "上方列,其空闲高度为:" + entry.getValue().getRemainHeight());
+                        } else {
+                            log.info("门口上方列空闲高度为:" + entry.getValue().getRemainHeight() + " ");
+                        }
+                    }
+                }
+
+                Map<String, Column> specialColumnMap = box.getSpecialColumnMap();
+                if (specialColumnMap != null && specialColumnUpMap.size() > 0) {
+                    for (Map.Entry<String, Column> entry : specialColumnMap.entrySet()) {
+                        fillCount = fillToColumn(entry.getValue(), -1, fillRequestItem.getReelData());
+                        if (fillCount > 0) {
+                            log.info("填充" + fillCount + "个" + fillRequestItem.getReelSizeStr() + "料盘到" + entry.getKey() + ",其空闲高度为:" + entry.getValue().getRemainHeight());
+                        } else {
+                            log.info("门口上方列空闲高度为:" + entry.getValue().getRemainHeight() + " ");
+                        }
+                    }
+                }
+            }
+            for (Box box : mixBoxList) {
+                box.setColumn(column);
+                box.setColumnCount(boxData.getColumnCount());
+            }
+        }
+        return getBoxResult(requestList, boxData, mixBoxList);
+    }
+}

src/main/java/com/neotel/webbox/capacitynew/method/BasicMethod.java

+package com.neotel.webbox.capacitynew.method;
+
+import com.neotel.webbox.capacitynew.bean.*;
+import com.neotel.webbox.capacitynew.box.Box;
+import com.neotel.webbox.capacitynew.box.Column;
+import com.neotel.webbox.capacitynew.box.SlotUnit;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class BasicMethod {
+
+    protected static SlotUnit getValidSlotUnit(int requestReelCount, ReelData reelData, int validHeight) {
+        if (requestReelCount <= 0) {
+            return null;
+        }
+        //剩余空间可放多少层料格
+        int slotCount = validHeight / reelData.getReelSlotHeight();
+        if (slotCount < reelData.getMinUnit()) {
+            //可放料格层数不到一个模组
+            return null;
+        }
+        int validReelCount = slotCount;
+        if (reelData.is7Reel()) {
+            validReelCount = validReelCount * 2;
+        }
+
+        if (validReelCount >= requestReelCount) {
+            //可以全部放下
+            return new SlotUnit(reelData, requestReelCount);
+        }
+        //只可以放下部分
+        return new SlotUnit(reelData, validReelCount);
+    }
+
+    protected static int fillToColumn(Column column, int remainCount, ReelData reelData) {
+        if (remainCount > 0 || remainCount == -1) {
+            //剩余空间可放多少层料格
+            int slotCount = column.getRemainHeight() / reelData.getReelSlotHeight();
+            if (remainCount != -1 && slotCount > remainCount) {
+                slotCount = remainCount;
+            }
+            SlotUnit existSlotUnit = column.getSlotUnit(reelData);
+            int existCount = 0;
+            if (existSlotUnit == null) {
+                //不存在同尺寸料格,需要判断最小模组
+                if (slotCount < reelData.getMinUnit()) {
+                    //可放料格层数不到一个模组,尝试扩展已存在的料盘
+                    return 0;
+                }
+            } else {
+                existCount = existSlotUnit.getReelCount();
+            }
+
+            int reelCount = slotCount;
+            if (reelData.is7Reel()) {
+                reelCount = reelCount * 2;
+            }
+            SlotUnit newSlotUnit = new SlotUnit(reelData, reelCount);
+            SlotUnit mergeSlotUnit = column.mergeSlotUnit(newSlotUnit);
+            if (mergeSlotUnit != null) {
+                int addCount = mergeSlotUnit.getReelCount() - existCount;
+                return addCount;
+            }
+        }
+        return 0;
+    }
+
+    protected static Column getPureColumn(int validHeight, BoxData boxData, ReelData reelData, int pureCapacity) {
+        Column column = new Column(validHeight);
+        column.setRemainHeight(0);
+        List<SlotUnit> slotUnitList = new ArrayList<>();
+        SlotUnit unit = new SlotUnit(reelData, pureCapacity);
+        slotUnitList.add(unit);
+        column.setSlotUnitList(slotUnitList);
+        return column;
+    }
+
+    protected static BoxResult getBoxResult(List<RequestItem> requestList, BoxData boxData, List<Box> mixBoxList) {
+        List<Box> boxes = new ArrayList<>();
+        for (RequestItem requestItem : requestList) {
+            ReelData reelData = requestItem.getReelData();
+            int pressHeight = reelData.getPressHeight();
+            for (int i = 0; i < requestItem.getPureBoxCount(); i++) {
+                Box box = new Box();
+
+                box.setColumnCount(boxData.getColumnCount());
+                int standColumnValidHeight = boxData.getColumnValidHeight(pressHeight); //标准列可用高度
+                int pureColumnCapacity = boxData.getColumnPureSizeCapacity(standColumnValidHeight,reelData.getReelSize(),reelData.getReelSlotHeight()); //可放入数量
+                Column standColumn = getPureColumn(standColumnValidHeight, boxData, reelData, pureColumnCapacity);
+                box.setColumn(standColumn);
+
+                //获取特殊列与特殊列上部的值
+                Map<String, Column> specialColumnMap = new HashMap<>();
+                Map<String, Column> specialColumnUpMap = new HashMap<>();
+                Map<String, List<BoxSpecialColumnContent>> boxSpecialColumnMap = boxData.getBoxSpecialColumnMap();
+                if (boxSpecialColumnMap != null && boxSpecialColumnMap.size() > 0) {
+                    boxSpecialColumnMap = boxData.boxFillSpecialColumnHeight(boxSpecialColumnMap, reelData);
+                    for (Map.Entry<String, List<BoxSpecialColumnContent>> entry : boxSpecialColumnMap.entrySet()) {
+                        String boxSpecialColumnTitle = entry.getKey();
+                        //特殊列
+                        List<BoxSpecialColumnContent> boxSpecialColumnContentList = entry.getValue();
+                        int boxSpecialColumnValidHeight = boxData.getBoxSingleSpecialColumnHeight(boxSpecialColumnContentList);
+                        int boxSingleSpecialColumnCapacity = boxData.getColumnPureSizeCapacity(boxSpecialColumnValidHeight, reelData.getReelSize(),reelData.getReelSlotHeight());
+                        Column specialColumn = getPureColumn(boxSpecialColumnValidHeight, boxData, reelData, boxSingleSpecialColumnCapacity);
+                        specialColumnMap.put(boxSpecialColumnTitle, specialColumn);
+                        //特殊列上部
+                        int boxSingleSpecialColumnUpValidHeight = boxData.getBoxSingleSpecialColumnUpValidHeight(boxSpecialColumnContentList, reelData.getPressHeight());
+                        int boxSingleSpecialColumnUpCapacity = boxData.getColumnPureSizeCapacity(boxSingleSpecialColumnUpValidHeight, reelData.getReelSize(), reelData.getReelSlotHeight());
+                        Column specialColumnUp = getPureColumn(boxSingleSpecialColumnUpValidHeight, boxData, reelData, boxSingleSpecialColumnUpCapacity);
+                        specialColumnUpMap.put(boxSpecialColumnTitle, specialColumnUp);
+                    }
+                }
+                box.setSpecialColumnMap(specialColumnMap);
+                box.setSpecialColumnUpMap(specialColumnUpMap);
+                boxes.add(box);
+            }
+        }
+
+        for (Box box : mixBoxList) {
+            boxes.add(box);
+        }
+        BoxResult boxResult = new BoxResult();
+        boxResult.setBoxList(boxes);
+        boxResult.setRequestList(requestList);
+        return boxResult;
+    }
+}

src/main/java/com/neotel/webbox/util/NumberUtil.java

+package com.neotel.webbox.util;
+
+import java.math.BigDecimal;
+import java.util.regex.Pattern;
+
+public class NumberUtil {
+
+    /**
+     * 判断是否为整数,使用异常方式
+     * @param str
+     * @return
+     */
+    public static boolean isInteger(String str) {
+        try{
+            int i = (int) Double.parseDouble(str);
+            return true;
+        }catch (Exception e){
+            return false;
+        }
+    }
+}