Java实现解析build.gradle字符串提取插件与依赖的高效方案

针对解析build.gradle字符串并检查特定插件、依赖的需求，这里有几种高效的Java实现方案，各有优劣，按需选择：

1. 用Gradle官方API（最可靠） #

Gradle本身提供了解析自身DSL的能力，用官方API能完美兼容所有Gradle语法，包括动态配置、apply false的插件声明等复杂场景，是最准确的方案。

实现代码 #

import org.gradle.api.Project;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.artifacts.Dependency;
import org.gradle.testfixtures.ProjectBuilder;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;

public class GradleParser {
    // 检查是否包含指定插件（包括plugins块声明和apply plugin语句）
    public static boolean hasPlugin(String buildGradleContent, String pluginId) throws IOException {
        // 创建临时文件存储build.gradle内容
        File tempBuildFile = File.createTempFile("temp-build", ".gradle");
        Files.write(tempBuildFile.toPath(), buildGradleContent.getBytes());
        
        // 构建Project实例并加载脚本
        Project project = ProjectBuilder.builder()
                .withProjectDir(tempBuildFile.getParentFile())
                .build();
        project.apply(settings -> settings.from(tempBuildFile));
        
        // 检查插件是否已应用，同时覆盖plugins块里的声明（即使apply false）
        boolean exists = project.getPlugins().hasPlugin(pluginId);
        if (!exists) {
            // 遍历plugins块中所有声明的插件ID
            for (var plugin : project.getPlugins()) {
                if (plugin.getId().getId().equals(pluginId)) {
                    exists = true;
                    break;
                }
            }
        }
        
        tempBuildFile.delete();
        return exists;
    }

    // 检查是否包含指定依赖（支持完整坐标或group:name形式）
    public static boolean hasDependency(String buildGradleContent, String dependencyNotation) throws IOException {
        File tempBuildFile = File.createTempFile("temp-build", ".gradle");
        Files.write(tempBuildFile.toPath(), buildGradleContent.getBytes());
        
        Project project = ProjectBuilder.builder()
                .withProjectDir(tempBuildFile.getParentFile())
                .build();
        project.apply(settings -> settings.from(tempBuildFile));
        
        // 遍历所有配置（implementation、testImplementation等）检查依赖
        for (Configuration config : project.getConfigurations()) {
            for (Dependency dep : config.getDependencies()) {
                String depFullNotation = dep.getGroup() + ":" + dep.getName() + ":" + dep.getVersion();
                String depShortNotation = dep.getGroup() + ":" + dep.getName();
                
                if (depFullNotation.equals(dependencyNotation) || depShortNotation.equals(dependencyNotation)) {
                    tempBuildFile.delete();
                    return true;
                }
            }
        }
        
        tempBuildFile.delete();
        return false;
    }
}

依赖配置 #

需要在项目中引入Gradle测试相关依赖（版本建议和目标Gradle版本匹配）：

dependencies {
    implementation 'org.gradle:gradle-core:7.6'
    testImplementation 'org.gradle:gradle-test-fixtures:7.6'
}

优劣总结 #

• 优点：完全兼容Gradle所有语法，能处理动态生成的插件/依赖、变量引用等复杂场景，结果准确；
• 缺点：引入Gradle核心依赖会增加项目体积，构建Project实例的性能开销比正则略大，但日常使用足够高效。

2. 正则表达式（轻量快速） #

如果你的build.gradle结构比较简单，没有复杂的动态配置，用正则表达式是最轻量化的方案，无需额外依赖，解析速度极快。

