Java DependencyTreeBuilderException类代码示例

import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException; //导入依赖的package包/类
private static DependencyNode createDependencyTree(MavenProject project,
        DependencyTreeBuilder dependencyTreeBuilder, ArtifactRepository localRepository,
        ArtifactFactory artifactFactory, ArtifactMetadataSource artifactMetadataSource,
        ArtifactCollector artifactCollector,
        String scope) {
    ArtifactFilter artifactFilter = createResolvingArtifactFilter(scope);

    try {
        // TODO: note that filter does not get applied due to MNG-3236
        return dependencyTreeBuilder.buildDependencyTree(project,
                localRepository, artifactFactory,
                artifactMetadataSource, artifactFilter, artifactCollector);
    } catch (DependencyTreeBuilderException exception) {
    }
    return null;
}
 

import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException; //导入依赖的package包/类
protected Set<Artifact> getDependencyArtifacts( Set<?> classPathArtifacts, Artifact rootArtifact )
    throws DependencyTreeBuilderException
{
    Set<Artifact> result = null;

    buildDependencyTree();
    DependencyNode artifactNode = findArtifactNode( rootArtifact, rootNode );
    if ( artifactNode != null )
    {
        result = new HashSet<Artifact>();
        addDependencyArtifacts( result, classPathArtifacts, artifactNode );
    }
    else
    {
        result = Collections.emptySet();
    }

    return result;
}
 

import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException; //导入依赖的package包/类
private Repository constructRepository() throws IOException {
    Repository repo = new DirRepository(classesDirectory.toPath());
    
    if (!quiet) {
        getLog().info("HuntBugs: +dir " + classesDirectory);
    }

    // collecting project dependencies including pom and transitive dependencies
    ArtifactFilter artifactFilter = new ScopeArtifactFilter("compile");
    DependencyNode rootNode;
    try {
        rootNode = treeBuilder.buildDependencyTree(project, session.getLocalRepository(), artifactFilter);
    } catch (DependencyTreeBuilderException e) {
        throw new RuntimeException(e);
    }
    CollectingDependencyNodeVisitor visitor = new CollectingDependencyNodeVisitor();
    rootNode.accept(visitor);

    // converting dependencies to type loaders
    List<DependencyNode> nodes = visitor.getNodes();
    List<ITypeLoader> deps = new ArrayList<>();
    for (DependencyNode dependencyNode : nodes) {
        int state = dependencyNode.getState();

        // checking that transitive dependency is NOT excluded
        if (state == DependencyNode.INCLUDED) {
            Artifact artifact = dependencyNode.getArtifact();
            addDependency(artifact, deps);
        }
    }
    
    if (deps.isEmpty()) {
        return repo;
    }
    
    return new CompositeRepository(
        Arrays.asList(repo, new AuxRepository(new CompositeTypeLoader(deps.toArray(new ITypeLoader[0])))));
}
 

import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException; //导入依赖的package包/类
private Set<Artifact> getDependenciesToCheck( MavenProject project, ArtifactRepository localRepository )
{
    Set<Artifact> dependencies = null;
    try
    {
        DependencyNode node = treeBuilder.buildDependencyTree( project, localRepository, null );
        
        if( isSearchTransitive() )
        {
            dependencies  = getAllDescendants( node );
        }
        else if ( node.getChildren() != null )
        {
            dependencies = new HashSet<Artifact>();
            for( DependencyNode depNode : node.getChildren() )
            {
                dependencies.add( depNode.getArtifact() );
            }
        }
    }
    catch ( DependencyTreeBuilderException e )
    {
        // otherwise we need to change the signature of this protected method
        throw new RuntimeException( e );
    }
    return dependencies;
}
 

import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException; //导入依赖的package包/类
protected Set<Artifact> getModuleDependencyArtifacts( Set<?> classPathArtifacts, Artifact moduleZipArtifact )
    throws DependencyTreeBuilderException
{
    Set<Artifact> result =
        getDependencyArtifactsExt( classPathArtifacts, moduleZipArtifact );
    return result;
}
 

