What's New

Simplify Diagrams

Add `Simplify Diagrams` menu: Promote the public method call inside a private method up to its caller method. e.g.

public class BriefPubClass {
    public String pubMethod() {
        priMethod(true);
        return "Pub";
    }

    private void priMethod(boolean condi) {
        if (condi) {
            priMethod2();
        } else {
            priMethod3();
        }
    }

    private void priMethod2() {
        BriefCallClass briefCallClass = new BriefCallClass();
        briefCallClass.callOtherPubMethod();
        priMethod4();
    }

    private void priMethod3() {

    }

    private void priMethod4() {

    }
}

public class BriefCallClass {

    public void callOtherPubMethod() {
        System.out.println();
    }
}
                

When diagram for method `pubMethod` was generated, the original sequence diagram (left upper) show all method call in deeps, includes private methods.

`pubMethod()` --> `priMethod()` --> `priMethod2()` --> `BriefCallClass.callOtherPubMethod()`
                

When the menu 'export' > 'Simplify Diagrams' is selected, the diagram promotes the public method calls within the private method to its caller method, leaving the only public method call 'BriefCallClass.callOtherPubMethod()' as if it were called directly in 'pubMethod', and all private method calls disappear (bottom left).

This feature is suitable for people who are very concerned about calls between classes.

Java Record support

Java Record fields are treated as getters，so `Skip getters/setters` will skip the fields as well.

public record School(String name, int size) {}

public class Test {
    public void close () {
        School peking = new School("Peking", 300);
        String name = peking.name();
    }
}
                

the `peking.name()` will not draw if you choose to `Skip getters/setters` setting.

Optimized recursive calls

the recursive calls will generate one more deep.

class GFG {

    static void factors(int n, int i)
    {
        // Checking if the number is less than N
        if (i <= n) {
            if (n % i == 0) {
                System.out.print(i + " ");
            }
            // Calling the function recursively
            // for the next number
            factors(n, i + 1);
        }
    }
    // Driver code
    public static void main(String args[])
    {
        int N = 16;
        factors(N, 1);
    }
}
                

Optimized alt/loop display

fix if/loop fragment color in dark theme.

optimize graphic gaps, now it display more beautiful.

Preferred Method list

In case of `Display only project classes`, you can add method to `Preferred method list`, so the method will show in diagram.

It shows in filter manager windows.

Note: this only works in current diagram.

Hotfix

Fix NoClassDefFoundError: org/w3c/dom/svg/SVGDocument.

Alt/Loop fragment support(Beta)

Add alt/loop fragment to support generate if-else, switch, for, while fragment box.

You need opt-in the checkbox in the settings before use it. e.g.

    public void test0 () {
        if (true) {
            new Apple("Green");
            System.out.println();
        }
    }
                

will generate sequence as the image.

Regular expression support in exclude settings

When add exclude setting entry, you can use regex expression. e.g.

    `.*Builder` to filter
    `my.package.MyBuilder`,
    `java.lang.StringBuilder`
                

Be more careful when using it, sometimes regular expressions can cause some trouble, and the result is not what you expected. When you encounter problems, please delete the settings in time and try again.

Method reference support

Java method reference is supported. e.g.

    public void testA() {
        Arrays.asList("Hello", "World")
                .stream()
                .map(ClassA::getData);
    }
                

the `ClassA::getData` method reference will generate in sequence like the image.

Draw Lambda expression as sub-sequence

Lambda expression support changed, in previous version, lambda draw right after method, while as in this version lambda draw as sub-sequence. e.g.

    public void testLambda() {
        Stream.iterate(0, n -> n + 1);
    }
                

Before(gray) vs after in the image.