别再手撸架构图了!我写了个 AI 工具,把 SpringBoot 代码一键变成 Draw.io 流程图

Archify实战:用AI技能自动生成架构图并保持同步 架构图是软件项目的重要文档,但手动绘制与代码同步往往滞后,导致文档与实现脱节。要解决这一问题,需要理解AI编程助手中的技能(Skill)概念——它不同于普通插件或一次性Prompt,而是一套包含执行流程、输入输出规范与模板的结构化指令包。基于代码分析原理,技能能够自动扫描工程结构、识别服务依赖,并生成可维护的架构图,从而提升技术文档的时效性与准确性。在微服务治理、系统设计评审、代码重构等场景中,这类技能可大幅降低人工梳理成本。本文以Archify在Trae中的应用为例,介绍其安装配置、SKILL.md编写、 阅读详情

👉 这是一个或许对你有用的社群

🐱 一对一交流/面试小册/简历优化/求职解惑,欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料: 

👉这是一个或许对你有用的开源项目

国产Star破10w的开源项目,前端包括管理后台、微信小程序,后端支持单体、微服务架构

RBAC权限、数据权限、SaaS多租户、商城、支付、工作流、大屏报表、ERP、CRM、AI大模型、IoT物联网等功能:

  • 多模块:https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • 微服务:https://gitee.com/zhijiantianya/yudao-cloud

  • 视频教程:https://doc.iocoder.cn

【国内首批】支持 JDK17/21+SpringBoot3、JDK8/11+Spring Boot2双版本 

来源:blog.youkuaiyun.com/W03096934


前言

