Java ArtifactFilter類代碼示例

import org.apache.maven.artifact.resolver.filter.ArtifactFilter; //導入依賴的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.artifact.resolver.filter.ArtifactFilter; //導入依賴的package包/類
private ArtifactResolutionResult createArtifactResolutionResult( Collection<Artifact> artifacts, List<Artifact> missingArtifacts, ArtifactResolutionException exception, ArtifactFilter filter ) {
   ArtifactResolutionResult result = new ArtifactResolutionResult();
   Set<Artifact> strippedArtifacts = new HashSet<Artifact>( artifacts );
   if( OptionalArtifactFilter.INSTANCE.equals( filter ) ){
      Iterator<Artifact> artifactItr = strippedArtifacts.iterator();
      while( artifactItr.hasNext() ){
         boolean include = OptionalArtifactFilter.INSTANCE.include( artifactItr.next() );
         if( !include ){
            artifactItr.remove();
         }
      }
   }
   result.setArtifacts( new HashSet<Artifact>( strippedArtifacts ) );
   if( missingArtifacts != null ){
      result.setUnresolvedArtifacts( missingArtifacts );
   }
   if( exception != null ){
      result.addErrorArtifactException( exception );
   }
   return result;
}
 

import org.apache.maven.artifact.resolver.filter.ArtifactFilter; //導入依賴的package包/類
public ArtifactResolutionResult resolveTransitively( Set<Artifact> artifacts, Artifact originatingArtifact, Map managedVersions, ArtifactRepository localRepository,
                                                     List<ArtifactRepository> remoteRepositories, ArtifactMetadataSource source, ArtifactFilter filter, List<ResolutionListener> listeners,
                                                     List<ConflictResolver> conflictResolvers )
  throws ArtifactResolutionException, ArtifactNotFoundException
{
  ArtifactResolutionRequest request = new ArtifactResolutionRequest()
    .setArtifact( originatingArtifact )
    .setResolveRoot( false )
      // This is required by the surefire plugin
    .setArtifactDependencies( artifacts )
    .setManagedVersionMap( managedVersions )
    .setLocalRepository( localRepository )
    .setRemoteRepositories( remoteRepositories )
    .setCollectionFilter( filter )
    .setListeners( listeners );

  injectSession2( request, legacySupport.getSession() );

  return resolveWithExceptions( request );
}
 

import org.apache.maven.artifact.resolver.filter.ArtifactFilter; //導入依賴的package包/類
public ArtifactResolutionResult resolveTransitively( Set<Artifact> artifacts, Artifact originatingArtifact,
                                                     Map managedVersions, ArtifactRepository localRepository,
                                                     List<ArtifactRepository> remoteRepositories,
                                                     ArtifactMetadataSource source, ArtifactFilter filter,
                                                     List<ResolutionListener> listeners,
                                                     List<ConflictResolver> conflictResolvers )
  throws ArtifactResolutionException, ArtifactNotFoundException
{
  ArtifactResolutionRequest request = new ArtifactResolutionRequest()
    .setArtifact( originatingArtifact )
    .setResolveRoot( false )
      // This is required by the surefire plugin
    .setArtifactDependencies( artifacts )
    .setManagedVersionMap( managedVersions )
    .setLocalRepository( localRepository )
    .setRemoteRepositories( remoteRepositories )
    .setCollectionFilter( filter )
    .setListeners( listeners );

  injectSession2( request, legacySupport.getSession() );

  return resolveWithExceptions( request );
}
 

import org.apache.maven.artifact.resolver.filter.ArtifactFilter; //導入依賴的package包/類
private List<File> getCompilerDependencies( Artifact scalaCompilerArtifact, Artifact scalaLibraryArtifact )
    throws ArtifactNotFoundException, ArtifactResolutionException
{
    ArtifactFilter scalaLibraryFilter =
        new ExcludesArtifactFilter( Collections.singletonList( scalaLibraryArtifact.getGroupId() + ":"
            + scalaLibraryArtifact.getArtifactId() ) );
    List<File> d = new ArrayList<File>();
    for ( Artifact artifact : getAllDependencies( scalaCompilerArtifact, scalaLibraryFilter ) )
    {
        if ( !scalaCompilerArtifact.getGroupId().equals( artifact.getGroupId() )
            || !scalaCompilerArtifact.getArtifactId().equals( artifact.getArtifactId() ) )
        {
            d.add( artifact.getFile() ); // don't add scalaCompilerArtifact file
        }
    }
    return d;
}
 

