Java判斷磁盤空間和分區(qū)表是否需要清理

更新時(shí)間：2025年07月29日 09:12:14 作者：yuanzhengme

這篇文章主要為大家詳細(xì)介紹了如何使用Java編寫一個(gè)工具類,可以判斷磁盤空間和分區(qū)表是否需要清理,感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下

1.依賴

        <!--hutool工具箱-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.6.6</version>
        </dependency>

2.核心代碼

根據(jù)路徑獲取磁盤空間數(shù)據(jù)

  /**
     * 根據(jù)路徑獲取磁盤空間數(shù)據(jù)
     *
     * @param path 路徑
     * @return 磁盤空間數(shù)據(jù)
     */
    public Map<String, Object> queryDiskSpaceDataByPath(String path) {
        File file = new File(path);
        long totalSpace = file.getTotalSpace();
        long freeSpace = file.getFreeSpace();
        long freeSpaceLong = freeSpace / 1024 / 1024 / 1024;
        long totalSpaceLong = totalSpace / 1024 / 1024 / 1024;
        double freeRate = 0.0;
        if (totalSpaceLong > 1) {
            freeRate = freeSpaceLong * 1.0 / totalSpaceLong * 100;
        }
        // 數(shù)據(jù)封裝
        Map<String, Object> diskDataMap = new HashMap<>(4);
        diskDataMap.put("path", path);
        diskDataMap.put("diskSpace", "磁盤剩余及總大小[" + freeSpaceLong + "G/" + totalSpaceLong + "G]");
        diskDataMap.put("diskUsageRate", "磁盤剩余率[" + String.format("%.2f", freeRate) + "%]");
        return diskDataMap;
    }

根據(jù)參數(shù)判斷當(dāng)前表是否需要清理分區(qū)

    /**
     * 根據(jù)參數(shù)判斷當(dāng)前表是否需要清理分區(qū)
     *
     * @param partitionDataMap 表的分區(qū)信息
     * @param retentionYears   存儲(chǔ)年限
     * @return 包含判斷結(jié)果的表分區(qū)信息
     */
    public boolean toDetermineIfTableNeedsToBeClearedUp(Map<String, Object> partitionDataMap, int retentionYears) {
        String partitionType = MapUtils.getString(partitionDataMap, "partitionType");
        String partitionMin = MapUtils.getString(partitionDataMap, "partitionMin");
        // 根據(jù)type獲取差值
        long differenceValue = getDateDifferenceValueByParam(partitionType, partitionMin);
        boolean isToBe = determineIfTableNeedsToBeClearedUp(partitionType, differenceValue, retentionYears);
        partitionDataMap.put("isToClearedUp", isToBe);
        return isToBe;
    }

根據(jù)參數(shù)獲取差值【跟當(dāng)前年月】

    /**
     * 根據(jù)參數(shù)獲取差值
     *
     * @param type 類型 year month day
     * @param min  最小分區(qū)值【最早分區(qū)】
     * @return 差值
     */
    private long getDateDifferenceValueByParam(String type, String min) {
        long differenceValue = 0;
        switch (type) {
            case "year":
                differenceValue = DateUtil.betweenYear(new Date(), DateUtil.parse(min, "yyyy"), false);
                break;
            case "month":
                differenceValue = DateUtil.betweenMonth(new Date(), DateUtil.parse(min, "yyyyMM"), false);
                break;
            case "day":
                differenceValue = DateUtil.betweenDay(new Date(), DateUtil.parse(min, "yyyyMMdd"), false);
                break;
            default:
                break;
        }
        return differenceValue;
    }

根據(jù)參數(shù)判斷大小【判斷差值是否大于0】

    /**
     * 根據(jù)參數(shù)判斷大小
     *
     * @param type            類型 year month day
     * @param differenceValue 差值
     * @param retentionYears  比對(duì)值
     * @return 是否大于
     */
    private boolean determineIfTableNeedsToBeClearedUp(String type, long differenceValue, int retentionYears) {
        boolean isToBe = false;
        switch (type) {
            case "year":
                isToBe = differenceValue > retentionYears;
                break;
            case "month":
                isToBe = differenceValue > (retentionYears * 12);
                break;
            case "day":
                isToBe = differenceValue > (retentionYears * 365);
                break;
            default:
                break;
        }
        return isToBe;
    }

獲取需要調(diào)整開始時(shí)間的分區(qū)【臨界分區(qū)】

    /**
     * 獲取需要調(diào)整開始時(shí)間的分區(qū)
     *
     * @param partitionDataMap 表的分區(qū)信息
     * @param retentionYears   存儲(chǔ)年限
     * @return 調(diào)整開始時(shí)間的分區(qū)
     */
    public String getAdjustmentPartitionName(Map<String, Object> partitionDataMap, int retentionYears) {
        // 解析參數(shù)
        String partitionType = MapUtils.getString(partitionDataMap, "partitionType");
        String partitionPrefix = MapUtils.getString(partitionDataMap, "partitionPrefix");
        String partitionMax = MapUtils.getString(partitionDataMap, "partitionMax");
        // 獲取需要調(diào)整的分區(qū)名稱
        String adjustmentPartition = getAdjustmentPartitionName(partitionType, partitionMax, retentionYears);
        return partitionPrefix + adjustmentPartition;
    }