在之前的博客中,我曾介绍过一款AI驱动在线协作绘图平台——IntelliDraw(在线访问地址:https://www.intellidraw.top)。

经过持续优化与创新,IntelliDraw现已升级为一个功能更为强大的开发辅助工具,能够:

  • 基于用户上传的数据库SQL文件自动生成实体关系图(ER Diagram)

  • 支持Java Spring Boot项目代码分析,可一键上传项目ZIP包并生成完整的项目架构图,清晰展示各层级间的调用关系

  • 本次更新不仅带来了功能上的扩展,还对系统性能进行了全面优化:

  • 通过改进后端提示词(Prompt)算法,将模型调用的token消耗降低了60%

  • 引入了先进的RAG(Retrieval-Augmented Generation)功能

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

技术实现

Spring Boot 项目解析

使用了 JavaParser 库实现的 Java 类的解析,maven 依赖如下

<!-- Source: https://mvnrepository.com/artifact/com.github.javaparser/javaparser-core -->
<dependency>
    <groupId>com.github.javaparser</groupId>
    <artifactId>javaparser-core</artifactId>
    <version>3.25.8</version>
    <scope>compile</scope>
</dependency>
<dependency>
    <groupId>com.github.javaparser</groupId>
    <artifactId>javaparser-symbol-solver-core</artifactId>
    <version>3.25.8</version>
    <scope>compile</scope>
</dependency>

通过JavaParser库解析Java代码,生成抽象语法树(AST),以便分析Spring Boot项目的结构和依赖关系。AST是计算机理解代码的逻辑结构,类似于将代码分解为语法节点。

例如,int x = 10 + 10;的AST包括变量声明、赋值和加法运算节点。解析整个项目时,需识别包、类、方法、字段、注解及依赖关系,特别是Spring Bean的注解。生成项目架构图时,AST需包含模块划分、层次结构、依赖关系和调用链路,以展示项目的组织和功能流程。

抽象语法树(AST)的定义与作用

抽象语法树(AST)是编程语言源代码的抽象语法结构的树形表示。它帮助计算机理解代码的结构,使代码能够被分析和处理。AST忽略了代码中的语法细节,专注于代码的逻辑结构。

AST示例解析

1.加法运算的AST结构

代码:int x = 10 + 10;

AST分解:

  • 变量声明节点:int x

  • 赋值操作节点:=

  • 加法运算节点:+,包含两个子节点10和10

2.If语句的AST结构 代码:if (a > 10) { break; }

AST分解:

  • 条件判断节点:if

  • 条件表达式节点:a > 10

  • 代码块节点:break;

JavaParser在Spring Boot项目中的应用

使用JavaParser库解析整个Spring Boot项目时,需要解析以下内容:

3.包和类结构

  • 包名

  • 类名

  • 类的修饰符(如public、final)

4.类成员

  • 方法: 包括方法名、参数、返回类型、访问修饰符

  • 字段: 包括字段名、类型、访问修饰符

5.注解

  • 特别是Spring相关的注解,如@Component、@Service、@Autowired等,用于识别Spring Bean及其依赖关系

6.依赖关系

  • 通过注解和依赖注入机制,解析类之间的依赖关系,如@Autowired注入的字段或方法参数

7.调用关系

  • 分析方法之间的调用,构建方法调用链路

生成项目架构图所需的AST特征

为了生成清晰的项目架构图,AST需要包含以下信息:

8.模块划分

  • 根据包名或注解信息,将项目划分为不同的模块或层(如Controller、Service、Repository)

9.层次结构

  • 展示模块之间的层次关系,如分层架构(表现层、业务逻辑层、数据访问层)

10.依赖关系

  • 通过注解和依赖注入信息,展示类之间的依赖关系,帮助识别高耦合模块

11.调用链路

  • 展示方法之间的调用顺序,帮助理解功能流程

12.接口和实现

  • 展示接口与其实现类之间的关系,帮助理解抽象与具体实现的对应

这里我设计了几个通用的 DTO

package com.wfh.drawio.core.model;

import lombok.Data;
import java.util.List;

/**
 * 1. 架构图中的“节点” (比如一个类、一个表、一个微服务)
 * @author fenghuanwang
 */
@Data
publicclass ArchNode {
    private String id;          // 唯一标识 (e.g., "com.example.UserService")
    private String name;        // 显示名称 (e.g., "UserService")
    private String type;        // 类型 (e.g., "CLASS", "INTERFACE", "TABLE", "SERVICE")
    private String stereotype;  // 构造型/注解 (e.g., "@Controller", "@Repository")
    private List<String> fields; // 关键字段
    // 新增字段:用于存放 API 路由列表、SQL 表名或其他备注
    private String description;
    // 建议新增:用于分组(比如按包名分组,画出子图)
    private String group;
    private List<String> methods; // 关键方法
}

这个就类似于架构 图中的一个节点,或者说是一个服务。

package com.wfh.drawio.core.model;
 
import lombok.Data;
 
/**
 * 2. 架构图中的“连线” (比如继承、调用、外键)
 * @author fenghuanwang
 */
@Data
public class ArchRelationship {
    private String sourceId;    // 起点
    private String targetId;    // 终点
    private String type;        // 关系类型 (e.g., "DEPENDS_ON", "INHERITS", "CALLS", "FOREIGN_KEY")
    private String label;       // 连线上的文字 (e.g., "findUserById")
}

这个就是架构图中的连线,放到代码中就是服务之间的相互调用之类的。

/**
 * 3. 完整的分析结果
 * @author fenghuanwang
 */
@Data
public class ProjectAnalysisResult {
    private List<ArchNode> nodes;
    private List<ArchRelationship> relationships;
}

而这个就是完整的分析结果了,也就是要返回给前端的东西

那这个 Java 解析器具体代码逻辑是怎么样的呢

下面是完整的代码,这段代码是使用了 Java 的 SPI 机制实现的:

package com.wfh.drawio.spi.parser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ParserConfiguration;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.ImportDeclaration;
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
import com.github.javaparser.ast.comments.Comment;
import com.github.javaparser.ast.expr.AnnotationExpr;
import com.github.javaparser.ast.type.ClassOrInterfaceType;
import com.github.javaparser.symbolsolver.JavaSymbolSolver;
import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
import com.wfh.drawio.core.model.ArchNode;
import com.wfh.drawio.core.model.ArchRelationship;
import com.wfh.drawio.core.model.ProjectAnalysisResult;
import com.wfh.drawio.spi.LanguageParser;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Title: JavaSpringParser
 * @Author wangfenghuan
 * @description: 极致优化的 Spring Boot 项目解析器 (支持 Javadoc 提取)
 */
@Slf4j
publicclass JavaSpringParser implements LanguageParser {

    privatestaticfinal Map<String, String> STEREOTYPE_MAPPING = Map.of(
            "RestController", "API Layer",
            "Controller", "API Layer",
            "Service", "Business Layer",
            "Repository", "Data Layer",
            "Mapper", "Data Layer",
            "Component", "Infrastructure",
            "Configuration", "Infrastructure",
            "Entity", "Data Layer",
            "Table", "Data Layer"
    );

    privatestaticfinal Set<String> IGNORED_SUFFIXES = Set.of(
            "Test", "Tests", "DTO", "VO", "Request", "Response", "Exception", "Constant", "Config", "Utils", "Properties"
    );

    privatestaticfinal Set<String> IGNORED_PACKAGES = Set.of(
            "java.", "javax.", "jakarta.",
            "org.springframework.", "org.slf4j.", "org.apache.",
            "com.baomidou.", "lombok.", "com.fasterxml."
    );

    @Override
    public String getName() {
        return"Java-Spring-Doc-Enhanced";
    }

    @Override
    public boolean canParse(String projectDir) {
        Path rootPath = Paths.get(projectDir);
        if (!Files.exists(rootPath) || !Files.isDirectory(rootPath)) returnfalse;
        try (Stream<Path> stream = Files.walk(rootPath, 2)) {
            return stream.filter(Files::isRegularFile).anyMatch(p -> {
                String name = p.getFileName().toString();
                return name.equals("pom.xml") || name.equals("build.gradle") || name.equals("build.gradle.kts");
            });
        } catch (IOException e) {
            returnfalse;
        }
    }

    @Override
    public ProjectAnalysisResult parse(String projectDir) {
        log.info("Starting Analysis with Javadoc Extraction: {}", projectDir);
        JavaParser javaParser = initializeSymbolSolver(projectDir);
        List<ArchNode> rawNodes = new ArrayList<>();
        List<ArchRelationship> rawRelationships = new ArrayList<>();
        Set<String> processedClasses = new HashSet<>();

        try {
            List<Path> javaFiles = findJavaFiles(projectDir);
            for (Path javaFile : javaFiles) {
                try {
                    CompilationUnit cu = javaParser.parse(javaFile).getResult().orElse(null);
                    if (cu == null) continue;

                    String packageName = cu.getPackageDeclaration().map(pd -> pd.getNameAsString()).orElse("");

                    cu.findAll(ClassOrInterfaceDeclaration.class).forEach(clazz -> {
                        String className = clazz.getNameAsString();
                        if (isIgnoredClass(className)) return;

                        String fullClassName = getFullyQualifiedName(clazz, packageName);
                        if (processedClasses.contains(fullClassName)) return;

                        ArchNode node = analyzeClass(clazz, fullClassName);
                        if (node != null) rawNodes.add(node);

                        rawRelationships.addAll(analyzeRelationships(clazz, fullClassName, cu));
                        processedClasses.add(fullClassName);
                    });

                } catch (Exception e) {
                    log.warn("Parse error: {}", e.getMessage());
                }
            }
        } catch (IOException e) {
            log.error("IO Error", e);
        }

        return optimizeResult(rawNodes, rawRelationships);
    }

    private ArchNode analyzeClass(ClassOrInterfaceDeclaration clazz, String id) {
        ArchNode node = new ArchNode();
        node.setId(id);
        node.setName(clazz.getNameAsString());

        // 1. 提取 Javadoc 注释 (新增功能)
        String comment = extractClassComment(clazz);

        String type = "Class";
        String stereotype = "Model";

        if (clazz.isInterface()) type = "Interface";

        List<String> annotations = clazz.getAnnotations().stream().map(a -> a.getNameAsString()).collect(Collectors.toList());

        if (clazz.getNameAsString().endsWith("Mapper") || annotations.contains("Mapper")) {
            type = "Interface";
            stereotype = "Data Layer";
        }

        for (Map.Entry<String, String> entry : STEREOTYPE_MAPPING.entrySet()) {
            if (annotations.stream().anyMatch(a -> a.contains(entry.getKey()))) {
                type = entry.getKey().toUpperCase();
                stereotype = entry.getValue();
                break;
            }
        }

        node.setType(type);
        node.setStereotype(stereotype);

        // 2. 构建 Description (合并 注释 + 技术细节)
        List<String> descParts = new ArrayList<>();

        // Part A: 中文注释
        if (comment != null && !comment.isEmpty()) {
            descParts.add(comment);
        }

        // Part B: 技术细节 (API 路由 或 表名)
        if ("API Layer".equals(stereotype)) {
            List<String> routes = extractApiRoutes(clazz);
            if (!routes.isEmpty()) {
                descParts.add("APIs:\n" + String.join("\n", routes));
            }
        } elseif (clazz.getNameAsString().endsWith("Entity") || annotations.contains("TableName")) {
            extractTableName(clazz).ifPresent(t -> descParts.add("Table: " + t));
        }

        if (!descParts.isEmpty()) {
            node.setDescription(String.join("\n\n", descParts));
        }

        node.setFields(Collections.emptyList());
        node.setMethods(Collections.emptyList());

        return node;
    }

    /**
     * 新增:提取并清洗 Javadoc
     */
    private String extractClassComment(ClassOrInterfaceDeclaration clazz) {
        return clazz.getComment()
                .map(Comment::getContent)
                .map(this::cleanJavadoc)
                .orElse("");
    }

    /**
     * 清洗 Javadoc:去除 * 号、@author 等标签
     */
    private String cleanJavadoc(String content) {
        if (content == null) return"";
        String[] lines = content.split("\n");
        StringBuilder sb = new StringBuilder();

        for (String line : lines) {
            // 去除开头的 * 和空格
            String cleanLine = line.trim().replaceAll("^\\*+\\s?", "").trim();

            // 遇到 @ 标签(如 @author, @date)停止读取,或者跳过
            // 这里策略是:只读取第一段描述,遇到 @ 就停止,通常第一段是核心描述
            if (cleanLine.startsWith("@")) {
                break;
            }
            // 忽略空行
            if (!cleanLine.isEmpty()) {
                sb.append(cleanLine).append(" "); // 将多行描述合并为一行
            }
        }
        return sb.toString().trim();
    }

    private ProjectAnalysisResult optimizeResult(List<ArchNode> nodes, List<ArchRelationship> relationships) {
        Set<String> validNodeIds = nodes.stream().map(ArchNode::getId).collect(Collectors.toSet());
        List<ArchRelationship> cleanRelationships = relationships.stream()
                .filter(r -> validNodeIds.contains(r.getSourceId()) && validNodeIds.contains(r.getTargetId()))
                .filter(r -> !r.getSourceId().equals(r.getTargetId()))
                .collect(Collectors.toList());

        Set<String> connectedNodes = new HashSet<>();
        cleanRelationships.forEach(r -> {
            connectedNodes.add(r.getSourceId());
            connectedNodes.add(r.getTargetId());
        });

        List<ArchNode> cleanNodes = nodes.stream()
                .filter(n -> {
                    if ("API Layer".equals(n.getStereotype())) returntrue;
                    return connectedNodes.contains(n.getId());
                })
                .collect(Collectors.toList());

        ProjectAnalysisResult result = new ProjectAnalysisResult();
        result.setNodes(cleanNodes);
        result.setRelationships(cleanRelationships);
        return result;
    }

    private List<ArchRelationship> analyzeRelationships(ClassOrInterfaceDeclaration clazz, String sourceId, CompilationUnit cu) {
        List<ArchRelationship> rels = new ArrayList<>();
        clazz.getExtendedTypes().forEach(t -> addRel(rels, sourceId, resolveType(t, cu), "EXTENDS"));
        clazz.getImplementedTypes().forEach(t -> addRel(rels, sourceId, resolveType(t, cu), "IMPLEMENTS"));
        clazz.getFields().forEach(field -> {
            if (field.isAnnotationPresent("Autowired") || field.isAnnotationPresent("Resource") || field.isAnnotationPresent("Inject")) {
                field.getVariables().forEach(v -> addRel(rels, sourceId, resolveType(field.getElementType(), cu), "DEPENDS_ON"));
            }
        });
        clazz.getConstructors().forEach(c -> c.getParameters().forEach(p -> addRel(rels, sourceId, resolveType(p.getType(), cu), "DEPENDS_ON")));
        return rels;
    }

    private boolean isIgnoredClass(String className) {
        return IGNORED_SUFFIXES.stream().anyMatch(className::endsWith);
    }

    private boolean isIgnoredPackage(String typeName) {
        if (typeName == null) returntrue;
        return IGNORED_PACKAGES.stream().anyMatch(typeName::startsWith);
    }

    private void addRel(List<ArchRelationship> rels, String src, String target, String type) {
        if (target == null || target.equals(src) || isIgnoredPackage(target)) return;
        ArchRelationship rel = new ArchRelationship();
        rel.setSourceId(src);
        rel.setTargetId(target);
        rel.setType(type);
        rels.add(rel);
    }

    private JavaParser initializeSymbolSolver(String projectDir) {
        CombinedTypeSolver combinedSolver = new CombinedTypeSolver();
        combinedSolver.add(new ReflectionTypeSolver());
        Path srcPath = Paths.get(projectDir, "src", "main", "java");
        if (Files.exists(srcPath)) {
            combinedSolver.add(new JavaParserTypeSolver(srcPath));
        } else {
            combinedSolver.add(new JavaParserTypeSolver(new File(projectDir)));
        }
        ParserConfiguration config = new ParserConfiguration();
        config.setSymbolResolver(new JavaSymbolSolver(combinedSolver));
        returnnew JavaParser(config);
    }

    private String resolveType(ClassOrInterfaceType type, CompilationUnit cu) {
        try {
            return type.resolve().asReferenceType().getQualifiedName();
        } catch (Exception e) {
            return inferFullyQualifiedNameFromImports(type.getNameAsString(), cu);
        }
    }

    private String resolveType(com.github.javaparser.ast.type.Type type, CompilationUnit cu) {
        try {
            if (type.isClassOrInterfaceType()) return type.asClassOrInterfaceType().resolve().asReferenceType().getQualifiedName();
            returnnull;
        } catch (Exception e) {
            return inferFullyQualifiedNameFromImports(type.asString(), cu);
        }
    }

    private String inferFullyQualifiedNameFromImports(String simpleName, CompilationUnit cu) {
        Optional<ImportDeclaration> match = cu.getImports().stream()
                .filter(i -> !i.isAsterisk() && i.getNameAsString().endsWith("." + simpleName))
                .findFirst();
        if (match.isPresent()) return match.get().getNameAsString();
        String packageName = cu.getPackageDeclaration().map(pd -> pd.getNameAsString()).orElse("");
        return packageName.isEmpty() ? simpleName : packageName + "." + simpleName;
    }

    private String getFullyQualifiedName(ClassOrInterfaceDeclaration clazz, String packageName) {
        return packageName.isEmpty() ? clazz.getNameAsString() : packageName + "." + clazz.getNameAsString();
    }

    private List<String> extractApiRoutes(ClassOrInterfaceDeclaration clazz) {
        List<String> routes = new ArrayList<>();
        String basePath = "";
        Optional<AnnotationExpr> classMapping = clazz.getAnnotationByName("RequestMapping");
        if (classMapping.isPresent()) basePath = extractPath(classMapping.get());
        String finalBasePath = basePath;
        clazz.getMethods().forEach(m -> {
            Stream.of("GetMapping", "PostMapping", "PutMapping", "DeleteMapping", "RequestMapping").forEach(methodType -> {
                m.getAnnotationByName(methodType).ifPresent(ann -> {
                    String methodPath = extractPath(ann);
                    String httpMethod = methodType.replace("Mapping", "").toUpperCase();
                    if ("REQUEST".equals(httpMethod)) httpMethod = "ALL";
                    routes.add("[" + httpMethod + "] " + (finalBasePath + methodPath).replaceAll("//", "/"));
                });
            });
        });
        return routes;
    }

    private String extractPath(AnnotationExpr ann) {
        if (ann.isSingleMemberAnnotationExpr()) {
            return ann.asSingleMemberAnnotationExpr().getMemberValue().toString().replace("\"", "");
        } elseif (ann.isNormalAnnotationExpr()) {
            return ann.asNormalAnnotationExpr().getPairs().stream()
                    .filter(p -> p.getNameAsString().equals("value") || p.getNameAsString().equals("path"))
                    .findFirst().map(p -> p.getValue().toString().replace("\"", "")).orElse("");
        }
        return"";
    }

    private Optional<String> extractTableName(ClassOrInterfaceDeclaration clazz) {
        return clazz.getAnnotationByName("TableName").map(this::extractPath)
                .or(() -> clazz.getAnnotationByName("Table").map(this::extractPath));
    }

    private List<Path> findJavaFiles(String projectPath) throws IOException {
        try (Stream<Path> paths = Files.walk(Paths.get(projectPath))) {
            return paths.filter(Files::isRegularFile).filter(p -> p.toString().endsWith(".java")).collect(Collectors.toList());
        }
    }
}

SQL 语句解析

在实现SQL解析功能时,我选择了使用阿里巴巴开源的Druid(德鲁伊)项目中的SQLUtil模块。这一选择是基于Druid在SQL解析领域的强大功能和良好性能,同时其丰富的API和活跃的开源社区也为项目开发提供了有力支持。

在具体实现上,我采用了插件化(Service Provider Interface, SPI)的设计模式。通过定义统一的接口规范,

解析器代码如下

package com.wfh.drawio.spi.parser;

import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLStatement;
import com.alibaba.druid.sql.ast.statement.*;
import com.alibaba.druid.util.JdbcConstants;
import com.wfh.drawio.core.model.ArchNode;
import com.wfh.drawio.core.model.ArchRelationship;
import com.wfh.drawio.core.model.ProjectAnalysisResult;
import com.wfh.drawio.spi.LanguageParser;
import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Title: SqlParser
 * @Author wangfenghuan
 * @description: 优化版 SQL 解析器 (已修复 Lambda 变量 Final 问题)
 */
@Slf4j
publicclass SqlParser implements LanguageParser {

    privatestaticfinal Set<String> IGNORED_COLUMNS = Set.of(
            "create_time", "update_time", "create_at", "update_at",
            "created_time", "updated_time", "created_at", "updated_at",
            "is_delete", "is_deleted", "version", "revision"
    );

    @Override
    public String getName() {
        return"SQL-DDL-Enhanced";
    }

    @Override
    public boolean canParse(String projectDir) {
        File file = new File(projectDir);
        if (!file.exists()) {
            returnfalse;
        }
        if (file.isFile()) {
            return file.getName().toLowerCase().endsWith(".sql");
        }
        try (Stream<Path> paths = Files.walk(Paths.get(projectDir), 3)) {
            return paths.anyMatch(p -> p.toString().toLowerCase().endsWith(".sql"));
        } catch (IOException e) {
            returnfalse;
        }
    }

    @Override
    public ProjectAnalysisResult parse(String projectDir) {
        log.info("Starting SQL analysis: {}", projectDir);
        ProjectAnalysisResult result = new ProjectAnalysisResult();
        List<ArchNode> nodes = new ArrayList<>();
        List<ArchRelationship> relationships = new ArrayList<>();
        Set<String> tableNames = new HashSet<>();

        try {
            List<Path> sqlFiles = findSqlFiles(projectDir);
            for (Path sqlFile : sqlFiles) {
                String content = Files.readString(sqlFile);
                parseSqlContent(content, nodes, relationships, tableNames);
            }
            inferLogicalRelationships(nodes, relationships, tableNames);
        } catch (Exception e) {
            log.error("Error parsing SQL files", e);
        }

        result.setNodes(nodes);
        result.setRelationships(relationships);
        return result;
    }

    private void parseSqlContent(String content, List<ArchNode> nodes, List<ArchRelationship> relationships, Set<String> tableNames) {
        List<SQLStatement> statements = parseWithFallback(content);
        for (SQLStatement stmt : statements) {
            if (stmt instanceof SQLCreateTableStatement) {
                SQLCreateTableStatement createTable = (SQLCreateTableStatement) stmt;
                ArchNode node = processCreateTable(createTable, relationships);
                if (node != null) {
                    nodes.add(node);
                    tableNames.add(node.getId());
                }
            }
        }
    }

    private List<SQLStatement> parseWithFallback(String content) {
        try {
            return SQLUtils.parseStatements(content, JdbcConstants.MYSQL);
        } catch (Exception e1) {
            try {
                return SQLUtils.parseStatements(content, JdbcConstants.POSTGRESQL);
            } catch (Exception e2) {
                try {
                    return SQLUtils.parseStatements(content, JdbcConstants.ORACLE);
                } catch (Exception e3) {
                    return Collections.emptyList();
                }
            }
        }
    }

    private ArchNode processCreateTable(SQLCreateTableStatement createTable, List<ArchRelationship> relationships) {
        String tableName = cleanName(createTable.getTableName());
        ArchNode node = new ArchNode();
        node.setId(tableName);
        node.setName(tableName);
        node.setType("TABLE");
        node.setStereotype("Database Table");

        if (createTable.getComment() != null) {
            node.setDescription(cleanComment(createTable.getComment().toString()));
        }

        List<String> fields = new ArrayList<>();

        for (SQLTableElement element : createTable.getTableElementList()) {
            if (element instanceof SQLColumnDefinition) {
                SQLColumnDefinition column = (SQLColumnDefinition) element;
                String colName = cleanName(column.getName().getSimpleName());

                if (IGNORED_COLUMNS.contains(colName.toLowerCase())) {
                    continue;
                }

                String colType = column.getDataType().getName();
                StringBuilder fieldStr = new StringBuilder(colName).append(": ").append(colType);

                if (column.isPrimaryKey()) {
                    fieldStr.append(" (PK)");
                } elseif (createTable.findColumn(colName) != null && isPrimaryKeyInConstraints(createTable, colName)) {
                    fieldStr.append(" (PK)");
                }

                if (column.getComment() != null) {
                    String comment = cleanComment(column.getComment().toString());
                    if (!comment.isEmpty()) {
                        fieldStr.append(" // ").append(comment);
                    }
                }
                fields.add(fieldStr.toString());

            } elseif (element instanceof SQLForeignKeyConstraint) {
                SQLForeignKeyConstraint fk = (SQLForeignKeyConstraint) element;
                String targetTable = cleanName(fk.getReferencedTableName().getSimpleName());
                ArchRelationship rel = new ArchRelationship();
                rel.setSourceId(tableName);
                rel.setTargetId(targetTable);
                rel.setType("FOREIGN_KEY");
                String colName = fk.getReferencingColumns().stream()
                        .map(c -> cleanName(c.getSimpleName()))
                        .collect(Collectors.joining(","));
                rel.setLabel("FK: " + colName);
                relationships.add(rel);
            }
        }
        node.setFields(fields);
        node.setMethods(Collections.emptyList());
        return node;
    }

    /**
     * 修复点:inferLogicalRelationships 方法
     * 引入 finalTarget 变量,解决 Lambda 表达式报错
     */
    private void inferLogicalRelationships(List<ArchNode> nodes, List<ArchRelationship> relationships, Set<String> allTables) {
        for (ArchNode node : nodes) {
            if (node.getFields() == null) continue;

            for (String fieldStr : node.getFields()) {
                String colName = fieldStr.split(":")[0].trim();

                if (colName.toLowerCase().endsWith("_id")) {
                    String potentialTableName = colName.substring(0, colName.length() - 3);

                    String tempTarget = matchTable(potentialTableName, allTables);
                    if (tempTarget == null) {
                        tempTarget = matchTable(potentialTableName + "s", allTables);
                    }

                    // ✅ 关键修复:将可能变化的 tempTarget 赋值给一个 final 变量
                    String finalTarget = tempTarget;

                    if (finalTarget != null && !finalTarget.equals(node.getId())) {
                        // 在 Lambda 中只使用 finalTarget
                        boolean exists = relationships.stream().anyMatch(r ->
                                r.getSourceId().equals(node.getId()) && r.getTargetId().equals(finalTarget)
                        );

                        if (!exists) {
                            ArchRelationship rel = new ArchRelationship();
                            rel.setSourceId(node.getId());
                            rel.setTargetId(finalTarget);
                            rel.setType("LOGICAL_KEY");
                            rel.setLabel("Link: " + colName);
                            relationships.add(rel);
                        }
                    }
                }
            }
        }
    }

    private String matchTable(String guess, Set<String> tables) {
        for (String table : tables) {
            if (table.equalsIgnoreCase(guess)) return table;
        }
        returnnull;
    }

    private boolean isPrimaryKeyInConstraints(SQLCreateTableStatement table, String colName) {
        if (table.getTableElementList() == null) returnfalse;
        for (SQLTableElement element : table.getTableElementList()) {
            if (element instanceof SQLPrimaryKey) {
                SQLPrimaryKey pk = (SQLPrimaryKey) element;
                return pk.getColumns().stream().anyMatch(c -> cleanName(c.getExpr().toString()).equals(colName));
            }
        }
        returnfalse;
    }

    private String cleanName(String name) {
        if (name == null) return"";
        return name.replace("`", "").replace("\"", "").replace("'", "").trim();
    }
    private String cleanComment(String comment) {
        if (comment == null) return"";
        return comment.replace("'", "").trim();
    }
    private List<Path> findSqlFiles(String projectPath) throws IOException {
        Path startPath = Paths.get(projectPath);
        if (Files.isRegularFile(startPath) && startPath.toString().toLowerCase().endsWith(".sql")) {
            return List.of(startPath);
        }
        try (Stream<Path> paths = Files.walk(startPath)) {
            return paths
                    .filter(Files::isRegularFile)
                    .filter(path -> path.toString().toLowerCase().endsWith(".sql"))
                    .collect(Collectors.toList());
        }
    }
}

刚才定义的一系列 DTO 是对于任何的图表都适用的,因为节点和连线就是构成一个不管是结构图还有 ER 图的主要元素。

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/yudao-cloud

  • 视频教程:https://doc.iocoder.cn/video/

GitHub 仓库

前端
  • https://github.com/wangfenghuan/ai-draw-io-fronted

后端
  • https://github.com/wangfenghuan/ai-draw-io-backend


欢迎加入我的知识星球,全面提升技术能力。

👉 加入方式,“长按”或“扫描”下方二维码噢:

星球的内容包括:项目实战、面试招聘、源码解析、学习路线。

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
SpringBoot+Thymeleaf+AI大模型:校园课程推荐系统设计与实现 推荐系统是解决信息过载的核心技术,通过分析用户行为与内容特征,实现个性化资源匹配。传统协同过滤与内容推荐虽能生成候选列表,但缺乏解释性,用户往往难以理解推荐依据。随着大模型技术的成熟,将自然语言生成能力融入推荐链路,可显著提升系统的交互体验与决策辅助价值。在高校选课场景中,课程数量多、信息分散,学生需要更智能的选课辅助工具。基于SpringBoot+Thymeleaf构建的校园课程推荐系统,融合协同过滤、内容推荐与混合推荐策略,并接入AI大模型生成个性化推荐理由及智能问答,为毕设项目提供了兼具工程实践与技术 阅读详情

相关推荐

从概念到落地:AI Agent 学习路径与工程实战指南

AI Agent 并非神秘黑魔法,而是一套融合循环、记忆、工具与评估的系统工程。从大语言模型的基本原理出发,Agent 通过感知-推理-行动的循环执行复杂任务,其核心价值在于把不可控的模型输出转化为可工程化的稳定流程。在应用场景中,无论是知识库问答、Java 后端 Agent 集成,还是 AI Agent 测试实战,都需要围绕工具调用与结果评估构建闭环。对于后端团队,Spring AI 提供了与 Spring Boot 无缝对接的 Agent 客户端方案,可复用既有 Bean 作为工具;而测试层面则需要建立

aoe41606的博客 352

别再手撸架构图了!我写了个 AI 工具,把 Spring Boot 代码一键变成 Draw.io 流程图

摘要:IntelliDraw是一款AI驱动的在线协作绘图平台,现已升级为功能更强大的开发辅助工具。最新版本支持自动生成数据库ER图和Java SpringBoot项目架构图,通过改进后端算法将模型调用token消耗降低60%。技术实现上采用JavaParser库解析SpringBoot项目结构,使用Druid解析SQL文件,并采用插件化设计模式。平台提供了通用的DTO模型来构建架构图节点和关系,包括ArchNode、ArchRelationship和ProjectAnalysisResult等核心类。文章详

W03096934的博客 1366

【WSL2+Ubuntu+Docker Desktop】迁移到D盘

该篇文章包含将WSL2+ubuntu+Docker Desktop从C盘迁移到D盘

哈茶的博客 3932

SpringBoot项目基于Draw-io做的二次开发

基于Draw-io做的二次开发 draw-io是我在做一个物联网平台项目用到的技术,因为当时需求要求组态相关,所以就去网上查了一通,最后发现还是draw-io是个比较全面。并且还是开源的 下载源码后研究源代码阶段 我们对Markdown编辑器进行了一些功能拓展与语法支持,除了标准的Markdown编辑器功能,我们增加了如下几点新功能,帮助你用它写博客: 全新的界面设计 ,将会带来全新的写作体验; 在创作中心设置你喜爱的代码高亮样式,Markdown 将代码片显示选择的高亮样式 进行展示; 增加了 图片拖拽

MaZhaoLiang0201的博客 7355

GlobalPlatform Technology Secure Channel Protocol ‘03‘ 标准 - 安全通道协议简介

按照GlobalPlatform Technology Secure Channel Protocol '03' (SCP03)标准,描述了如何利用S-MAC,S-RMAC,S-ENC进行安全通信的过程。

mmmx777的专栏 6094

海鸥派OpenEuler开发板实战:从烧写到SSH连接的完整指南

本文提供海鸥派OpenEuler开发板从开箱到SSH远程连接的完整实战指南。详细介绍了基于海思SD3403/SS928芯片的算力开发板系统烧写、存储扩容、网络配置等关键步骤,帮助开发者快速上手这款AI边缘计算设备,并实现高效的远程开发与管理。

ruby5的博客 1121

我做了个 AI + 实时协作 的 draw.io,免费开源!!

摘要:本文介绍了一款基于AI和多人协作的drawio在线绘图工具Intellidraw。该项目采用Next.js+Ant Design前端技术栈实现实时协作功能,后端使用SpringBoot+SpringAI提供AI绘图能力,并通过Node.js微服务处理实时协作逻辑。主要功能包括:1)AI自然语言生成各类图表;2)多人实时协作编辑,支持权限管理。项目已开源,前端代码地址:https://github.com/wangfenghuan/smart-drawio-fronted,后端代码地址:https://

