一文详解Java如何自动生成简单的Mermaid类图

import java.lang.reflect.accessflag;
import java.util.*;

public class classdiagramgenerator {
    private final map<class<?>, class<?>[]> realizationrelations = new hashmap<>();
    private final map<class<?>, class<?>> inheritancerelations = new hashmap<>();

    private final set<class<?>> analyzedclasses = new hashset<>();

    public static void main(string[] args) {
        classdiagramgenerator generator = new classdiagramgenerator();
        generator.convert(args).foreach(generator::analyzehierarchy);

        generator.generateclassdiagram();
        generator.generatenamemappingtable();
    }

    /**
     * convert class name to the corresponding class object
     *
     * @param classnames give class names
     * @return a list that contains corresponding class objects
     */
    private list<class<?>> convert(string[] classnames) {
        if (classnames.length == 0) {
            string hint = "please refer to below usage and specify at least one class name!";
            string usage = "usage: java classdiagramgenerator 'java.util.arraylist' 'java.util.linkedlist'";
            throw new illegalargumentexception(string.join(system.lineseparator(), hint, usage));
        }

        list<class<?>> classlist = new arraylist<>(classnames.length);
        for (string classname : classnames) {
            try {
                class<?> clazz = class.forname(classname);
                classlist.add(clazz);
            } catch (classnotfoundexception e) {
                string message = string.format("class with name=%s can't be found, please check!", classname);
                throw new runtimeexception(message);
            }
        }
        return classlist;
    }

    /**
     * generate header for mermaid class diagram
     */
    private void generateheader() {
        system.out.println("```mermaid");
        system.out.println("classdiagram");
        system.out.println();
    }

    /**
     * generate footer for mermaid class diagram
     */
    private void generatefooter() {
        system.out.println("```");
    }

    /**
     * generate main content in mermaid class diagram
     */
    private void generateclassdiagram() {
        generateheader();
        dogenerateclassdiagram();
        generatefooter();
    }

    /**
     * generate a markdown table that contains name mapping
     */
    private void generatenamemappingtable() {
        system.out.println();
        system.out.println("| 在上图中的类名/接口名 | `fully qualified name` |");
        system.out.println("| --- | --- |");
        map<string, string> classnames = new treemap<>();
        analyzedclasses.foreach(c -> {
            string simplename = c.getsimplename();
            if (classnames.containskey(simplename)) {
                string prevname = classnames.get(simplename);
                string currname = c.getname();
                string message = string.format("duplicated simple class name detected! (%s and %s have the same simple name)", prevname, currname);
                throw new illegalargumentexception(message);
            }
            classnames.put(simplename, c.getname());
        });

        classnames.foreach((simplename, name) -> {
            string row = string.format("| `%s` | `%s` |", simplename, name);
            system.out.println(row);
        });
    }

    private void dogenerateclassdiagram() {
        analyzedclasses.foreach(c -> {
            if (inheritancerelations.containskey(c)) {
                system.out.printf("%s <|-- %s%n", inheritancerelations.get(c).getsimplename(), c.getsimplename());
            }
            if (realizationrelations.containskey(c)) {
                string type = c.isinterface() ? "<|--" : "<|..";
                arrays.stream(realizationrelations.get(c)).foreach(item -> {
                    system.out.printf("%s %s %s%n", item.getsimplename(), type, c.getsimplename());
                });
            }
        });

        generatespecialclassannotation();
    }

    /**
     * this method generates annotation for
     * 1. abstract classes
     * 2. interfaces
     */
    private void generatespecialclassannotation() {
        set<class<?>> abstractclasses = new linkedhashset<>();
        set<class<?>> interfaces = new linkedhashset<>();

        analyzedclasses.foreach(c -> {
            if (c.isinterface()) {
                interfaces.add(c);
            } else if (c.accessflags().contains(accessflag.abstract)) {
                abstractclasses.add(c);
            }
        });

        if (!abstractclasses.isempty() || !interfaces.isempty()) {
            system.out.println();
            abstractclasses.foreach(c -> system.out.println("<<abstract>> " + c.getsimplename()));
            interfaces.foreach(c -> system.out.println("<<interface>> " + c.getsimplename()));
        }
    }

    private void analyzehierarchy(class<?> currclass) {
        if (!analyzedclasses.contains(currclass)) {
            analyzesuperclass(currclass);
            analyzeinterfaces(currclass);

            analyzedclasses.add(currclass);
        }
    }

    private void analyzesuperclass(class<?> currclass) {
        class<?> superclass = currclass.getsuperclass();
        if (superclass == null || superclass == object.class) {
            return;
        }
        analyzehierarchy(superclass);
        inheritancerelations.put(currclass, superclass);
    }

    private void analyzeinterfaces(class<?> currclass) {
        class<?>[] interfaces = currclass.getinterfaces();
        for (class<?> item : interfaces) {
            analyzehierarchy(item);
        }

        realizationrelations.put(currclass, interfaces);
    }
}

javac classdiagramgenerator.java

java classdiagramgenerator 'java.util.arraylist'

java classdiagramgenerator 'java.util.linkedlist'

java classdiagramgenerator 'java.util.arrays$arraylist'

java classdiagramgenerator 'java.util.list' 'java.util.set' 'java.util.deque'

java classdiagramgenerator 'java.util.hashmap' 'java.util.linkedhashmap' 'java.util.concurrent.concurrenthashmap'

java classdiagramgenerator 'java.util.immutablecollections$set12' 'java.util.immutablecollections$setn'

java classdiagramgenerator 'java.util.jumboenumset' 'java.util.regularenumset'

java classdiagramgenerator 'java.util.concurrent.threadpoolexecutor'