import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException; //导入依赖的package包/类
private Set<Artifact> getDependencyArtifactsExt( Set<?> classPathArtifacts, Artifact rootArtifact )
    throws DependencyTreeBuilderException
{
    Set<Artifact> result = null;

    buildDependencyTree();
    DependencyNode artifactNode = findArtifactNode( rootArtifact, rootNode );
    if ( artifactNode != null )
    {
        result = new HashSet<Artifact>();
        addDependencyArtifacts( result, classPathArtifacts, artifactNode );
        if ( result.isEmpty() )
        {
            Set<?> projectArtifacts = project.getArtifacts();
            for ( Iterator<?> iter = projectArtifacts.iterator(); iter.hasNext(); )
            {
                Artifact artifact = (Artifact) iter.next();
                if ( artifact != rootArtifact && artifact.getGroupId().equals( rootArtifact.getGroupId() )
                    && artifact.getArtifactId().equals( rootArtifact.getArtifactId() ) )
                {
                    Set<Artifact> tmp = getDependencyArtifacts( classPathArtifacts, artifact );
                    result.addAll( tmp );
                }
            }
        }
    }
    else
    {
        result = Collections.emptySet();
    }

    return result;
}
 

import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException; //导入依赖的package包/类
private void buildDependencyTree()
    throws DependencyTreeBuilderException
{
    if ( rootNode == null )
    {
        rootNode =
            dependencyTreeBuilder.buildDependencyTree( project, localRepository, artifactFactory,
                                                       artifactMetadataSource, null, artifactCollector );
    }
}
 

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

  // Due to MNG-3236, we need to filter the artifacts on our own.
  GraphBuildingVisitor visitor = new GraphBuildingVisitor(graphBuilder, globalFilter, transitiveDependencyFilter, this.targetFilter, this.includedResolutions);
  root.accept(visitor);
}
 