W03096934的博客 1449

编写一个程序实现顺序表的各种基本运算(假设顺序表的元数基本类型为Char)

/* *Copyright (c) 2016, 烟台大学计算机学院 *All rights reserved. *文件名称:main.cpp *作者:张旺华 *完成日期: 2016 年 7 月 1 日 *版本号:v1.0 *问题描述:编写一个程序实现顺序表的各种基本运算(假设顺序表的元数基本类型为Char) * */ #include #include #include

张旺华的博客 1万+

coral-draw:springboot drawio user 绘图工具

coral-draw:springboot drawio user 绘图工具 【下载地址】coral-drawspringbootdrawiouser绘图工具 coral-draw 是一款基于 SpringBoot 的 drawio 用户绘图工具,专为简化绘图数据存储与同步而设计。它通过浏览器存储模式自动同步 drawi...

gitblog_06741的博客 424

【模型之美】3、文本聚类与智能摘要,让AI帮你做个总结

在信息过载时代,文本聚类与摘要技术成为关键工具。本文提出了一种结合OpenAI Embedding与传统机器学习的方法,实现从文本预处理到智能分析的完整流程。技术方案分为三阶段:1)通过Embedding将文本转化为语义向量;2)采用K-Means等算法进行无监督聚类;3)利用大模型生成可解释的标签和摘要。实验证明,该方法能有效提升信息处理效率,如在新闻聚合系统中自动分类10,000篇文章,准确率较传统方法提高15%。方案包含实用代码示例,涵盖文本清洗、向量化、聚类优化等关键技术细节,可应用于对话记忆、舆情

