Java DependencyGraphBuilderException类代码示例

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private Set<Artifact> resolveTransitiveDependencies(Artifact artifact) throws EnforcerRuleException {
  final DependencyNode root;
  try {
    root = dependencyGraphBuilder.buildDependencyGraph(project, null);
  } catch (DependencyGraphBuilderException e) {
    throw new EnforcerRuleException("Unable to build the dependency graph!", e);
  }
  if (logger.isDebugEnabled()) {
    logger.debug("Root node is '" + root + "'.");
  }

  final Set<Artifact> transitiveDependencies = new HashSet<Artifact>();
  traverseDependencyNodes(root, transitiveDependencies);

  final Set<Artifact> directDependencies = resolveDirectDependencies(artifact);
  transitiveDependencies.removeAll(directDependencies);
  if (logger.isDebugEnabled()) {
    logger.debug("Transitive dependencies are '" + transitiveDependencies + "'.");
  }
  return transitiveDependencies;
}
 

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
/**
 * Convert dependency to root artifact.
 * @param dep Dependency
 * @return Root artifact
 */
private MavenRootArtifact root(final Dependency dep) {
    final DefaultArtifact artifact = new DefaultArtifact(
        dep.getGroupId(),
        dep.getArtifactId(),
        dep.getVersion(),
        dep.getScope(),
        dep.getType(),
        dep.getClassifier(),
        new DefaultArtifactHandler()
    );
    try {
        final Collection<Artifact> children = new LinkedList<Artifact>();
        for (final DependencyNode child : this.graph().getChildren()) {
            children.add(child.getArtifact());
        }
        return new MavenRootArtifact(
            artifact,
            dep.getExclusions(),
            children
        );
    } catch (final DependencyGraphBuilderException ex) {
        throw new IllegalStateException(ex);
    }
}
 

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
public DependencyNode getRootDependencyNode(final DependencyGraphBuilder dependencyGraphBuilder, final MavenSession session, final MavenProject project,
        final String projectName,
        final String versionName) throws MojoExecutionException {
    org.apache.maven.shared.dependency.graph.DependencyNode rootNode = null;
    final ProjectBuildingRequest buildRequest = new DefaultProjectBuildingRequest(
            session.getProjectBuildingRequest());
    buildRequest.setProject(project);
    buildRequest.setResolveDependencies(true);

    try {
        rootNode = dependencyGraphBuilder.buildDependencyGraph(buildRequest, null);
    } catch (final DependencyGraphBuilderException ex) {
        throw new MojoExecutionException(EXCEPTION_MSG_NO_DEPENDENCY_GRAPH, ex);
    }

    final String groupId = project.getGroupId();
    final String artifactId = project.getArtifactId();
    final String version = versionName;
    final MavenExternalId projectGav = new MavenExternalId(groupId, artifactId, version);

    final Set<DependencyNode> children = new LinkedHashSet<>();
    final DependencyNode root = new DependencyNode(projectName, versionName, projectGav, children);
    for (final org.apache.maven.shared.dependency.graph.DependencyNode child : rootNode.getChildren()) {
        if (includedScopes.contains(child.getArtifact().getScope())) {
            children.add(createCommonDependencyNode(child));
        }
    }

    for (final MavenProject moduleProject : project.getCollectedProjects()) {
        if (!excludedModules.contains(moduleProject.getArtifactId())) {
            final DependencyNode moduleRootNode = getRootDependencyNode(dependencyGraphBuilder, session, moduleProject, moduleProject.getArtifactId(),
                    moduleProject.getVersion());
            children.addAll(moduleRootNode.children);
        }
    }

    return root;
}
 

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
protected Set<Artifact> getDependenciesToCheck( MavenProject project )
{
    Set<Artifact> dependencies = null;
    try
    {
        DependencyNode node = graphBuilder.buildDependencyGraph( project, null );
        dependencies  = getAllDescendants( node );
    }
    catch ( DependencyGraphBuilderException e )
    {
        // otherwise we need to change the signature of this protected method
        throw new RuntimeException( e );
    }
    return dependencies;
}
 

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
private void createGraph(MavenProject project, ArtifactFilter globalFilter, ArtifactFilter transitiveDependencyFilter, GraphBuilder<DependencyNode> graphBuilder) throws DependencyGraphException {
  org.apache.maven.shared.dependency.graph.DependencyNode root;
  try {
    root = this.dependencyGraphBuilder.buildDependencyGraph(project, globalFilter);
  } catch (DependencyGraphBuilderException e) {
    throw new DependencyGraphException(e);
  }

  GraphBuildingVisitor visitor = new GraphBuildingVisitor(graphBuilder, transitiveDependencyFilter, this.targetFilter, this.omitReachablePaths);
  root.accept(visitor);
}
 

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
@Test
public void dependencyGraphWithException() throws Exception {
  DependencyGraphBuilderException cause = new DependencyGraphBuilderException("boom");
  when(this.dependencyGraphBuilder.buildDependencyGraph(ArgumentMatchers.<MavenProject>any(), ArgumentMatchers.<ArtifactFilter>any())).thenThrow(cause);

  this.expectedException.expect(DependencyGraphException.class);
  this.expectedException.expectCause(is(cause));

  this.graphAdapter.buildDependencyGraph(this.mavenProject, this.globalFilter, this.graphBuilder);
}
 

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
protected DependencyNode createDependencyTree( MavenProject project, DependencyGraphBuilder dependencyGraphBuilder,
                                               String scope )
    throws MojoExecutionException
{
    ArtifactFilter artifactFilter = createResolvingArtifactFilter( scope );
    try
    {
        return dependencyGraphBuilder.buildDependencyGraph( project, artifactFilter );
    }
    catch ( DependencyGraphBuilderException exception )
    {
        throw new MojoExecutionException( "Cannot build project dependency tree", exception );
    }

}
 

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
/**
 * Collects the transitive dependencies of the current projects.
 *
 * @param mojo  the mojo
 * @param graph the dependency graph builder
 * @return the set of resolved transitive dependencies.
 */