import org.apache.maven.artifact.resolver.filter.ArtifactFilter; //導入依賴的package包/類
private ArtifactFilter createArtifactFilter() {
  List<ArtifactFilter> filters = new ArrayList<>(3);

  if (this.scope != null) {
    filters.add(new ScopeArtifactFilter(this.scope));
  }

  if (!this.includes.isEmpty()) {
    filters.add(new StrictPatternIncludesArtifactFilter(this.includes));
  }

  if (!this.excludes.isEmpty()) {
    filters.add(new StrictPatternExcludesArtifactFilter(this.excludes));
  }

  return new AndArtifactFilter(filters);
}
 

import org.apache.maven.artifact.resolver.filter.ArtifactFilter; //導入依賴的package包/類
/**
 * Detects the GWT modules that should be excluded from the IDE GWT app.
 *
 * @return detected GWT modules
 */
private Set<String> detectExcludedGwtModules() throws IOException {
  Set<String> modules = new HashSet<>();

  ArtifactFilter dependencyFilter = fullIdeArtifact.getDependencyFilter();

  if (dependencyFilter instanceof ExcludesArtifactFilter) {
    ExcludesArtifactFilter excludesDependencyFilter = (ExcludesArtifactFilter) dependencyFilter;

    for (String pattern : excludesDependencyFilter.getPatterns()) {
      String[] split = pattern.split(":");
      String groupId = split[0];
      String artifactId = split[1];
      String version = fullIdeArtifact.getVersion();

      Artifact artifact = repositorySystem.createArtifact(groupId, artifactId, version, "jar");
      String gwtModule = readGwtModuleName(artifact);

      modules.add(gwtModule);

      getLog().info("Detected GWT module to exclude: " + gwtModule);
    }
  }

  return modules;
}
 

import org.apache.maven.artifact.resolver.filter.ArtifactFilter; //導入依賴的package包/類
public ArtifactResolutionResult resolveTransitively(
    Set<Artifact> artifacts,
    Artifact originatingArtifact,
    ArtifactRepository localRepository,
    List<ArtifactRepository> remoteRepositories,
    ArtifactMetadataSource source,
    ArtifactFilter filter)
    throws ArtifactResolutionException, ArtifactNotFoundException {
  return resolveTransitively(
      artifacts,
      originatingArtifact,
      Collections.EMPTY_MAP,
      localRepository,
      remoteRepositories,
      source,
      filter);
}
 

import org.apache.maven.artifact.resolver.filter.ArtifactFilter; //導入依賴的package包/類
/**
 * Determine if the artifact is included in the list of artifacts to be processed.
 *
 * @param artifact The artifact we want to check.
 * @return true if the artifact should be processed, false otherwise.
 */
protected boolean isIncluded( Artifact artifact )
{
    boolean result = true;

    ArtifactFilter includesFilter = this.getIncludesArtifactFilter();

    if ( includesFilter != null )
    {
        result = includesFilter.include( artifact );
    }

    ArtifactFilter excludesFilter = this.getExcludesArtifactFilter();

    if ( excludesFilter != null )
    {
        result = result && excludesFilter.include( artifact );
    }

    return result;
}
 

import org.apache.maven.artifact.resolver.filter.ArtifactFilter; //導入依賴的package包/類
public Set<Artifact> resolve(String groupId, String artifactId, String version, final String exclusion)
        throws MojoExecutionException {
    ArtifactResolutionRequest request = new ArtifactResolutionRequest()
        .setResolveTransitively(true)
        .setResolveRoot(true)
        .setArtifact(system.createArtifact(groupId, artifactId, version, "jar"))
        .setLocalRepository(this.localRepo)
        .setRemoteRepositories(remoteRepos).setCollectionFilter(new ArtifactFilter() {
            
            @Override
            public boolean include(Artifact artifact) {
                if (exclusion != null && 
                        (artifact.getGroupId() + ":" + artifact.getArtifactId()).equals(exclusion)) {
                    return false;
                }
                return artifact.getScope() == null || artifact.getScope().equals("compile") || artifact.getScope().equals("runtime");
            }
        });

    ArtifactResolutionResult result = system.resolve(request);  
    // TODO error handling
    return result.getArtifacts();
}
 

import org.apache.maven.artifact.resolver.filter.ArtifactFilter; //導入依賴的package包/類
/**
 * @param pattern   pattern to test over artifacts
 * @param artifacts collection of artifacts to check
 * @return true if filter matches no artifact, false otherwise *
 */