2025博客之星Top81。专注AI工程化与架构实战。从分布式思维到模型部署,用工程化视角为你厘清AI落地的真实路径。 1444

ROS从入门到精通2-1:机器人3D可视化工具——Rviz

本文详细介绍了Rviz是什么?为什么要使用这个工具?清晰地列出了Rviz的安装流程和界面的基本功能元素;讲解了Rviz基本数据类型与话题,并用两个实例深入理解Rviz数据可视化的过程

FRIGIDWINTER的博客 5350

如何用ai画流程图

摘要:Mermaid是一款基于JavaScript的开源图表工具,通过类似Markdown的文本语法快速生成流程图、时序图等专业图表。其代码化绘图特性可与AI大模型完美结合,只需用文字清晰描述需求,AI就能输出标准的Mermaid代码。推荐使用DevToolBox等免费在线工具将代码转换为可视化图表,显著提升办公效率。该方案特别适合技术文档编写和团队协作场景。(149字)

thtwz的博客 737

2024年全国青少年信息素养大赛复赛真题(算法创意实践挑战赛C++试卷:带解析)

2024年全国青少年信息素养大赛复赛真题(算法创意实践挑战赛C++试卷:带解析)

王老师青少年编程 4792

next-ai-draw-io 让 AI 替你画架构图