private static Set<Artifact> getTransitiveDependencies(AbstractWisdomMojo mojo, DependencyGraphBuilder graph,
                                                       ArtifactFilter filter) {
    Set<Artifact> artifacts;
    artifacts = new LinkedHashSet<>();
    try {
        Set<Artifact> transitives = new LinkedHashSet<>();
        DependencyNode node = graph.buildDependencyGraph(mojo.project, filter);
        node.accept(new ArtifactVisitor(mojo, transitives));
        mojo.getLog().debug(transitives.size() + " transitive dependencies have been collected : " +
                transitives);

        // Unfortunately, the retrieved artifacts are not resolved, we need to find their 'surrogates' in the
        // resolved list.
        Set<Artifact> resolved = mojo.project.getArtifacts();
        for (Artifact a : transitives) {
            Artifact r = getArtifact(a, resolved);
            if (r == null) {
                mojo.getLog().warn("Cannot find resolved artifact for " + a);
            } else {
                artifacts.add(r);
            }
        }
    } catch (DependencyGraphBuilderException e) {
        mojo.getLog().error("Cannot traverse the project's dependencies to collect transitive dependencies, " +
                "ignoring transitive");
        mojo.getLog().debug("Here is the thrown exception having disabled the transitive dependency collection", e);
        artifacts = mojo.project.getDependencyArtifacts();
    }
    return artifacts;
}
 

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
/**
 * Fetch all files found (JAR, ZIP, directories, etc).
 * @return Set of files
 */
@SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
private Set<File> fetch() {
    final Set<File> files = new LinkedHashSet<File>(0);
    for (final String path : this.elements()) {
        files.add(new File(path));
    }
    try {
        files.addAll(this.dependencies(this.graph(), this.scopes));
    } catch (final DependencyGraphBuilderException ex) {
        throw new IllegalStateException(ex);
    }
    return files;
}
 

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
/**
 * Build dependency graph.
 * @return Root of dependency graph.
 * @throws DependencyGraphBuilderException In case of error.
 */