private boolean ensurePatternMatchesAtLeastOneArtifact( String pattern, Collection<Artifact> artifacts )
{
    List<String> onePatternList = new ArrayList<>();
    onePatternList.add( pattern );
    ArtifactFilter filter = new IncludesArtifactFilter( onePatternList );

    boolean noMatch = true;
    for ( Artifact artifact : artifacts )
    {
        getLog().debug( "checking pattern: " + pattern + " against " + artifact );

        if ( filter.include( artifact ) )
        {
            noMatch = false;
            break;
        }
    }
    if ( noMatch )
    {
        getLog().error( "pattern: " + pattern + " doesn't match any artifact." );
    }
    return noMatch;
}
 

import org.apache.maven.artifact.resolver.filter.ArtifactFilter; //導入依賴的package包/類
/**
 * Iterate through all the extensions dependencies declared in the project and
 * collect all the runtime scope dependencies for inclusion in the .zip and just
 * copy them to the lib directory.
 * <p>
 * TODO, should check that all dependencies are well signed with the same
 * extension with the same signer.
 *
 * @throws MojoExecutionException
 */
private void processExtensionsDependencies()
        throws MojoExecutionException
{

    Collection<Artifact> artifacts =
            isExcludeTransitive() ? getProject().getDependencyArtifacts() : getProject().getArtifacts();

    for ( JnlpExtension extension : jnlpExtensions )
    {
        ArtifactFilter filter = new IncludesArtifactFilter( extension.getIncludes() );

        for ( Artifact artifact : artifacts )
        {
            if ( filter.include( artifact ) )
            {
                processExtensionDependency( extension, artifact );
            }
        }
    }
}
 

import org.apache.maven.artifact.resolver.filter.ArtifactFilter; //導入依賴的package包/類
/**
 * Determine if the artifact is included in the list of artifacts to be processed.
 *
 * @param artifact The artifact we want to check.
 * @return true if the artifact should be processed, false otherwise.
 */
protected boolean isIncluded( Artifact artifact )
{
    boolean result = true;

    ArtifactFilter includesFilter = this.getIncludesArtifactFilter();

    if ( includesFilter != null )
    {
        result = includesFilter.include( artifact );
    }

    ArtifactFilter excludesFilter = this.getExcludesArtifactFilter();

    if ( excludesFilter != null )
    {
        result = result && excludesFilter.include( artifact );
    }

    return result;

}
 

import org.apache.maven.artifact.resolver.filter.ArtifactFilter; //導入依賴的package包/類
@Override
protected GraphFactory createGraphFactory(ArtifactFilter globalFilter, ArtifactFilter transitiveIncludeExcludeFilter, ArtifactFilter targetFilter, GraphStyleConfigurer graphStyleConfigurer) {

  DependencyNodeIdRenderer nodeIdRenderer = DependencyNodeIdRenderer
      .groupId()
      .withScope(!this.mergeScopes);

  GraphBuilder<DependencyNode> graphBuilder = graphStyleConfigurer
      .showGroupIds(true)
      .showArtifactIds(false)
      .showTypes(false)
      .showClassifiers(false)
      .showVersionsOnNodes(false)
      .showVersionsOnEdges(false)
      .repeatTransitiveDependencies(this.repeatTransitiveDependenciesInTextGraph)
      .configure(GraphBuilder.create(nodeIdRenderer))
      .omitSelfReferences();

  MavenGraphAdapter adapter = new MavenGraphAdapter(this.dependencyGraphBuilder, transitiveIncludeExcludeFilter, targetFilter, this.reduceEdges);

  return new AggregatingGraphFactory(adapter, createReactorOrderSubProjectSupplier(), globalFilter, graphBuilder, true);
}
 

import org.apache.maven.artifact.resolver.filter.ArtifactFilter; //導入依賴的package包/類
@Override
protected GraphFactory createGraphFactory(ArtifactFilter globalFilter, ArtifactFilter transitiveIncludeExcludeFilter, ArtifactFilter targetFilter, GraphStyleConfigurer graphStyleConfigurer) {

  GraphBuilder<DependencyNode> graphBuilder = graphStyleConfigurer
      .showGroupIds(true)
      .showArtifactIds(false)
      .showTypes(false)
      .showClassifiers(false)
      .showVersionsOnNodes(false)
      .showVersionsOnEdges(false)
      .configure(GraphBuilder.create(DependencyNodeIdRenderer.groupId().withScope(true)))
      .omitSelfReferences();

  MavenGraphAdapter adapter = new MavenGraphAdapter(this.dependencyTreeBuilder, this.localRepository, transitiveIncludeExcludeFilter, targetFilter, allOf(NodeResolution.class));
  return new SimpleGraphFactory(adapter, globalFilter, graphBuilder);
}