基于 Next.js 构建,融合 AI 与 draw.io 的绘图能力,支持通过自然语言生成、编辑、优化流程图和架构图。GitHub 地址:https://github.com/DayuanJiang/next-ai-draw-io。-- 上传一张架构图截图,AI 帮你用 draw.io 重新画出来,可编辑。-- 描述你的系统架构,AI 直接生成 draw.io 格式的图表。的开源项目,前端包括管理后台、微信小程序,后端支持单体、微服务架构。next-ai-draw-io 的思路很直接:用对话生成架构图。

weixin_44421461的博客 123

带有HSE组件的S32系列芯片中各子系统如何依次启动?

仔细阐述了上电后各个子系统的启动顺序,并给出了详细的启动步骤流程图。

车载系统攻城狮 1704

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

毕设系统架构图一键生成,告别 Draw.io 手动拖拽绘制

系统架构图核心作用是清晰展示项目分层与组件依赖,不应该把大量时间消耗在拖拽绘图上。借助工具快速生成初稿,人工微调修正,把更多精力投入项目开发与论文正文撰写。

yangousheji的博客 195

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

AI 自动生成 SpringBoot 架构图:从代码到 Draw.io 的实践指南

在 Java 工程实践中,架构图是团队沟通与系统设计的重要载体,但代码持续演进,手动维护的架构图常常迅速过期,成为“历史文物”。如何让架构图与代码保持同步,是许多开发者和项目负责人面临的真实痛点。借助 AI 技术与静态源码解析,我们可以将 SpringBoot 项目的类结构、依赖关系和分层边界自动抽取出来,再通过结构化数据映射为可编辑的 Draw.io 流程图。这种方案不仅解决了手绘架构图滞后、风格不统一、重复劳动等问题,还能将架构图纳入 CI 流水线,实现文档随代码自动更新。从 Java 项目扫描、注解解

