Java FilterArtifacts类代码示例

import org.apache.maven.shared.artifact.filter.collection.FilterArtifacts; //导入依赖的package包/类
/**
 * Filter the marked dependencies
 * 
 * @param artifacts
 * @return
 * @throws MojoExecutionException
 */
protected DependencyStatusSets filterMarkedDependencies( Set artifacts )
    throws MojoExecutionException
{
    // remove files that have markers already
    FilterArtifacts filter = new FilterArtifacts();
    filter.clearFilters();
    filter.addFilter( getMarkedArtifactFilter() );

    Set unMarkedArtifacts;
    try
    {
        unMarkedArtifacts = filter.filter( artifacts );
    }
    catch ( ArtifactFilterException e )
    {
        throw new MojoExecutionException(e.getMessage(),e);
    }

    // calculate the skipped artifacts
    Set skippedArtifacts = new HashSet();
    skippedArtifacts.addAll( artifacts );
    skippedArtifacts.removeAll( unMarkedArtifacts );

    return new DependencyStatusSets( unMarkedArtifacts, null, skippedArtifacts );
}
 

import org.apache.maven.shared.artifact.filter.collection.FilterArtifacts; //导入依赖的package包/类
@Override
protected Set<Artifact> filterDependencies(Set<Artifact> dependencies,
                                           FilterArtifacts filters) throws MojoExecutionException {
    try {
        Set<Artifact> filtered = new LinkedHashSet<Artifact>(dependencies);

        @SuppressWarnings("unchecked")
        Collection<ArtifactsFilter> filtersToUse = filters.getFilters();
        filtersToUse.addAll(getAdditionalFilters());

        filtered.retainAll(filters.filter(dependencies));
        return filtered;
    }
    catch (ArtifactFilterException ex) {
        throw new MojoExecutionException(ex.getMessage(), ex);
    }
}
 

import org.apache.maven.shared.artifact.filter.collection.FilterArtifacts; //导入依赖的package包/类
/**
 * Return artifact filters configured for this MOJO.
 * @param additionalFilters optional additional filters to apply
 * @return the filters
 */
protected final FilterArtifacts getFilters(ArtifactsFilter... additionalFilters) {
	FilterArtifacts filters = new FilterArtifacts();
	for (ArtifactsFilter additionalFilter : additionalFilters) {
		filters.addFilter(additionalFilter);
	}
	filters.addFilter(
			new ArtifactIdFilter("", cleanFilterConfig(this.excludeArtifactIds)));
	filters.addFilter(
			new MatchingGroupIdFilter(cleanFilterConfig(this.excludeGroupIds)));
	if (this.includes != null && !this.includes.isEmpty()) {
		filters.addFilter(new IncludeFilter(this.includes));
	}
	if (this.excludes != null && !this.excludes.isEmpty()) {
		filters.addFilter(new ExcludeFilter(this.excludes));
	}
	return filters;
}
 

import org.apache.maven.shared.artifact.filter.collection.FilterArtifacts; //导入依赖的package包/类
protected DependencyStatusSets filterMarkedDependencies(Set artifacts) throws MojoExecutionException {
    // remove files that have markers already
    FilterArtifacts filter = new FilterArtifacts();
    filter.clearFilters();
    filter.addFilter(getMarkedArtifactFilter());

    Set unMarkedArtifacts;
    try {
        unMarkedArtifacts = filter.filter(artifacts);
    } catch (ArtifactFilterException e) {
        throw new MojoExecutionException(e.getMessage(), e);
    }

    // calculate the skipped artifacts
    Set skippedArtifacts = new HashSet();
    skippedArtifacts.addAll(artifacts);
    skippedArtifacts.removeAll(unMarkedArtifacts);

    return new DependencyStatusSets(unMarkedArtifacts, null, skippedArtifacts);
}
 

import org.apache.maven.shared.artifact.filter.collection.FilterArtifacts; //导入依赖的package包/类
/**
 * This method resolves the plugin artifacts from the project.
 *
 * @return set of resolved plugin artifacts.
 * @throws ArtifactResolutionException
 * @throws ArtifactNotFoundException
 * @throws ArtifactFilterException 
 */
