如何通过Java代码获取Spring Boot项目未显式声明的依赖版本？

直接用maven-model解析POM只能拿到显式声明的版本，因为它仅读取原始XML结构，不会执行Maven的依赖解析流程——包括继承parent的dependencyManagement版本、依赖冲突调解、快照版本解析等。要实现和mvn dependency:tree相同的效果，得用Maven的核心依赖解析API或者Spring Boot专属工具类。

方法一：使用Maven Resolver API（Aether） #

这是Maven官方用来处理依赖解析的底层库，能完整复刻Maven命令行的依赖解析逻辑，适用于所有Maven项目。

步骤1：添加Maven Resolver依赖 #

在你的项目POM里加入以下依赖（版本可根据当前Maven版本调整）：

<dependencies>
    <dependency>
        <groupId>org.apache.maven.resolver</groupId>
        <artifactId>maven-resolver-api</artifactId>
        <version>1.9.15</version>
    </dependency>
    <dependency>
        <groupId>org.apache.maven.resolver</groupId>
        <artifactId>maven-resolver-impl</artifactId>
        <version>1.9.15</version>
    </dependency>
    <dependency>
        <groupId>org.apache.maven.resolver</groupId>
        <artifactId>maven-resolver-transport-http</artifactId>
        <version>1.9.15</version>
    </dependency>
    <dependency>
        <groupId>org.apache.maven</groupId>
        <artifactId>maven-core</artifactId>
        <version>3.9.5</version>
    </dependency>
</dependencies>

步骤2：编写依赖解析代码 #

以下代码会解析指定POM的完整依赖树，包含所有继承、调解后的实际版本：

import org.apache.maven.model.building.DefaultModelBuilder;
import org.apache.maven.model.building.DefaultModelBuilderFactory;
import org.apache.maven.model.building.DefaultModelBuildingRequest;
import org.apache.maven.model.building.ModelBuildingRequest;
import org.apache.maven.model.Model;
import org.apache.maven.resolver.api.*;
import org.apache.maven.resolver.api.resolver.ResolutionResult;
import org.apache.maven.resolver.api.resolver.ResolveRequest;
import org.apache.maven.resolver.examples.util.BasicRepositorySystemFactory;

import java.io.File;
import java.util.List;

public class DependencyVersionResolver {

    public static void main(String[] args) throws Exception {
        // 1. 加载并构建完整的Maven模型（包含parent继承内容）
        File pomFile = new File("path/to/your/project/pom.xml");
        DefaultModelBuilder modelBuilder = new DefaultModelBuilderFactory().newInstance();
        ModelBuildingRequest request = new DefaultModelBuildingRequest()
                .setPomFile(pomFile)
                .setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL);
        Model model = modelBuilder.build(request).getEffectiveModel();

        // 2. 初始化Maven Resolver仓库系统
        RepositorySystem repoSystem = BasicRepositorySystemFactory.newRepositorySystem();
        RepositorySystemSession session = MavenRepositoryUtils.newSession(repoSystem);

        // 3. 设置远程仓库（这里用Maven中央仓库，可按需添加私有仓库）
        RemoteRepository central = new RemoteRepository.Builder("central", "default", "https://repo1.maven.org/maven2/").build();
        session.setRemoteRepositories(List.of(central));

        // 4. 构建依赖请求，解析项目compile范围依赖
        DependencyFilter filter = DependencyFilterUtils.classpathFilter("compile");
        List<Artifact> projectArtifacts = model.getDependencies().stream()
                .map(MavenRepositoryUtils::toArtifact)
                .toList();

        ResolveRequest resolveRequest = new ResolveRequest()
                .setSession(session)
                .setArtifacts(projectArtifacts)
                .setFilter(filter);

        // 5. 执行依赖解析
        ResolutionResult result = repoSystem.resolve(resolveRequest);

        // 6. 输出所有依赖及其实际版本
        for (Artifact artifact : result.getArtifacts()) {
            System.out.printf("%s:%s:%s%n", artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion());
        }
    }
}

方法二：利用Spring Boot的DependencyManagement工具类 #

如果是Spring Boot项目，可以直接用Spring Boot提供的工具类，它会自动读取spring-boot-starter-parent里的依赖管理配置，无需手动处理仓库解析。

步骤1：添加Spring Boot相关依赖 #

确保项目引入Spring Boot的核心依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependency-management</artifactId>
    <version>3.2.0</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>3.2.0</version>
</dependency>

步骤2：编写代码获取依赖版本 #

import org.springframework.boot.dependencymanagement.DependencyManagement;
import org.springframework.boot.dependencymanagement.DependencyManagementEntry;
import org.springframework.boot.dependencymanagement.DependencyManagementGroup;
import org.springframework.boot.dependencymanagement.buildmodel.DependencyManagementModelBuilder;
import org.springframework.boot.dependencymanagement.buildmodel.ModelBuildingRequest;

import java.io.File;
import java.util.Map;

public class SpringBootDependencyResolver {

    public static void main(String[] args) throws Exception {
        File pomFile = new File("path/to/your/project/pom.xml");
        ModelBuildingRequest request = new ModelBuildingRequest(pomFile);
        DependencyManagement dependencyManagement = DependencyManagementModelBuilder.build(request);

        // 遍历所有依赖管理条目（包括parent继承的版本）
        for (DependencyManagementGroup group : dependencyManagement.getGroups()) {
            Map<String, DependencyManagementEntry> entries = group.getEntries();
            for (Map.Entry<String, DependencyManagementEntry> entry : entries.entrySet()) {
                String artifactId = entry.getKey();
                String version = entry.getValue().getVersion();
                System.out.printf("%s:%s:%s%n", group.getGroupId(), artifactId, version);
            }
        }
    }
}

关键说明 #

• maven-model仅处理静态XML，不会触发Maven的依赖解析生命周期，所以拿不到继承的版本；上述两种方法都会执行完整的依赖解析逻辑，和mvn dependency:tree的底层逻辑一致。
• 如果项目有私有仓库，需要在代码中添加对应的RemoteRepository配置，确保能解析私有依赖。

内容的提问来源于stack exchange，提问作者Robbi Nespu