Herramienta de diagrama de clases de visualización de Java (herramienta pequeña escrita a mano, no es necesario citar ningún paquete ni complemento)

Cuando estudiamos el código fuente, a menudo tenemos que verificar el diagrama de clases de una determinada clase. Aunque IDEA tiene su propia visualización del diagrama de clases, es solo la versión paga, la versión comunitaria no la admite y Eclipse no la tiene. De hecho, la función es bastante simple, así que escribí una pequeña herramienta para ver diagramas de clases para compartir con ustedes. 

Ponga las representaciones primero:

 A partir de esta representación, podemos ver claramente que la clase principal de ArrayList es AbstractList, y la interfaz principal incluye List, RandomAccess, Cloneable y Serializable. La clase padre de AbstractList es AbstractCollection, y la interfaz que implementa también tiene List, y así sucesivamente.

 Por supuesto, también es relativamente simple de usar para nosotros. Solo necesitamos llamar al método showDiagram() de la clase de herramienta y pasar la clase para que se vea.

DiagramUtils.showDiagram(ArrayList.class, true);

Si desea ver el nombre corto de la interfaz o clase, simplemente cambie el segundo parámetro a falso (el efecto es el siguiente):

 

 [Visualización del código fuente]

package com.test.inherited;

import java.util.ArrayList;
import java.util.List;

/**
 * 类图查看工具类
 *
 * @author zyq
 * @since 2021/08/18
 */
public class DiagramUtils {

    private static List<String> list = new ArrayList<>();

    public static void main(String[] args) {
        DiagramUtils.showDiagram(ArrayList.class, false);
    }

    /**
     * 打印类或接口的类图关系
     *
     * @param clazz          类或接口
     * @param isShowFullName 是否显示类全名，true-显示类全名，false-显示简名
     */
    public static void showDiagram(Class clazz, boolean isShowFullName) {
        if (clazz == null) {
            System.out.println("你没有传参");
        }
        Node node = getSupper(clazz, isShowFullName);
        if (node != null) {
            print(node, 0);
        }
        handleAll();
        for (int i = list.size() - 1; i >= 0; i--) {
            System.out.println(list.get(i).substring(4));
        }
    }

    private static void handleAll() {
        // 获取最大的层级
        int max = 1;
        for (int i = list.size() - 1; i > 0; i--) {
            int level = getLevel(list.get(i));
            if (max < level) {
                max = level;
            }
        }
        // 循环处理每层树状
        for (int i = max; i > 0; i--) {
            handle(i);
        }
    }

    private static void handle(int level) {
        // 获取该层次的所有序号
        List<Integer> rowList = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if (level == getLevel(list.get(i))) {
                rowList.add(i);
            }
        }
        if (rowList.size() <= 1) {
            return;
        }
        // 判断两个依次同层级的是否为连续
        int i = 0;
        while (i < rowList.size() - 1) {
            int num1 = rowList.get(i);
            int num2 = rowList.get(i + 1);
            i++;
            // 相邻的直接略过
            if (num1 + 1 == num2) {
                continue;
            }
            // 判断两行之间是否有阻碍，没有阻碍才连续
            boolean isOk = true;
            int levelIndex = level * 4;
            for (int j = num1; j < num2; j++) {
                String s = list.get(j);
                if (s.length() > levelIndex) {
                    char c = s.charAt(levelIndex);
                    if (c != ' ' && c != '|') {
                        isOk = false;
                    }
                }
            }
            if (isOk) {
                for (int j = num1; j < num2; j++) {
                    list.set(j, setLevel(list.get(j), level));
                }
            }
        }
    }

    private static String setLevel(String s, int level) {
        int levelIndex = level * 4;
        if (s.length() > levelIndex) {
            char[] chars = s.toCharArray();
            chars[levelIndex] = '|';
            return new String(chars);
        } else {
            int diff = levelIndex - s.length();
            for (int i = 0; i < diff - 1; i++) {
                s += " ";
            }
            return  s + "|";
        }
    }

    private static int getLevel(String s) {
        String start = "|---";
        int level = 0;
        while (level < 100) {
            level ++;
            start = "    " + start;
            if (s.startsWith(start)) {
                break;
            }
        }
        return level;
    }


    private static void print(Node node, int level) {
        String lineBlank = "";
        for (int i = level; i > 0; i--) {
            lineBlank += "    ";
        }
        String s = lineBlank + "|---" + node.getName() + " " + node.getType();
        list.add(s);
        List<Node> superList = node.getSuperList();
        if (superList.size() > 0) {
            for (Node each : superList) {
                print(each, level + 1);
            }
        }
    }

    private static Node getSupper(Class clazz, boolean isShowFullName) {
        Node node = new Node();
        if (clazz.isInterface()) {
            node.setType("(I)");
        } else {
            node.setType("(C)");
        }
        node.setName(getClassName(clazz, isShowFullName));
        Class superclass = clazz.getSuperclass();
        if (superclass != null) {
            node.getSuperList().add(getSupper(superclass, isShowFullName));
        }
        Class[] interfaces = clazz.getInterfaces();
        if (interfaces != null && interfaces.length > 0) {
            for (Class anInterface : interfaces) {
                node.getSuperList().add(getSupper(anInterface, isShowFullName));
            }
        }
        return node;
    }


    private static String getClassName(Class clazz, boolean isShowFullName) {
        return isShowFullName ? clazz.getName() : clazz.getSimpleName();
    }

    private static class Node {
        private String name;
        private String type;
        private List<Node> superList = new ArrayList<>();

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getType() {
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }

        public List<Node> getSuperList() {
            return superList;
        }
    }
}