生成要清理的分區(qū)列表【需要?jiǎng)h除的分區(qū)不包含臨界分區(qū)】

    /**
     * 生成要清理的分區(qū)列表
     *
     * @param partitionDataMap 表的分區(qū)信息
     * @param retentionYears   存儲(chǔ)年限
     * @return 要清理的分區(qū)列表
     */
    public List<String> getClearedUpPartitionTableNames(Map<String, Object> partitionDataMap, int retentionYears) {
        // 解析參數(shù)
        String partitionType = MapUtils.getString(partitionDataMap, "partitionType");
        String partitionMin = MapUtils.getString(partitionDataMap, "partitionMin");
        String partitionMax = MapUtils.getString(partitionDataMap, "partitionMax");
        // 獲取需要調(diào)整的分區(qū)名稱
        String adjustmentPartition = getAdjustmentPartitionName(partitionType, partitionMax, retentionYears);
        // 生成清理分區(qū)列表
        return getClearedUpListByParam(partitionType, adjustmentPartition, partitionMin);
    }

根據(jù)參數(shù)獲取調(diào)整分區(qū)名稱（調(diào)整分區(qū)的開始時(shí)間）

    /**
     * 根據(jù)參數(shù)獲取調(diào)整分區(qū)名稱（調(diào)整分區(qū)的開始時(shí)間）
     *
     * @param type           分區(qū)類型 year month day
     * @param partitionMax   最大分區(qū)
     * @param retentionYears 存儲(chǔ)年限
     * @return 需要調(diào)整的分區(qū)名稱
     */
    private String getAdjustmentPartitionName(String type, String partitionMax, int retentionYears) {
        String adjustPartitionName = "";
        switch (type) {
            case "year":
                adjustPartitionName = DateUtil.format(DateUtil.offsetDay(DateUtil.parse(partitionMax, "yyyy"), -365 * retentionYears), "yyyy");
                break;
            case "month":
                adjustPartitionName = DateUtil.format(DateUtil.offsetDay(DateUtil.parse(partitionMax, "yyyyMM"), -365 * retentionYears), "yyyyMM");
                break;
            case "day":
                adjustPartitionName = DateUtil.format(DateUtil.offsetDay(DateUtil.parse(partitionMax, "yyyyMMdd"), -365 * retentionYears), "yyyyMMdd");
                break;
            default:
                break;
        }
        return adjustPartitionName;
    }

根據(jù)參數(shù)獲取區(qū)間分區(qū)表名稱

    /**
     * 根據(jù)參數(shù)獲取區(qū)間分區(qū)表名稱
     *
     * @param type         扶你去類型 year month day
     * @param partitionMax 最大分區(qū)值
     * @param partitionMin 最小分區(qū)值
     * @return 區(qū)間分區(qū)表名稱列表
     */
    private List<String> getClearedUpListByParam(String type, String partitionMax, String partitionMin) {
        List<String> clearedUpList = new ArrayList<>();
        switch (type) {
            case "year":
                LocalDateTime startYear = LocalDateTime.of(Integer.parseInt(partitionMin), 1, 1, 0, 0);
                LocalDateTime endYear = LocalDateTime.of(Integer.parseInt(partitionMax), 1, 1, 0, 0);
                long numOfYearsBetween = ChronoUnit.YEARS.between(startYear, endYear) - 1;
                if (numOfYearsBetween >= 0) {
                    for (long i = 0; i <= numOfYearsBetween; i++) {
                        clearedUpList.add("p_year_" + DateUtil.format(startYear.plusYears(i), "yyyy"));
                    }
                }
                break;
            case "month":
                LocalDateTime startMonth = LocalDateTime.of(Integer.parseInt(partitionMin.substring(0, 4)), Integer.parseInt(partitionMin.substring(4)), 1, 0, 0);
                LocalDateTime endMonth = LocalDateTime.of(Integer.parseInt(partitionMax.substring(0, 4)), Integer.parseInt(partitionMax.substring(4)), 1, 0, 0);
                long numOfMonthsBetween = ChronoUnit.MONTHS.between(startMonth, endMonth) - 1;
                if (numOfMonthsBetween >= 0) {
                    for (long i = 0; i <= numOfMonthsBetween; i++) {
                        clearedUpList.add("p_month_" + DateUtil.format(startMonth.plusMonths(i), "yyyyMM"));
                    }
                }
                break;
            case "day":
                LocalDateTime startDay = LocalDateTime.of(Integer.parseInt(partitionMin.substring(0, 4)), Integer.parseInt(partitionMin.substring(4, 6)), Integer.parseInt(partitionMin.substring(6)), 0, 0);
                LocalDateTime endDay = LocalDateTime.of(Integer.parseInt(partitionMax.substring(0, 4)), Integer.parseInt(partitionMax.substring(4, 6)), Integer.parseInt(partitionMax.substring(6)), 0, 0);
                long numOfDaysBetween = ChronoUnit.DAYS.between(startDay, endDay) - 1;
                if (numOfDaysBetween >= 0) {
                    for (long i = 0; i <= numOfDaysBetween; i++) {
                        clearedUpList.add("p_day_" + DateUtil.format(startDay.plusDays(i), "yyyyMMdd"));
                    }
                }
                break;
            default:
                break;
        }
        return clearedUpList;
    }