@SuppressWarnings( "unchecked" )
protected Set<Artifact> resolvePluginArtifacts()
    throws ArtifactResolutionException, ArtifactNotFoundException, ArtifactFilterException
{
    final Set<Artifact> plugins = project.getPluginArtifacts();
    final Set<Artifact> reports = project.getReportArtifacts();

    Set<Artifact> artifacts = new HashSet<Artifact>();
    artifacts.addAll( reports );
    artifacts.addAll( plugins );

    final FilterArtifacts filter = getPluginArtifactsFilter();
    artifacts = filter.filter( artifacts );

    //        final ArtifactFilter filter = getPluginFilter();
    for ( final Artifact artifact : new HashSet<Artifact>( artifacts ) )
    {
        // resolve the new artifact
        this.resolver.resolve( artifact, this.remotePluginRepositories, this.getLocal() );
    }
    return artifacts;
}
 

import org.apache.maven.shared.artifact.filter.collection.FilterArtifacts; //导入依赖的package包/类
/**
 * 
 * Method creates filters and filters the projects dependencies. This method
 * also transforms the dependencies if classifier is set. The dependencies
 * are filtered in least specific to most specific order
 * 
 * @param stopOnFailure
 * @return DependencyStatusSets - Bean of TreeSets that contains information
 *         on the projects dependencies
 * @throws MojoExecutionException 
 */
protected DependencyStatusSets getDependencySets( boolean stopOnFailure )
    throws MojoExecutionException
{
    // add filters in well known order, least specific to most specific
    FilterArtifacts filter = new FilterArtifacts();

    filter.addFilter( new TransitivityFilter( project.getDependencyArtifacts(), this.excludeTransitive ) );
    filter.addFilter( new ScopeFilter( this.includeScope, this.excludeScope ) );
    filter.addFilter( new TypeFilter( this.includeTypes, this.excludeTypes ) );
    filter.addFilter( new ClassifierFilter( this.includeClassifiers, this.excludeClassifiers ) );
    filter.addFilter( new GroupIdFilter( this.includeGroupIds, this.excludeGroupIds ) );
    filter.addFilter( new ArtifactIdFilter( this.includeArtifactIds, this.excludeArtifactIds ) );

    // start with all artifacts.
    Set artifacts = project.getArtifacts();

    // perform filtering
    try
    {
        artifacts = filter.filter( artifacts );
    }
    catch ( ArtifactFilterException e )
    {
        throw new MojoExecutionException(e.getMessage(),e);
    }

    // transform artifacts if classifier is set
    DependencyStatusSets status = null;
    if ( StringUtils.isNotEmpty( classifier ) )
    {
        status = getClassifierTranslatedDependencies( artifacts, stopOnFailure );
    }
    else
    {
        status = filterMarkedDependencies( artifacts );
    }

    return status;
}
 

import org.apache.maven.shared.artifact.filter.collection.FilterArtifacts; //导入依赖的package包/类
@SuppressWarnings("unchecked")
protected Set<Artifact> filterDependencies(Set<Artifact> dependencies,
		FilterArtifacts filters) throws MojoExecutionException {
	try {
		return filters.filter(dependencies);
	}
	catch (ArtifactFilterException e) {
		throw new MojoExecutionException(e.getMessage(), e);
	}
}
 

import org.apache.maven.shared.artifact.filter.collection.FilterArtifacts; //导入依赖的package包/类
private void addDependencies(List<URL> urls)
		throws MalformedURLException, MojoExecutionException {
	FilterArtifacts filters = this.useTestClasspath ? getFilters()
			: getFilters(new TestArtifactFilter());
	Set<Artifact> artifacts = filterDependencies(this.project.getArtifacts(),
			filters);
	for (Artifact artifact : artifacts) {
		if (artifact.getFile() != null) {
			urls.add(artifact.getFile().toURI().toURL());
		}
	}
}
 

import org.apache.maven.shared.artifact.filter.collection.FilterArtifacts; //导入依赖的package包/类
@Override
protected Set<Artifact> filterDependencies(Set<Artifact> dependencies,
                                           FilterArtifacts filters) throws MojoExecutionException {
    try {
        Set<Artifact> filtered = new LinkedHashSet<Artifact>(dependencies);

        filters.getFilters().addAll(getAdditionalFilters());

        filtered.retainAll(filters.filter(dependencies));
        return filtered;
    }
    catch (ArtifactFilterException ex) {
        throw new MojoExecutionException(ex.getMessage(), ex);
    }
}
 

