Comment accéder à la hiérarchie des dépendances de Maven dans un plug-in

Question

Dans mon plugin je dois traiter la hiérarchie des dépendances et obtenir de l'information (groupId, artifactId, la version, etc.) sur chaque dépendance et si elle a été exclue. Quelle est la meilleure façon de le faire?

Answer 1

Le plug-in de dépendance a fait la majeure partie de ce travail. Il traite un MavenProject en utilisant le DependencyTreeBuilder, cela renvoie une DependencyNode avec des informations sur les dépendances hiérarchiques résolus (et leurs dépendances transitif).

Vous pouvez copier une grande partie du code directement à partir du TreeMojo. Il utilise le CollectingDependencyNodeVisitor pour traverser l'arbre et produire un List de tous les nœuds.

Vous pouvez accéder au Artifact pour le nœud en appelant getArtifact(), puis obtenir l'information sur les artefacts au besoin. Pour obtenir la raison d'exclusion, DependencyNode a une méthode getState() qui retourne un entier indiquant si la dépendance a été incluse, ou sinon la raison de l'omission était (il y a des constantes dans la classe DependencyNode pour vérifier la valeur de retour contre)

//All components need this annotation, omitted for brevity

/**
 * @component
 * @required
 * @readonly
 */
private ArtifactFactory artifactFactory;
private ArtifactMetadataSource artifactMetadataSource;
private ArtifactCollector artifactCollector;
private DependencyTreeBuilder treeBuilder;
private ArtifactRepository localRepository;
private MavenProject project;

public void execute() throws MojoExecutionException, MojoFailureException {
    try {
        ArtifactFilter artifactFilter = new ScopeArtifactFilter(null);

        DependencyNode rootNode = treeBuilder.buildDependencyTree(project,
                localRepository, artifactFactory, artifactMetadataSource,
                artifactFilter, artifactCollector);

        CollectingDependencyNodeVisitor visitor = 
            new CollectingDependencyNodeVisitor();

        rootNode.accept(visitor);

        List<DependencyNode> nodes = visitor.getNodes();
        for (DependencyNode dependencyNode : nodes) {
            int state = dependencyNode.getState();
            Artifact artifact = dependencyNode.getArtifact();
            if(state == DependencyNode.INCLUDED) {                    
                //...
            } 
        }
    } catch (DependencyTreeBuilderException e) {
        // TODO handle exception
        e.printStackTrace();
    }
}

Answer 2

Vous pouvez utiliser noreferrer MavenProject # getDependencyArtifacts () ou noreferrer MavenProject # getDependencies () (une suite retourne aussi les dépendances transitif).

/**
 * Test Mojo
 *
 * @goal test
 * @requiresDependencyResolution compile
 */
public class TestMojo extends AbstractMojo {

    /**
     * The Maven Project.
     *
     * @parameter expression="${project}"
     * @required
     * @readonly
     */
    private MavenProject project = null;

    /**
     * Execute Mojo.
     *
     * @throws MojoExecutionException If an error occurs.
     * @throws MojoFailureException If an error occurs.
     */
    public void execute() throws MojoExecutionException,
MojoFailureException {

        ...

        Set dependencies = project.getDependencies();

       ...
    }

}

Je ne suis pas tout à fait sûr, mais je pense que les deux méthodes renvoient une collection de les implémentations de artefact qui exposent getters pour groupId, artifactId, la version, etc.

Answer 3

Voici une mise à jour, par exemple Maven3 sur la façon d'obtenir toutes les dépendances (y compris transitif), ainsi que l'accès aux fichiers eux-mêmes (si par exemple vous devez ajouter les chemins à un classpath).

// Default phase is not necessarily important.
// Both requiresDependencyCollection and requiresDependencyResolution are extremely important however!
@Mojo(name = "simple", defaultPhase = LifecyclePhase.PROCESS_RESOURCES, requiresDependencyCollection = ResolutionScope.COMPILE_PLUS_RUNTIME, requiresDependencyResolution = ResolutionScope.COMPILE_PLUS_RUNTIME)
public class SimpleMojo extends AbstractMojo {
  @Parameter(defaultValue = "${project}", readonly = true)
  private MavenProject mavenProject;