weixin_30545945的博客 243

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

AI 辅助 SpringBoot 代码自动生成 Draw.io 架构图:工具设计与实战

在软件工程实践中,架构图是理解系统结构、促进团队协作和保障代码质量的重要可视化载体。然而,传统手工绘制架构图的方式往往滞后于代码迭代,难以真实反映系统全貌。借助对 SpringBoot 编程模型的分析,可以识别 Controller、Service、Mapper 等核心组件及其依赖关系;引入 AI 技术则能进一步理解泛型继承、接口分离等复杂场景,提升解析准确率。通过将解析结果转化为 Draw.io 支持的 XML 格式,即可实现代码到架构图的一键生成,并支持后续人工精修与版本管理。该自动化能力广泛应用于新成

weixin_32642109的博客 76

AI工具如何提升计算机毕业设计效率与质量

人工智能技术正在重塑学术研究的工作范式,特别是在计算机领域的毕业设计环节。通过自然语言处理(NLP)和代码生成技术,AI工具能够显著提升文献调研、系统开发和论文写作的效率。以STM32嵌入式开发和SpringBoot+Vue管理系统为例,合理使用GitHub Copilot等代码生成工具可以减少40%的样板代码编写量,而Semantic Scholar等智能文献检索系统能在15分钟内建立初步文献库。这些技术不仅缩短了开发周期,还能通过自动化测试工具如Diffblue Cover提升代码质量。在学术规范方面,

