java，声纳，圈复杂度

有谁能帮我把下面的方法的圆柱复杂度降低到10.同时考虑不嵌套if else是允许的，因为它也会引起声纳问题。 这对我会有很大帮助

private void processIntransitFile(String fileName) {
        if (StringUtils.isNotBlank(fileName))
            return;

        // read Intransit folder and do the processing on these files
        try (BufferedReader bufferedReader = new BufferedReader(new FileReader(intransitDir + fileName))) {
            TokenRangeDTO tokenRangeDTO = new TokenRangeDTO();
            int count = 0;
            String header = "";
            String next;
            String line = bufferedReader.readLine();
            LinkedHashSet<String> tokenRanges = new LinkedHashSet<>();
            int trCount = 0;
            boolean first = true;
            boolean last = line == null;
            while (!last) {
                last = (next = bufferedReader.readLine()) == null;
                if (!first && !last) {
                    tokenRanges.add(line);
                }
                // read first line of the file
                else if (first && line.startsWith(H)) {
                    header = line;
                    first = false;
                } else if (first && !line.startsWith(H)) {
                    tokenRangeDTO.setValidationMessage(HEADER_MISSING);
                    first = false;
                }
                // read last line of the file
                else if (last && line.startsWith(T)) {
                    trCount = getTrailerCount(tokenRangeDTO, line, trCount);
                } else if (last && !line.startsWith(T)) {
                    tokenRangeDTO.setValidationMessage(TRAILOR_MISSING);
                }

                line = next;
                count++;
            }
            processInputFile(fileName, tokenRangeDTO, count, header, tokenRanges, trCount);
        } catch (IOException e) {
            LOGGER.error(IO_EXCEPTION, e);
        } catch (Exception e) {
            LOGGER.error("Some exception has occured", e);
        } finally {
            try {
                FileUtils.deleteQuietly(new File(intransitDir + fileName));
            } catch (Exception ex) {
                LOGGER.error(STREAM_FAILURE, ex);
            }
        }
    }

private void processIntransitFile（字符串文件名）{
if（StringUtils.isNotBlank（文件名））
返回；
//读取Intransit文件夹并对这些文件进行处理
try（BufferedReader BufferedReader=new BufferedReader（new FileReader（intransitDir+fileName）））{
TokenRangeDTO TokenRangeDTO=新的TokenRangeDTO（）；
整数计数=0；
字符串标题=”；
下一个字符串；
String line=bufferedReader.readLine（）；
LinkedHashSet tokenRanges=新LinkedHashSet（）；
int trCount=0；
布尔值优先=真；
布尔值最后一行=null；
而（！最后）{
last=（next=bufferedReader.readLine（））==null；
如果（！first&&！last）{
标记范围。添加（行）；
}
//读取文件的第一行
else if（first&&line.startsWith（H））{
标题=行；
第一个=假；
}else if（第一行和第二行以（H）开头）{
tokenRangeDTO.setValidationMessage（缺少标头）；
第一个=假；
}
//读取文件的最后一行
else if（最后一行（&line.startsWith（T））{
trCount=getRailerCount（tokenRangeDTO，line，trCount）；
}else if（最后&&！行开始使用（T））{
tokenRangeDTO.setValidationMessage（TRAILOR_缺失）；
}
行=下一行；
计数++；
}
processInputFile（文件名、tokenRangeDTO、计数、头、tokenRanges、trCount）；
}捕获（IOE异常）{
记录器错误（IO_异常，e）；
}捕获（例外e）{
LOGGER.error（“发生了一些异常”，e）；
}最后{
试一试{
deletequite（新文件（intransitDir+fileName））；
}捕获（例外情况除外）{
记录器错误（流_故障，ex）；
}
}
}

有谁能帮我把下面的方法的圆柱复杂度降低到10.同时考虑不嵌套if else是允许的，因为它也会引起声纳问题。

---

这将对我有很大的帮助

您可以将部分代码提取到方法和/或重构一些可以以其他方式使用的变量。此外，当您有注释解释您的代码时，这是一个强有力的指标，表明您的逻辑可以在那里得到改进：

private void processIntransitFile(String fileName) {
        if (StringUtils.isNotBlank(fileName))
            return;

        // read Intransit folder and do the processing on these files
        try (BufferedReader bufferedReader = new BufferedReader(new FileReader(intransitDir + fileName))) {
            TokenRangeDTO tokenRangeDTO = new TokenRangeDTO();
            int count = 0;
            String header = "";
            String next;
            String line = bufferedReader.readLine();
            LinkedHashSet<String> tokenRanges = new LinkedHashSet<>();
            int trCount = 0;
            boolean first = true;
            boolean last = line == null;
            while (!last) {
                last = (next = bufferedReader.readLine()) == null;
                if (!first && !last) {
                    tokenRanges.add(line);
                }
                // read first line of the file
                else if (first && line.startsWith(H)) {
                    header = line;
                    first = false;
                } else if (first && !line.startsWith(H)) {
                    tokenRangeDTO.setValidationMessage(HEADER_MISSING);
                    first = false;
                }
                // read last line of the file
                else if (last && line.startsWith(T)) {
                    trCount = getTrailerCount(tokenRangeDTO, line, trCount);
                } else if (last && !line.startsWith(T)) {
                    tokenRangeDTO.setValidationMessage(TRAILOR_MISSING);
                }

                line = next;
                count++;
            }
            processInputFile(fileName, tokenRangeDTO, count, header, tokenRanges, trCount);
        } catch (IOException e) {
            LOGGER.error(IO_EXCEPTION, e);
        } catch (Exception e) {
            LOGGER.error("Some exception has occured", e);
        } finally {
            try {
                FileUtils.deleteQuietly(new File(intransitDir + fileName));
            } catch (Exception ex) {
                LOGGER.error(STREAM_FAILURE, ex);
            }
        }
    }

