Cyclomatic Complexity Management via Function Extraction

In software development, code complexity directly impacts program quality, testability, and maintainability. This article explores the governance of cyclomatic complexity and demonstrates how extracting functions can effectively reduce complexity.

What is cyclomatic complexity? It is a metric that indicates the minimum number of test cases required to achieve full code coverage.

Why care about it? A higher cyclomatic complexity usually means lower code quality and makes testing and maintenance harder.

How to address it? Use the IDEA plugin CodeMetrics to visualize complexity, then apply function extraction to split large or complex methods into smaller, reusable units.

When to extract a function?

When a function is too long or its cyclomatic complexity is high.

When duplicate code appears.

When a distinct sub‑behaviour is needed to obtain data or make a decision.

IDEA can quickly extract a method, but developers should still design the function purposefully before extraction.

Example before extraction:

Query query = new Query();
Long id = query.getId();
if (query.isXX()) {
    // xxx
}
if (id != null) {
    // xxx
}
String res = "xxx";
System.out.println(res + id);

After extracting a helper method:

private static String getString(Query query, Long id) {
    if (query.isXX()) {
        // xxx
    }
    if (id != null) {
        // xxx
    }
    String res = "xxx";
    return res;
}

Notice that the IDE passed id as a parameter without considering whether getId() is expensive; developers must evaluate such side effects.

Dealing with loops that compute multiple variables – either split the loop into two separate loops or encapsulate related results in an object.

Handling RPC calls with possible errors – replace result‑checking logic with exceptions:

if (param.getId() == null) {
    throw new XxxException("id is null");
}
Xxx xxx = rpcService.query(param.getId());
if (xxx == null || !xxx.isSuccess()) {
    log.error("xxx");
    throw new XxxException("xxx");
}

Using return instead of break or continue can simplify loop logic:

public static boolean passAll(List
aList) {
    for (A a : aList) {
        if (a == 1) {
            return false;
        }
    }
    return true;
}

Complex boolean expressions should be extracted into well‑named helper methods:

private static boolean isOnline(A a) {
    return a != null && a.status == 1 && a.time > now();
}

Finally, function design is not only about splitting code but also about future reuse. A well‑designed function clarifies its intent, parameters, and return values, which improves code readability and reduces the risk of “spaghetti” code during later feature additions.

The article concludes that while tools like IDEA are helpful, thoughtful function design and incremental refactoring are essential for maintaining high‑quality, maintainable code.