weixin_33767813的博客 879

2026年AI Agent开发与运行逻辑实战:从入门到工程化落地

AI Agent开发正从概念走向工程实践,开发者对运行逻辑、工具调用和记忆设计的理解,决定了系统能否真正落地。本文从基础概念切入,拆解Agent的规划、工具、记忆与反思四大核心模块,并深入分析模型调用工具不等于Agent可用的关键卡点。结合Spring Boot Java生态、Obsidian知识库、draw.io流程工具对接等真实场景,给出企业级选型与测试评估的实操建议。面向开发团队与个人工程师,提供从入门学习到面试准备、从技术选型到生产落地的完整参考路径。

weixin_34239592的博客 325

SpringBoot3+Vue3智慧管理平台开发指南:从架构设计到AI集成实践

在信息化管理系统开发中,前后端分离与微服务架构早已成为主流思想,而Spring Boot与Vue.js的组合则凭借轻量、高效、生态完善的优势,成为众多企业级应用与毕业设计项目的首选技术栈。随着SpringBoot3基于JDK17的全面升级,以及Vue3组合式API的普及,开发者需要重新理解模块划分、权限控制与数据流设计。而AI能力的引入,更让智慧管理平台从传统CRUD跃升为具备智能问答、工单分诊、数据洞察的协同系统。本文从业务边界梳理、单体架构选择、SpringBoot3关键特性、Vue3权限路由,到AI接