  @Override
  public void execute() throws MojoExecutionException, MojoFailureException {
    for (final Artifact artifact : mavenProject.getArtifacts()) {
      // Do whatever you need here.
      // If having the actual file (artifact.getFile()) is not important, you do not need requiresDependencyResolution.
    }
  }
}

Modification des paramètres du Mojo est un morceau très important que je manque. Sans elle, les lignes comme suit:

@Parameter(defaultValue = "${project.compileClasspathElements}", readonly = true, required = true)
private List<String> compilePath;

ne retournera le répertoire classes, pas le chemin que vous attendez.

Modification du requiresDependencyCollection et requiresDependencyResolution à différentes valeurs vous permettra de modifier la portée de ce que vous voulez saisir. documentation maven peut fournir plus de détails.

Answer 4

Essayez d'utiliser Aether classe utilitaire à partir de jcabi-aether pour obtenir une liste de toutes les dépendances de tout artefact:

File repo = this.session.getLocalRepository().getBasedir();
Collection<Artifact> deps = new Aether(this.getProject(), repo).resolve(
  new DefaultArtifact("junit", "junit-dep", "", "jar", "4.10"),
  JavaScopes.RUNTIME
);

Answer 5

Pourquoi ne pas simplement retourner toutes les dépendances (les deux ones directs et transitifs) et vérifier l'exclusion?

@Parameter(property = "project", required = true, readonly = true)
private MavenProject project;

public void execute() throws MojoExecutionException
{
  for (Artifact a : project.getArtifacts()) {
    if( a.getScope().equals(Artifact.SCOPE_TEST) ) { ... }
    if( a.getScope().equals(Artifact.SCOPE_PROVIDED) ) { ... }
    if( a.getScope().equals(Artifact.SCOPE_RUNTIME) ) { ... }
  }
}

Answer 6

Maven 3 utilisation aether, il y a échantillon ici: https://docs.sonatype.org/display/AETHER/Home

Answer 7

Pour Maven 3, vous pouvez utiliser DependencyGraphBuilder. Il fait à peu près la même chose que DependencyTreeBuilder.

Voici l'exemple

    import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
    import org.apache.maven.artifact.resolver.filter.IncludesArtifactFilter;
    import org.apache.maven.execution.MavenSession;
    import org.apache.maven.model.Dependency;
    import org.apache.maven.plugins.annotations.ResolutionScope;
    import org.apache.maven.plugins.annotations.LifecyclePhase;
    import org.apache.maven.shared.dependency.graph.DependencyGraphBuilder;

    import org.apache.maven.shared.dependency.graph.DependencyNode;
    import org.apache.maven.shared.dependency.graph.traversal.CollectingDependencyNodeVisitor;

    public class AnanlyzeTransitiveDependencyMojo extends AbstractMojo{

        @Parameter(defaultValue = "${project}", readonly = true, required = true)
        private MavenProject project;

        @Parameter(defaultValue = "${session}", readonly = true, required = true)
        private MavenSession session;

        @Component(hint="maven3")
        private DependencyGraphBuilder dependencyGraphBuilder;

        @Override
        public void execute() throws MojoExecutionException, MojoFailureException {
    // If you want to filter out certain dependencies.
             ArtifactFilter artifactFilter = new IncludesArtifactFilter("groupId:artifactId:version");
             ProjectBuildingRequest buildingRequest = new DefaultProjectBuildingRequest(session.getProjectBuildingRequest());
             buildingRequest.setProject(project);
            try{
               DependencyNode depenGraphRootNode = dependencyGraphBuilder.buildDependencyGraph(buildingRequest, artifactFilter);
               CollectingDependencyNodeVisitor visitor = new  CollectingDependencyNodeVisitor();
               depenGraphRootNode.accept(visitor);
               List<DependencyNode> children = visitor.getNodes();

               getLog().info("CHILDREN ARE :");
               for(DependencyNode node : children) {
                   Artifact atf = node.getArtifact();
            }
}catch(Exception e) {
    e.printStackTrace();
}