En mi plugin necesito proceso de la dependencia de la jerarquía y obtener información (groupId, artifactId, versión, etc) acerca de cada dependencia y si fue excluido. ¿Cuál es la mejor manera de hacer esto?

OriginalEl autor talk to frank | 2009-09-29

7 Comentarios

  1. 29

    La dependencia plugin tiene la árbol de objetivo que hace la mayoría de este trabajo. Se procesa un MavenProject el uso de la DependencyTreeBuilder, este devuelve un DependencyNode con jerárquica de la información sobre el resuelto dependencias (y sus dependencias transitivas).

    Puede copiar mucho de el código directamente desde el TreeMojo. Utiliza el CollectingDependencyNodeVisitor para recorrer el árbol y producir un List de todos los nodos.

    Puede acceder a la Artifact para el nodo llamando getArtifact(), a continuación, obtener el artefacto de la información según sea necesario. Para obtener la exclusión de la razón, DependencyNode tiene un getState() método que devuelve un entero que indica si la dependencia se ha incluido, o si no lo que la razón de la omisión fue (no son constantes en el DependencyNode clase para comprobar el valor devuelto en contra)

    //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();
        }
    }
    +1 Muy bonito, gracias! Sin embargo, el fragmento de código contiene un pequeño error: Lista de< DependencyNode > nodos = visitante.getNodes(); Sobre el bucle for.
    Mucho de eso está en desuso en Maven3. Le importa a alguien para actualizar con un Maven3 (no en desuso) de la solución?
    qué dependencias describir todos los thses clases?

    OriginalEl autor Rich Seller

  2. 19

    Usted podría utilizar MavenProject#getDependencyArtifacts() o MavenProject#getDependencies() (la posterior devuelve también transitivo dependencias).

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

    No estoy totalmente seguro, pero creo que ambos métodos devuelven una colección de Artefacto implementaciones que exponen a los getters para groupId, artifactId, versión, etc.

    +1 Esta es una solución más simple que el mío, si usted necesita para obtener todos los resuelto dependencias, pero si quieres encontrar información sobre los excluidos de las dependencias que necesita más de esto
    Maldita sea, tienes razón, me he perdido el punto acerca de excluidos de las dependencias. Así que esto no responde a la OP pregunta.
    sí, yo soy, después de todas las dependencias por lo que puedo informar de por qué ellos no estaban incluidos, gracias por la información, aunque
    en Maven 3.x getDependencies() no volver transitiva deps
    en Maven 3.x, hay una [setResolvedArtifacts][1] método, pero su campo privado… [1] maven.apache.org/ref/3.0.3/maven-core/apidocs/org/apache/maven/…

    OriginalEl autor Pascal Thivent

  3. 9

    Aquí es un hasta la fecha, Maven3 ejemplo sobre cómo obtener todas las dependencias (incluyendo transitiva), así como tener acceso a los archivos propios (si, por ejemplo, necesita agregar las rutas de acceso a una ruta de clases).

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

    El cambio de los parámetros en el Mojo es una pieza muy importante que me faltaba. Sin ella, las líneas como las siguientes:

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

    Sólo devolverá el directorio clases, no la ruta de acceso que usted espera.

    Cambiar el requiresDependencyCollection y requiresDependencyResolution para diferentes valores que le permiten cambiar el alcance de lo que usted desea tomar. El maven documentación puede proporcionar más detalles.

    Esta es la mejor respuesta (hasta la fecha & integral). He creado una cuenta & respondió a algunas preguntas para que yo pueda obtener suficiente karma para tener el derecho a upvote este. Gracias.
    A pesar de que he votado a favor de que la respuesta parece que el segundo nivel transitiva dependencias no resueltas utilizando este método.
    Hola, ¿cómo puedo conseguir que esto funcione en mi extensión personalizada? Por favor alguien puede vistazo a esta pregunta? agradeceria mucho su ayuda stackoverflow.com/questions/51888672/…

    OriginalEl autor wrestang

  4. 5

    Intentar utilizar Aether utilidad de la clase de jcabi-éter para obtener una lista de todas las dependencias de cualquier artefacto:

    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
    );
    Hola, puedo hacer esto en este escenario ? Agradezco su ayuda stackoverflow.com/questions/51888672/…

    OriginalEl autor yegor256

  5. 3

    ¿Por qué no acaba de volver de todas las dependencias (tanto directos y transitiva) y verificación de exclusión?

    @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) ) { ... }
      }
    }

    OriginalEl autor kane

  6. 2

    Maven 3 utilice éter, no se muestra aquí :
    https://docs.sonatype.org/display/AETHER/Home

    Lo siento, abajo de la votación para no incluir contenido en stackoverflow en caso de rotura de enlaces – link está roto ahora.
    Aether ahora vive en el Eclipse de la Fundación: eclipse.org/aether
    Aether fue repudiado por Eclipse, pero, posteriormente, adoptada por Apache!
    … es un trivial de actualización de Eclipse Aether 1.1.0 a Apache Aether 1.1.1; sólo GIDs para la mayor parte. org.apache.maven.resolución y maven-resolución-proveedor

    OriginalEl autor Yann Le Moigne

  7. 1

    Para Maven 3 puede utilizar DependencyGraphBuilder. Hace más o menos lo mismo como DependencyTreeBuilder.

    Aquí está el ejemplo de

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

    OriginalEl autor poojaN

Dejar respuesta

Please enter your comment!
Please enter your name here