private DependencyNode graph() throws DependencyGraphBuilderException {
    return this.builder.buildDependencyGraph(
        this.session.getCurrentProject(),
        new ArtifactFilter() {
            @Override
            public boolean include(
                final Artifact artifact) {
                return MavenClasspath.this.scopes
                    .contains(artifact.getScope());
            }
        }
    );
}
 

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
/**
 * Classpath can return a string when a dependency is broken.
 * @throws Exception If there is some problem inside
 */
@Test
public void hasToStringWithBrokenDependency() throws Exception {
    final DependencyGraphBuilder builder =
        Mockito.mock(DependencyGraphBuilder.class);
    Mockito.doThrow(
        new DependencyGraphBuilderException("DependencyResolutionException")
    )
        .when(builder)
        .buildDependencyGraph(
            Mockito.any(MavenProject.class),
            Mockito.any(ArtifactFilter.class)
        );
    final MavenSession session = Mockito.mock(MavenSession.class);
    final MavenProject project = this.project(
        this.dependency(
            "junit-broken", "junit-absent", "1.0"
        )
    );
    Mockito.when(session.getCurrentProject()).thenReturn(project);
    final MavenClasspath classpath = new MavenClasspath(
        builder, session, MavenClasspath.TEST_SCOPE
    );
    MatcherAssert.assertThat(
        classpath.toString(),
        Matchers.containsString(
            "failed to load 'junit-broken:junit-absent:jar:1.0 (test)'"
        )
    );
}
 

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
private void createDependencyReducedPom( Set<String> artifactsToRemove )
    throws IOException, DependencyGraphBuilderException, ProjectBuildingException
{
    List<Dependency> dependencies = new ArrayList<Dependency>();

    boolean modified = false;

    List<Dependency> transitiveDeps = new ArrayList<Dependency>();

    // NOTE: By using the getArtifacts() we get the completely evaluated artifacts
    // including the system scoped artifacts with expanded values of properties used.
    for ( Artifact artifact : project.getArtifacts() )
    {
        if ( "pom".equals( artifact.getType() ) )
        {
            // don't include pom type dependencies in dependency reduced pom
            continue;
        }

        // promote
        Dependency dep = createDependency( artifact );

        // we'll figure out the exclusions in a bit.
        transitiveDeps.add( dep );
    }
    List<Dependency> origDeps = project.getDependencies();

    if ( promoteTransitiveDependencies )
    {
        origDeps = transitiveDeps;
    }

    Model model = project.getOriginalModel();
    // MSHADE-185: We will remove all system scoped dependencies which usually
    // have some kind of property usage. At this time the properties within
    // such things are already evaluated.
    List<Dependency> originalDependencies = model.getDependencies();
    removeSystemScopedDependencies( artifactsToRemove, originalDependencies );

    for ( Dependency d : origDeps )
    {
        dependencies.add( d );

        String id = getId( d );

        if ( artifactsToRemove.contains( id ) )
        {
            modified = true;

            if ( keepDependenciesWithProvidedScope )
            {
                d.setScope( "provided" );
            }
            else
            {
                dependencies.remove( d );
            }
        }
    }

    // MSHADE-155
    model.setArtifactId( shadedArtifactId );

    // MSHADE-185: We will add those system scoped dependencies
    // from the non interpolated original pom file. So we keep
    // things like this: <systemPath>${tools.jar}</systemPath> intact.
    addSystemScopedDependencyFromNonInterpolatedPom( dependencies, originalDependencies );

    // Check to see if we have a reduction and if so rewrite the POM.
    rewriteDependencyReducedPomIfWeHaveReduction( dependencies, modified, transitiveDeps, model );
}
 

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
public DependencyGraphException(DependencyGraphBuilderException cause) {
  super(cause);
}
 

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
/**
 * Examines the {@linkplain #getProject() current
 * <code>MavenProject</code>}'s dependencies, {@linkplain
 * #getArtifactResolver() resolving} them if necessary, and
 * assembles and returns a {@link Collection} whose elements are
 * {@link URL}s representing reachable changelog fragments that are
 * classpath resources.
 *
 * <p>This method may return {@code null}.</p>
 *
 * <p>This method calls the {@link #getChangeLogResources(Iterable)}
 * method.</p>
 *
 * <p>This method invokes the {@link
 * Artifacts#getArtifactsInTopologicalOrder(MavenProject,
 * DependencyGraphBuilder, ArtifactFilter, ArtifactResolver,
 * ArtifactRepository)} method.</p>
 *
 * @return a {@link Collection} of {@link URL}s to classpath
 * resources that are changelog fragments, or {@code null}
 *
 * @exception IllegalStateException if the return value of {@link
 * #getProject()}, {@link #getDependencyGraphBuilder()} or {@link
 * #getArtifactResolver()} is {@code null}
 * 
 * @exception ArtifactResolutionException if there was a problem
 * {@linkplain ArtifactResolver#resolve(ArtifactResolutionRequest)
 * resolving} a given {@link Artifact} representing a dependency
 *
 * @exception DependencyGraphBuilderException if there was a problem
 * with dependency resolution
 *
 * @exception IOException if there was a problem with input or
 * output
 *
 * @see #getChangeLogResources(Iterable)
 *
 * @see Artifacts#getArtifactsInTopologicalOrder(MavenProject,
 * DependencyGraphBuilder, ArtifactFilter, ArtifactResolver,
 * ArtifactRepository)
 */