import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException; //导入依赖的package包/类
@Test
public void dependencyTreeWithException() throws Exception {
  DependencyTreeBuilderException cause = new DependencyTreeBuilderException("boom");
  when(this.dependencyTreeBuilder.buildDependencyTree(ArgumentMatchers.<MavenProject>any(), ArgumentMatchers.<ArtifactRepository>any(), ArgumentMatchers.<ArtifactFilter>any())).thenThrow(cause);

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

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

import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException; //导入依赖的package包/类
List<String> getNonProvidedDependencies(String possibleArtifactIds) throws MojoExecutionException {
    try {
        DependencyNode root = depTreeBuilder.buildDependencyTree(project, localRepo, artifactFactory, artifactMetadataSource,
                PROVIDED_SCOPE_FILTER, artifactCollector);
        SubArtifactCollector sac = new SubArtifactCollector(possibleArtifactIds == null ? null : Arrays.asList(new IncludeAndExclude(
                possibleArtifactIds, null).getIncludeSplit()));
        root.accept(sac);
        return sac.getSubArtifactIds();
    } catch (DependencyTreeBuilderException e) {
        throw new MojoExecutionException("error building dependency tree", e);
    }
}
 

import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException; //导入依赖的package包/类
/**
 * @param mavenProject Base pom to check.
 * @param artifactRepository Repository to use when resolving artifacts.
 * @param dependencyTreeBuilder {@link DependencyTreeBuilder} instance to use
 *          to build a dependency tree.
 * @param scope Dependency scope to use. See {@link Artifact} SCOPE constants.
 * @param checkers A list of one or more {@link SciJavaDependencyChecker}s.
 *          Each will visit the constructed dependency tree.
 * @throws SciJavaDependencyException If one or more of the given checkers
 *           visitations ultimately returns {@code true}, indicating a failed
 *           state was discovered.n
 */
public static void checkDependencies(final MavenProject mavenProject,
	final ArtifactRepository artifactRepository,
	final DependencyTreeBuilder dependencyTreeBuilder, final String scope,
	final SciJavaDependencyChecker... checkers)
	throws SciJavaDependencyException
{
	final ArtifactFilter artifactFilter = createResolvingArtifactFilter(scope);
	try {
		// Build the dependency tree that will be visited by each checker.
		final DependencyNode root =
			dependencyTreeBuilder.buildDependencyTree(mavenProject,
				artifactRepository, artifactFilter);

		String failureMessage = "";

		// Iterate over each checker, visiting the dependency tree and aggregating
		// failure messages.
		for (final SciJavaDependencyChecker checker : checkers) {
			if (root.accept(checker)) {
				failureMessage += checker.makeExceptionMessage();
			}
		}

		// throw an exception if one or more checker failed.
		if (!failureMessage.isEmpty()) {
			throw new SciJavaDependencyException(failureMessage);
		}
	}
	catch (final DependencyTreeBuilderException e) {
		throw new SciJavaDependencyException(e.getMessage());
	}
}
 

import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException; //导入依赖的package包/类
private void processPackage() throws MojoExecutionException {
    try {
        //Limit the transitivity of a dependency, and also to affect the classpath used for various build tasks.
        ArtifactFilter artifactFilter = createResolvingArtifactFilter();

        DependencyResolver dependencyResolver = new DefaultDependencyResolver();
        DependencyNode rootNode = dependencyTreeBuilder.buildDependencyTree(project,
                localRepository, artifactFilter);

        DependencyResolutionResult drr = dependencyResolver.resolve(rootNode);

        Map<String, List<Artifact>> conflictDependencyArtifact = drr
                .getConflictDependencyArtifact();
        Map<String, Artifact> results = drr.getResolvedDependenciesByName();
        if (!conflictDependencyArtifact.isEmpty()) {
            Iterator<Entry<String, List<Artifact>>> iter = conflictDependencyArtifact
                    .entrySet().iterator();
            while (iter.hasNext()) {
                Entry<String, List<Artifact>> conflictEntries = iter.next();
                StringBuilder sb = new StringBuilder("Founded conflicting dependency component:");
                List<Artifact> conflictArtifacts = conflictEntries.getValue();
                sb.append(conflictEntries.getKey())
                        .append("\n Resolved version is "
                                + results.get(conflictEntries.getKey()))
                        .append("\n But found conflicting artifact ");
                for (Artifact at : conflictArtifacts) {
                    sb.append(String.format("%s:%s:%s,", at.getGroupId(), at.getArtifactId(),
                            at.getVersion()));
                }
                getLog().warn(sb.subSequence(0, sb.length() - 1));
            }
        }
    } catch (DependencyTreeBuilderException e) {
        throw new MojoExecutionException("Cannot build project dependency ", e);
    }
}
 

import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException; //导入依赖的package包/类
protected Set<Artifact> getFrameworkDependencyArtifacts( Set<?> classPathArtifacts, Artifact frameworkJarArtifact )
    throws DependencyTreeBuilderException
{
    Set<Artifact> result = getDependencyArtifactsExt( classPathArtifacts, frameworkJarArtifact );
    return result;
}
 

import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException; //导入依赖的package包/类
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
    try {
        // find the nar dependency
        Artifact narArtifact = null;
        for (final Artifact artifact : project.getDependencyArtifacts()) {
            if (NAR.equals(artifact.getType())) {
                // ensure the project doesn't have two nar dependencies
                if (narArtifact != null) {
                    throw new MojoExecutionException("Project can only have one NAR dependency.");
                }

                // record the nar dependency
                narArtifact = artifact;
            }
        }

        // ensure there is a nar dependency
        if (narArtifact == null) {
            throw new MojoExecutionException("Project does not have any NAR dependencies.");
        }

        // build the project for the nar artifact
        final ProjectBuildingRequest narRequest = new DefaultProjectBuildingRequest();
        narRequest.setRepositorySession(repoSession);
        narRequest.setSystemProperties(System.getProperties());
        final ProjectBuildingResult narResult = projectBuilder.build(narArtifact, narRequest);

        // get the artifact handler for excluding dependencies
        final ArtifactHandler narHandler = excludesDependencies(narArtifact);
        narArtifact.setArtifactHandler(narHandler);

        // nar artifacts by nature includes dependencies, however this prevents the
        // transitive dependencies from printing using tools like dependency:tree.
        // here we are overriding the artifact handler for all nars so the
        // dependencies can be listed. this is important because nar dependencies
        // will be used as the parent classloader for this nar and seeing what
        // dependencies are provided is critical.
        final Map<String, ArtifactHandler> narHandlerMap = new HashMap<>();
        narHandlerMap.put(NAR, narHandler);
        artifactHandlerManager.addHandlers(narHandlerMap);

        // get the dependency tree
        final DependencyNode root = dependencyTreeBuilder.buildDependencyTree(narResult.getProject(), localRepository, null);

        // write the appropriate output
        DependencyNodeVisitor visitor = null;
        if ("tree".equals(mode)) {
            visitor = new TreeWriter();
        } else if ("pom".equals(mode)) {
            visitor = new PomWriter();
        }

        // ensure the mode was specified correctly
        if (visitor == null) {
            throw new MojoExecutionException("The specified mode is invalid. Supported options are 'tree' and 'pom'.");
        }

        // visit and print the results
        root.accept(visitor);
        getLog().info("--- Provided NAR Dependencies ---\n\n" + visitor.toString());
    } catch (DependencyTreeBuilderException | ProjectBuildingException e) {
        throw new MojoExecutionException("Cannot build project dependency tree", e);
    }
}
 

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