import org.apache.maven.shared.artifact.filter.collection.FilterArtifacts; //导入依赖的package包/类
protected DependencyStatusSets getDependencySets(boolean stopOnFailure) throws MojoExecutionException {
    // add filters in well known order, least specific to most specific
    FilterArtifacts filter = new FilterArtifacts();

    filter.addFilter(new ProjectTransitivityFilter(project.getDependencyArtifacts(), false));
    filter.addFilter(new ScopeFilter(this.includeScope, this.excludeScope));
    filter.addFilter(new TypeFilter(this.includeTypes, this.excludeTypes));
    filter.addFilter(new ClassifierFilter(this.includeClassifiers, this.excludeClassifiers));
    filter.addFilter(new GroupIdFilter(this.includeGroupIds, this.excludeGroupIds));
    filter.addFilter(new ArtifactIdFilter(this.includeArtifactIds, this.excludeArtifactIds));

    // explicitly filter our nar dependencies
    filter.addFilter(new TypeFilter("", "nar"));

    // start with all artifacts.
    Set artifacts = project.getArtifacts();

    // perform filtering
    try {
        artifacts = filter.filter(artifacts);
    } catch (ArtifactFilterException e) {
        throw new MojoExecutionException(e.getMessage(), e);
    }

    // transform artifacts if classifier is set
    final DependencyStatusSets status;
    if (StringUtils.isNotEmpty(copyDepClassifier)) {
        status = getClassifierTranslatedDependencies(artifacts, stopOnFailure);
    } else {
        status = filterMarkedDependencies(artifacts);
    }

    return status;
}
 

import org.apache.maven.shared.artifact.filter.collection.FilterArtifacts; //导入依赖的package包/类
private NarDependency getNarDependency() throws MojoExecutionException {
    NarDependency narDependency = null;

    // get nar dependencies
    FilterArtifacts filter = new FilterArtifacts();
    filter.addFilter(new TypeFilter("nar", ""));

    // start with all artifacts.
    Set artifacts = project.getArtifacts();

    // perform filtering
    try {
        artifacts = filter.filter(artifacts);
    } catch (ArtifactFilterException e) {
        throw new MojoExecutionException(e.getMessage(), e);
    }

    // ensure there is a single nar dependency
    if (artifacts.size() > 1) {
        throw new MojoExecutionException("Each NAR represents a ClassLoader. A NAR dependency allows that NAR's ClassLoader to be "
                + "used as the parent of this NAR's ClassLoader. As a result, only a single NAR dependency is allowed.");
    } else if (artifacts.size() == 1) {
        final Artifact artifact = (Artifact) artifacts.iterator().next();

        narDependency = new NarDependency(artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion());
    }

    return narDependency;
}
 

import org.apache.maven.shared.artifact.filter.collection.FilterArtifacts; //导入依赖的package包/类
private URL[] getIndexPath()
{
    final List<URL> indexPath = new ArrayList<URL>();
    appendToClassPath( indexPath, outputDirectory );
    if ( includeDependencies )
    {
        final FilterArtifacts filter = new FilterArtifacts();

        filter.addFilter( new ProjectTransitivityFilter( project.getDependencyArtifacts(), excludeTransitive ) );
        filter.addFilter( new ScopeFilter( cleanList( includeScope ), cleanList( excludeScope ) ) );
        filter.addFilter( new TypeFilter( cleanList( includeTypes ), cleanList( excludeTypes ) ) );
        filter.addFilter( new ClassifierFilter( cleanList( includeClassifiers ), cleanList( excludeClassifiers ) ) );
        filter.addFilter( new GroupIdFilter( cleanList( includeGroupIds ), cleanList( excludeGroupIds ) ) );
        filter.addFilter( new ArtifactIdFilter( cleanList( includeArtifactIds ), cleanList( excludeArtifactIds ) ) );

        try
        {
            for ( final Object artifact : filter.filter( project.getArtifacts() ) )
            {
                appendToClassPath( indexPath, ( (Artifact) artifact ).getFile() );
            }
        }
        catch ( final ArtifactFilterException e )
        {
            getLog().warn( e.getLocalizedMessage() );
        }
    }
    return indexPath.toArray( new URL[indexPath.size()] );
}