public final Collection<? extends URL> getChangeLogResources() throws ArtifactResolutionException, DependencyGraphBuilderException, IOException {
  final MavenProject project = this.getProject();
  if (project == null) {
    throw new IllegalStateException("this.getProject()", new NullPointerException("this.getProject()"));
  }
  final DependencyGraphBuilder dependencyGraphBuilder = this.getDependencyGraphBuilder();
  if (dependencyGraphBuilder == null) {
    throw new IllegalStateException("this.getDependencyGraphBuilder()", new NullPointerException("this.getDependencyGraphBuilder()"));
  }
  final ArtifactResolver resolver = this.getArtifactResolver();
  if (resolver == null) {
    throw new IllegalStateException("this.getArtifactResolver()", new NullPointerException("this.getArtifactResolver()"));
  }
  final Collection<? extends Artifact> artifacts = new Artifacts().getArtifactsInTopologicalOrder(project,
                                                                                                  dependencyGraphBuilder,
                                                                                                  this.getArtifactFilter(),
                                                                                                  resolver,
                                                                                                  this.getLocalRepository());
  Collection<? extends URL> urls = null;
  if (artifacts != null && !artifacts.isEmpty()) {
    urls = getChangeLogResources(artifacts);
  }
  if (urls == null) {
    urls = Collections.emptySet();
  }
  return urls;
}
 

import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException; //导入依赖的package包/类
/**
 * Resolve dependencies of a project matching the given filter.
 * 
 * @param mavenProject
 *            The {@link MavenProject} whose dependency tree is to be read.
 * @param artifactFilter
 *            An {@link ArtifactFilter} that will determine what artifacts are to qualify.
 * @return A {@link List} of {@link DependencyNode} objects representing the matching dependencies.
 * @throws MojoExecutionException
 *             If any errors occur while trying to resolve the dependencies.
 */
protected List<DependencyNode> resolveDependencies(MavenProject mavenProject, ArtifactFilter artifactFilter) throws MojoExecutionException {
    try {
        return dependencyGraphBuilder.buildDependencyGraph(project, artifactFilter).getChildren();
    } catch (DependencyGraphBuilderException e) {
        throw new MojoExecutionException(String.format("Failed to build dependency graph for project %s", formatIdentifier(project)), e);
    }
}