Comment obtenir l'accès à Maven de la dépendance de la hiérarchie au sein d'un plugin

La dépendance plugin a la arbre but qui réalise la plupart de ce travail. Il traite une MavenProject à l'aide de la DependencyTreeBuilder, cela renvoie une DependencyNode avec hiérarchique de l'information au sujet de l'résolu dépendances (et leurs dépendances transitives).

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

Vous pouvez accéder à la Artifact pour le nœud en appelant getArtifact(), puis obtenir l'objet d'informations que nécessaire. Pour obtenir l'exclusion de la raison, DependencyNode a un getState() méthode qui renvoie un entier indiquant si la dépendance a été compris, ou sinon quelle est la raison de l'omission qu'il a été (il y a des constantes dans la DependencyNode classe 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();
    }
}

Ici est une mise à jour, Maven3 exemple sur la façon d'obtenir toutes les dépendances (y compris transitive) et d'avoir accès aux fichiers eux-mêmes (si vous avez par exemple besoin d'ajouter les chemins d'accès à un chemin de classe).

//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.
    }
  }
}

Modifié les paramètres dans le Mojo est un élément très important qu'il me manquait. Sans elle, les lignes comme suit:

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

Retourne uniquement le répertoire classes, et non pas le chemin que vous attendez.

La modification de la requiresDependencyCollection et requiresDependencyResolution à différentes valeurs vous permettra de modifier la portée de ce que vous voulez prendre. Le maven de la documentation peut fournir plus de détails.

Pourquoi ne pas juste en arrière de toutes les dépendances (à la fois 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) ) { ... }
  }
}

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();
}