实现代码 #

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class GradleRegexParser {
    // 匹配plugins块中的id声明（支持带apply false的情况）
    private static final Pattern PLUGIN_ID_PATTERN = Pattern.compile(
        "id\\s+(?:\"|')([a-zA-Z0-9.]+)(?:\"|')(?:\\s+apply\\s+(?:true|false))?",
        Pattern.CASE_INSENSITIVE | Pattern.MULTILINE
    );
    
    // 匹配apply plugin: 'xxx'形式的插件应用
    private static final Pattern APPLY_PLUGIN_PATTERN = Pattern.compile(
        "apply\\s+plugin:\\s+(?:\"|')([a-zA-Z0-9.]+)(?:\"|')",
        Pattern.CASE_INSENSITIVE | Pattern.MULTILINE
    );
    
    // 匹配dependencies块中的依赖声明（覆盖常见配置类型）
    private static final Pattern DEPENDENCY_PATTERN = Pattern.compile(
        "(?:implementation|testImplementation|compileOnly|runtimeOnly|api)\\s+(?:\"|')([a-zA-Z0-9.:-]+)(?:\"|')",
        Pattern.CASE_INSENSITIVE | Pattern.MULTILINE
    );
    
    public static boolean hasPlugin(String buildGradleContent, String pluginId) {
        // 检查plugins块中的声明
        Matcher matcher = PLUGIN_ID_PATTERN.matcher(buildGradleContent);
        while (matcher.find()) {
            if (matcher.group(1).equals(pluginId)) {
                return true;
            }
        }
        // 检查apply plugin语句
        matcher = APPLY_PLUGIN_PATTERN.matcher(buildGradleContent);
        while (matcher.find()) {
            if (matcher.group(1).equals(pluginId)) {
                return true;
            }
        }
        return false;
    }
    
    public static boolean hasDependency(String buildGradleContent, String dependencyNotation) {
        Matcher matcher = DEPENDENCY_PATTERN.matcher(buildGradleContent);
        while (matcher.find()) {
            String matchedDep = matcher.group(1);
            // 支持完整坐标或group:name形式匹配
            if (matchedDep.equals(dependencyNotation) || 
                matchedDep.startsWith(dependencyNotation + ":")) {
                return true;
            }
        }
        return false;
    }
}

优劣总结 #

• 优点：零依赖、解析速度快，实现简单；
• 缺点：无法处理复杂场景，比如依赖用变量定义（implementation libs.joda.time）、插件通过动态逻辑声明等，容易出现漏判或误判，适合结构简单的脚本。

3. Groovy AST解析（折中方案） #

如果不想引入Gradle核心依赖，但又需要比正则更准确的解析，可以用Groovy的AST（抽象语法树）解析能力，直接分析脚本的语法结构，能处理部分动态配置场景。

实现代码（简化版） #

import org.codehaus.groovy.ast.ASTNode;
import org.codehaus.groovy.ast.builder.AstBuilder;
import org.codehaus.groovy.ast.expr.*;
import org.codehaus.groovy.ast.stmt.BlockStatement;
import org.codehaus.groovy.ast.stmt.Statement;

import java.util.List;

public class GroovyAstParser {
    public static boolean hasPlugin(String buildGradleContent, String pluginId) {
        // 构建AST树
        List<ASTNode> astNodes = new AstBuilder().buildFromString(buildGradleContent);
        
        // 遍历AST节点查找插件声明
        for (ASTNode node : astNodes) {
            if (node instanceof BlockStatement) {
                if (traverseBlock((BlockStatement) node, pluginId)) {
                    return true;
                }
            }
        }
        return false;
    }
    
    private static boolean traverseBlock(BlockStatement block, String pluginId) {
        for (Statement stmt : block.getStatements()) {
            if (stmt instanceof MethodCallExpression) {
                MethodCallExpression callExpr = (MethodCallExpression) stmt;
                String methodName = callExpr.getMethodAsString();
                
                // 处理plugins块
                if ("plugins".equals(methodName)) {
                    ClosureExpression closure = (ClosureExpression) callExpr.getArguments()[0];
                    if (traverseBlock((BlockStatement) closure.getCode(), pluginId)) {
                        return true;
                    }
                }
                // 处理apply plugin语句
                else if ("apply".equals(methodName)) {
                    MapExpression args = (MapExpression) callExpr.getArguments()[0];
                    for (MapEntryExpression entry : args.getMapEntryExpressions()) {
                        if ("plugin".equals(entry.getKeyExpression().getText())) {
                            ConstantExpression pluginExpr = (ConstantExpression) entry.getValueExpression();
                            if (pluginId.equals(pluginExpr.getValue())) {
                                return true;
                            }
                        }
                    }
                }
                // 处理plugins块内的id声明
                else if ("id".equals(methodName)) {
                    ConstantExpression idExpr = (ConstantExpression) callExpr.getArguments()[0];
                    if (pluginId.equals(idExpr.getValue())) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
}

依赖配置 #

需要引入Groovy核心依赖：

dependencies {
    implementation 'org.codehaus.groovy:groovy:3.0.17'
}

优劣总结 #

• 优点：比正则更准确，能处理部分动态语法，无需Gradle核心依赖；
• 缺点：AST遍历逻辑编写繁琐，学习成本高，对于非常复杂的Gradle脚本（比如插件扩展、动态生成依赖）仍不如官方API可靠。

方案选择建议 #

• 优先选Gradle官方API：如果需要处理复杂脚本，追求结果准确性；
• 选正则表达式：脚本结构简单，追求轻量快速；
• 选Groovy AST解析：需要折中方案，不想引入Gradle核心依赖但要比正则准确。

内容的提问来源于stack exchange，提问作者Krati Tiwari