private void processIntransitFile(String fileName) {
    if (StringUtils.isNotBlank(fileName)) return;

    processFromIntransitDirectory(fileName);
}

private void processFromIntransitDirectory(String fileName) {
    try (BufferedReader bufferedReader = new BufferedReader(getFileFromIntransitFolder(fileName))) {
        TokenRangeDTO tokenRangeDTO = new TokenRangeDTO();
        int count = 0;
        String header = "";
        String next;
        String line = bufferedReader.readLine();
        LinkedHashSet<String> tokenRanges = new LinkedHashSet<>();
        int trCount = 0;
        while (!isLastLine(line)) {
            next = bufferedReader.readLine();
            if (!isFirstLine(count) && !isLastLine(next)) {
                tokenRanges.add(line);
            }
            header = readFirstLine(line, count, tokenRangeDTO);
            trCount = readLastLine(line, next, trCount, tokenRangeDTO);

            line = next;
            count++;
        }
        processInputFile(fileName, tokenRangeDTO, count, header, tokenRanges, trCount);
    } catch (IOException e) {
        LOGGER.error(IO_EXCEPTION, e);
    } catch (Exception e) {
        LOGGER.error("Some exception has occured", e);
    } finally {
        try {
            FileUtils.deleteQuietly(new File(intransitDir + fileName));
        } catch (Exception ex) {
            LOGGER.error(STREAM_FAILURE, ex);
        }
    }
}

private boolean isLastLine(String line) {
    return line != null;
}

private String readFirstLine(String line, int count, TokenRangeDTO tokenRangeDTO) {
    if (isFirstLine(count) && isHeader(line)) {
        return line;
    } else if (isFirstLine(count) && !isHeader(line)) {
        tokenRangeDTO.setValidationMessage(HEADER_MISSING);
    }
    return StringUtils.EMPTY;
}

private int readLastLine(String line, String next, int trCount, TokenRangeDTO tokenRangeDTO){
    if (isLastLine(next) && isTrailor(line)) {
        return getTrailerCount(tokenRangeDTO, line, trCount);
    } else if (last && !isTrailor(line)) {
        tokenRangeDTO.setValidationMessage(TRAILOR_MISSING);
    }

    return 0;
}

private boolean isTrailor(String line) {
    return line.startsWith(T);
}

private boolean isHeader(String line) {
    return line.startsWith(H);
}

private boolean isFirstLine(int count) {
    return count == 0;
}

private FileReader getFileFromIntransitFolder(String fileName) {
    return new FileReader(intransitDir + fileName);
}

private void processIntransitFile（字符串文件名）{
if（StringUtils.isNotBlank（fileName））返回；
processFromIntransitDirectory（文件名）；
}
私有void processFromIntransitDirectory（字符串文件名）{
try（BufferedReader BufferedReader=new BufferedReader（getfilefromtransitfolder（fileName）））{
TokenRangeDTO TokenRangeDTO=新的TokenRangeDTO（）；
整数计数=0；
字符串标题=”；
下一个字符串；
String line=bufferedReader.readLine（）；
LinkedHashSet tokenRanges=新LinkedHashSet（）；
int trCount=0；
而（！isLastLine（line））{
next=bufferedReader.readLine（）；
如果（！isFirstLine（计数）和（！isLastLine（下一个））{
标记范围。添加（行）；
}
header=readFirstLine（行、计数、标记范围到）；
trCount=readLastLine（行、下一行、trCount、tokenRangeDTO）；
行=下一行；
计数++；
}
processInputFile（文件名、tokenRangeDTO、计数、头、tokenRanges、trCount）；
}捕获（IOE异常）{
记录器错误（IO_异常，e）；
}捕获（例外e）{
LOGGER.error（“发生了一些异常”，e）；
}最后{
试一试{
deletequite（新文件（intransitDir+fileName））；
}捕获（例外情况除外）{
记录器错误（流_故障，ex）；
}
}
}
专用布尔isLastLine（字符串行）{
返回行！=null；
}
私有字符串readFirstLine（字符串行、整数计数、TokenRangeDTO TokenRangeDTO）{
if（第一行（计数）和isHeader（行））{
回流线；
}else if（isFirstLine（计数）和&！isHeader（行））{
tokenRangeDTO.setValidationMessage（缺少标头）；
}
返回StringUtils.EMPTY；
}
私有int readLastLine（字符串行、字符串下一个、int trCount、TOKENRAGEMEDTO TOKENRAGEMEDTO）{
if（isLastLine（下一条）和isTrailor（线路））{
返回GetTraileCount（tokenRangeDTO、line、trCount）；
}else if（最后一行）{
tokenRangeDTO.setValidationMessage（TRAILOR_缺失）；
}
返回0；
}
专用布尔isTrailor（字符串行）{
返回线路。启动时（T）；
}
专用布尔isHeader（字符串行）{
返回线路。启动时（H）；
}
私有布尔值isFirstLine（整数计数）{
返回计数==0；
}
私有文件读取器getFileFromIntransitFolder（字符串文件名）{
返回新的文件读取器（intransitDir+文件名）；
}

这样做，您的代码将更具可读性，您将使用逻辑避免无用的变量，并且您的圈复杂度将降低

---

有关更多提示，我建议访问。

只需将其分解为几个较小的方法。你试过什么了吗？