weixin_30697239的博客 545

AI Agent开发趋势:从热搜词看2026年市场信号与落地实践

从大模型到智能体,技术演进正从概念讨论走向工程落地。理解Agent运行逻辑、掌握工具调用与记忆设计,成为开发者进入AI应用领域的核心能力。随着企业级生态加速渗透,Spring Boot等框架已开始承载Agent客户端,工业场景也通过数字孪生与机器人融合实现降本增效。本文基于热搜关键词,拆解ai应用开发学习路线、ai agent面试题背后的市场信号,梳理从个人工作流到工业现场的真实约束与实践路径,为开发者提供从入门到进阶的可执行参考。

weixin_34246551的博客 392

AI Agent 学习路线与实战指南:从原理到框架落地

AI Agent 是大模型应用从“被动问答”走向“主动执行”的关键形态。其核心原理是让模型在感知、决策、行动的循环中自主调用工具、规划步骤,并基于反馈修正行为。掌握这一技术价值,意味着开发者能构建具备任务拆解、记忆与反思能力的智能系统。在工程实践中,Agent 已广泛渗透到知识库问答、代码生成、Java 后端服务等场景,例如基于 Spring AI 的客户端开发,以及面向硬件设计的 Verilog 代码生成。与此同时,如何对 Agent 进行测试实战成为落地难点,需要从工具调用序列与效果评估两个维度建立体系

weixin_34297704的博客 440

计算机毕业设计AI提效方案与选题开发指南

毕业设计是计算机专业学生综合能力的集中体现,涉及系统设计、编码实现和论文撰写全流程。随着AI技术的发展,智能编程助手如GitHub Copilot和Cursor已能显著提升开发效率,通过自动生成代码框架、优化算法实现等功能,帮助开发者聚焦核心创新点。在技术选型上,SpringBoot+Vue+MySQL等成熟技术栈组合既能满足功能需求,又便于查找解决方案。本方案特别强调AI工具在需求分析、测试用例生成等环节的应用,同时提醒需保持学术规范性,所有AI生成内容必须经过人工校验和重构。

weixin_30561425的博客 316

计算机专业毕业设计选题指南与避坑技巧

毕业设计是计算机专业学生的重要实践环节,选题直接影响项目成败。从技术实现角度,管理系统类项目采用SpringBoot+Vue等技术栈成熟稳定,数据分析类项目运用Python+Pandas+Echarts实现可视化,而轻量级AI应用则需注重模型部署与降级方案。开发工具类项目以JavaScript/TypeScript为主,代码量可控且演示直观。在选题策略上,需平衡技术难度与可实现性,避免区块链等复杂领域,优先选择有明确产出和展示性的题目。通过合理规划开发周期,采用看板管理等敏捷方法,结合规范文档与流畅演示,能

weixin_30357231的博客 379

完全0基础适用!Activiti7.1 + Springboot 2.x 开发快速上手讲解,全网最全最详细(不藏私)

点击绘制界面空白处,编辑底部内容。如果不需要,则自动以文件名为准此处ID为:。也可根据自己喜好改,但是后续代码操作需要该ID!

Qensq的博客 1021
上一篇: 2026年Java资料总结!没到35k的Java开发都值得好好看一看
下一篇: Maven 4 要来了:15 年后,Java 构建工具迎来“彻底重构”
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值