Java MavenResourcesExecution类代码示例

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
    initializeHandlers();

    for (AppBuildHandler appBuildHandler : appBuildHandlers) {
        appBuildHandler.handle();
    }

    final Build build = project.getBuild();
    final List<String> nonFilteredFileExtensions = getNonFilteredFileExtensions(build.getPlugins());


    MavenResourcesExecution mavenResourcesExecution =
            new MavenResourcesExecution(build.getResources(), new File(outputDirectory), project,
                    ENCODING, build.getFilters(), nonFilteredFileExtensions, session);

    try {
        mavenResourcesFiltering.filterResources(mavenResourcesExecution);
    } catch (MavenFilteringException e) {
        throw new WMRuntimeException("Failed to execute resource filtering ", e);
    }
}
 

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
protected void executeUserFilterComponents(MavenResourcesExecution mavenResourcesExecution)
		throws MojoExecutionException, MavenFilteringException {

	if (mavenFilteringHints != null) {
		for (String hint : mavenFilteringHints) {
			try {
				mavenFilteringComponents.add((MavenResourcesFiltering) plexusContainer
						.lookup(MavenResourcesFiltering.class.getName(), hint));
			} catch (ComponentLookupException e) {
				throw new MojoExecutionException(e.getMessage(), e);
			}
		}
	} else {
		getLog().debug("no use filter components");
	}

	if (mavenFilteringComponents != null && !mavenFilteringComponents.isEmpty()) {
		getLog().debug("execute user filters");
		for (MavenResourcesFiltering filter : mavenFilteringComponents) {
			filter.filterResources(mavenResourcesExecution);
		}
	}
}
 

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
@Test
public void testExecute()
    throws MojoExecutionException, MavenFilteringException
{
    // given
    doAnswer( new MockCopyAnswer() ).when( mavenResourcesFiltering ).filterResources( any( MavenResourcesExecution.class ) );

    // when
    mojo.execute();
    assertThat( mojo.countCopiedFiles() ).isEqualTo( 1 );
    mojo.execute();
    assertThat( mojo.countCopiedFiles() ).isEqualTo( 0 );

    // then
    verify( mavenResourcesFiltering, times( 2 ) ).filterResources( any( MavenResourcesExecution.class ) );
    verify( buildContext, times( 1 ) ).refresh( outputDirectory );
    verify( project, times( 2 ) ).addCompileSourceRoot( outputDirectory.getAbsolutePath() );
}
 

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
private void copyNbmResources()
    throws MojoExecutionException
{
    try
    {
        if ( StringUtils.isEmpty( encoding ) && isFilteringEnabled( nbmResources ) )
        {
            getLog().warn( "File encoding has not been set, using platform encoding " + ReaderFactory.FILE_ENCODING
                               + ", i.e. build is platform dependent!" );
        }
        MavenResourcesExecution mavenResourcesExecution =
            new MavenResourcesExecution( Arrays.asList( nbmResources ), clusterDir, project, encoding,
                                         Collections.EMPTY_LIST, Collections.EMPTY_LIST, session );
        mavenResourcesExecution.setEscapeWindowsPaths( true );
        mavenResourcesFiltering.filterResources( mavenResourcesExecution );
    }
    catch ( MavenFilteringException ex )
    {
        throw new MojoExecutionException( ex.getMessage(), ex );
    }
}
 

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
private static void filterAndCopy(AbstractWisdomMojo mojo, MavenResourcesFiltering filtering, File in, File out) throws IOException {
    Resource resource = new Resource();
    resource.setDirectory(in.getAbsolutePath());
    resource.setFiltering(true);
    resource.setTargetPath(out.getAbsolutePath());

    List<String> excludedExtensions = new ArrayList<>();
    excludedExtensions.addAll(filtering.getDefaultNonFilteredFileExtensions());
    excludedExtensions.addAll(NON_FILTERED_EXTENSIONS);

    MavenResourcesExecution exec = new MavenResourcesExecution(ImmutableList.of(resource), out, mojo.project,
            "UTF-8", Collections.<String>emptyList(), excludedExtensions, mojo.session);
    exec.setEscapeString("\\");

    try {
        filtering.filterResources(exec);
    } catch (MavenFilteringException e) {
        throw new IOException("Error while copying resources", e);
    }
}
 

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
/**
 * @param mavenResourcesExecution {@link MavenResourcesExecution}
 * @throws MojoExecutionException  in case of wrong lookup.
 * @throws MavenFilteringException in case of failure.
 * @since 2.5
 */
protected void executeUserFilterComponents(MavenResourcesExecution mavenResourcesExecution)
        throws MojoExecutionException, MavenFilteringException {

    if (mavenFilteringHints != null) {
        for (String hint : mavenFilteringHints) {
            try {
                // CHECKSTYLE_OFF: LineLength
                mavenFilteringComponents.add((MavenResourcesFiltering) plexusContainer.lookup(MavenResourcesFiltering.class.getName(), hint));
                // CHECKSTYLE_ON: LineLength
            } catch (ComponentLookupException e) {
                throw new MojoExecutionException(e.getMessage(), e);
            }
        }
    } else {
        getLog().debug("no use filter components");
    }

    if (mavenFilteringComponents != null && !mavenFilteringComponents.isEmpty()) {
        getLog().debug("execute user filters");
        for (MavenResourcesFiltering filter : mavenFilteringComponents) {
            filter.filterResources(mavenResourcesExecution);
        }
    }
}
 

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
/**
 * Copy resources to target directory using Maven resource filtering so that we don't have to handle
 * recursive directory listing and pattern matching.
 * In order to disable filtering, the "filtering" property is force set to False.
 *
 * @param project
 * @param session
 * @param filtering
 * @param resources
 * @param targetDirectory
 * @throws IOException
 */
public static void copyResources(final MavenProject project, final MavenSession session,
                                 final MavenResourcesFiltering filtering, final List<Resource> resources,
                                 final String targetDirectory) throws IOException {
    for (final Resource resource : resources) {
        resource.setTargetPath(Paths.get(targetDirectory, resource.getTargetPath()).toString());
        resource.setFiltering(false);
    }

    final MavenResourcesExecution mavenResourcesExecution = new MavenResourcesExecution(
            resources,
            new File(targetDirectory),
            project,
            "UTF-8",
            null,
            Collections.EMPTY_LIST,
            session
    );

    // Configure executor
    mavenResourcesExecution.setEscapeWindowsPaths(true);
    mavenResourcesExecution.setInjectProjectBuildFilters(false);
    mavenResourcesExecution.setOverwrite(true);
    mavenResourcesExecution.setIncludeEmptyDirs(false);
    mavenResourcesExecution.setSupportMultiLineFiltering(false);

    // Filter resources
    try {
        filtering.filterResources(mavenResourcesExecution);
    } catch (MavenFilteringException ex) {
        throw new IOException("Failed to copy resources", ex);
    }
}
 

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
@Test
public void copyResources() throws Exception {
    final MavenResourcesFiltering filtering = mock(MavenResourcesFiltering.class);
    final Resource resource = new Resource();
    resource.setTargetPath("/");

    Utils.copyResources(mock(MavenProject.class),
            mock(MavenSession.class),
            filtering,
            Arrays.asList(new Resource[] {resource}),
            "target");
    verify(filtering, times(1)).filterResources(any(MavenResourcesExecution.class));
    verifyNoMoreInteractions(filtering);
}
 

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
private void filterSourceToTemporaryDir( final File sourceDirectory, final File temporaryDirectory )
    throws MojoExecutionException
{
    List<Resource> resources = new ArrayList<Resource>();
    Resource resource = new Resource();
    resource.setFiltering( true );
    logDebug( "Source absolute path: %s", sourceDirectory.getAbsolutePath() );
    resource.setDirectory( sourceDirectory.getAbsolutePath() );
    resources.add( resource );

    MavenResourcesExecution mavenResourcesExecution =
        new MavenResourcesExecution( resources, temporaryDirectory, project, encoding,
                                     Collections.<String>emptyList(), Collections.<String>emptyList(), session );
    mavenResourcesExecution.setInjectProjectBuildFilters( true );
    mavenResourcesExecution.setEscapeString( escapeString );
    mavenResourcesExecution.setOverwrite( overwrite );
    setDelimitersForExecution( mavenResourcesExecution );
    try
    {
        mavenResourcesFiltering.filterResources( mavenResourcesExecution );
    }
    catch ( MavenFilteringException e )
    {
        buildContext.addMessage( getSourceDirectory(), 1, 1, "Filtering Exception", BuildContext.SEVERITY_ERROR,
                                 e );
        throw new MojoExecutionException( e.getMessage(), e );
    }
}
 

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
private void setDelimitersForExecution( MavenResourcesExecution mavenResourcesExecution )
{
    // if these are NOT set, just use the defaults, which are '${*}' and '@'.
    if ( delimiters != null && !delimiters.isEmpty() )
    {
        LinkedHashSet<String> delims = new LinkedHashSet<String>();
        if ( useDefaultDelimiters )
        {
            delims.addAll( mavenResourcesExecution.getDelimiters() );
        }

        for ( String delim : delimiters )
        {
            if ( delim == null )
            {
                // FIXME: ${filter:*} could also trigger this condition. Need a better long-term solution.
                delims.add( "${*}" );
            }
            else
            {
                delims.add( delim );
            }
        }

        mavenResourcesExecution.setDelimiters( delims );
    }
}
 

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
public Void answer( InvocationOnMock invocation )
    throws Throwable
{
    MavenResourcesExecution arg = MavenResourcesExecution.class.cast( invocation.getArguments()[0] );
    File source = new File( arg.getResources().iterator().next().getDirectory() );
    assertThat( source ).exists();
    assertThat( source ).isDirectory();
    File destination = arg.getOutputDirectory();
    assertThat( destination ).doesNotExist();
    FileUtils.copyDirectoryStructure( source, destination );
    return null;
}
 

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
protected void doCopyPreAssembleDirectory( final String targetDirectory )
    throws MojoFailureException
{
    // Create a Resource from the configuration source directory
    Resource resource = new Resource();
    resource.setDirectory( preAssembleDirectory.getAbsolutePath() );
    resource.setFiltering( filterPreAssembleDirectory );
    List<Resource> resources = new ArrayList<Resource>();
    resources.add( resource );

    MavenResourcesExecution mavenResourcesExecution =
        new MavenResourcesExecution( resources, new File( targetDirectory ), mavenProject, encoding, buildFilters,
                                     Collections.<String>emptyList(), session );

    mavenResourcesExecution.setEscapeString( escapeString );
    // Include empty directories, to be backwards compatible
    mavenResourcesExecution.setIncludeEmptyDirs( true );
    mavenResourcesExecution.setUseDefaultFilterWrappers( true );

    try
    {
        getLog().info( "Copy pre-assemble files from " + this.preAssembleDirectory.getAbsolutePath() + " to "
                            + targetDirectory );

        // Use a MavenResourcesFiltering component to filter and copy the configuration files
        mavenResourcesFiltering.filterResources( mavenResourcesExecution );
    }
    catch ( MavenFilteringException mfe )
    {
        throw new MojoFailureException( "Failed to copy/filter the configuration files." );
    }
}
 

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
private void setDelimiters( MavenResourcesExecution mavenResourcesExecution )
{
    // if these are NOT set, just use the defaults, which are '${*}' and '@'.
    if ( delimiters != null && !delimiters.isEmpty() )
    {
        LinkedHashSet<String> delims = new LinkedHashSet<String>();
        if ( useDefaultDelimiters )
        {
            delims.addAll( mavenResourcesExecution.getDelimiters() );
        }

        for ( String delim : delimiters )
        {
            if ( delim == null )
            {
                // FIXME: ${filter:*} could also trigger this condition. Need a better long-term solution.
                delims.add( "${*}" );
            }
            else
            {
                delims.add( delim );
            }
        }

        mavenResourcesExecution.setDelimiters( delims );
    }
}
 

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
/**
 * Copies the file <tt>file</tt> to the directory <tt>dir</tt>, keeping the structure relative to <tt>rel</tt>.
 *
 * @param file                 the file to copy
 * @param rel                  the base 'relative'
 * @param dir                  the directory
 * @param mojo                 the mojo
 * @param filtering            the filtering component
 * @param additionalProperties additional properties
 * @throws IOException if the file cannot be copied.
 */
public static void copyFileToDir(File file, File rel, File dir, AbstractWisdomMojo mojo, MavenResourcesFiltering
        filtering, Properties additionalProperties) throws
        IOException {
    if (filtering == null) {
        File out = computeRelativeFile(file, rel, dir);
        if (out.getParentFile() != null) {
            mojo.getLog().debug("Creating " + out.getParentFile() + " : " + out.getParentFile().mkdirs());
            FileUtils.copyFileToDirectory(file, out.getParentFile());
        } else {
            throw new IOException("Cannot copy file - parent directory not accessible for "
                    + file.getAbsolutePath());
        }
    } else {
        Resource resource = new Resource();
        resource.setDirectory(rel.getAbsolutePath());
        resource.setFiltering(true);
        resource.setTargetPath(dir.getAbsolutePath());
        resource.setIncludes(ImmutableList.of("**/" + file.getName()));

        List<String> excludedExtensions = new ArrayList<>();
        excludedExtensions.addAll(filtering.getDefaultNonFilteredFileExtensions());
        excludedExtensions.addAll(NON_FILTERED_EXTENSIONS);

        MavenResourcesExecution exec = new MavenResourcesExecution(ImmutableList.of(resource), dir, mojo.project,
                "UTF-8", Collections.<String>emptyList(), excludedExtensions, mojo.session);

        if (additionalProperties != null) {
            exec.setAdditionalProperties(additionalProperties);
        }
        exec.setEscapeString("\\");

        try {
            filtering.filterResources(exec);
        } catch (MavenFilteringException e) {
            throw new IOException("Error while copying resources", e);
        }
    }
}
 

import org.apache.maven.shared.filtering.MavenResourcesExecution; //导入依赖的package包/类
/**
 * Builds the webapp for the specified project with the new packaging task thingy
 * <p/>
 * Classes, libraries and tld files are copied to the <tt>webappDirectory</tt> during this phase.
 *
 * @param mavenProject the maven project
 * @param webapplicationDirectory the target directory
 * @throws MojoExecutionException if an error occurred while packaging the webapp
 * @throws MojoFailureException if an unexpected error occurred while packaging the webapp
 * @throws IOException if an error occurred while copying the files
 */
@SuppressWarnings( "unchecked" )
public void buildWebapp( MavenProject mavenProject, File webapplicationDirectory )
    throws MojoExecutionException, MojoFailureException, IOException
{

    WebappStructure cache;
    if ( useCache && cacheFile.exists() )
    {
        // CHECKSTYLE_OFF: LineLength
        cache = new WebappStructure( mavenProject.getDependencies(), webappStructureSerialier.fromXml( cacheFile ) );
        // CHECKSTYLE_ON: LineLength
    }
    else
    {
        cache = new WebappStructure( mavenProject.getDependencies(), null );
    }

    // CHECKSTYLE_OFF: LineLength
    final long startTime = System.currentTimeMillis();
    getLog().info( "Assembling webapp [" + mavenProject.getArtifactId() + "] in [" + webapplicationDirectory + "]" );

    final OverlayManager overlayManager =
        new OverlayManager( overlays, mavenProject, dependentWarIncludes, dependentWarExcludes,
                            currentProjectOverlay );
    final List<WarPackagingTask> packagingTasks = getPackagingTasks( overlayManager );
    // CHECKSTYLE_ON: LineLength
    List<FileUtils.FilterWrapper> defaultFilterWrappers;
    try
    {
        MavenResourcesExecution mavenResourcesExecution = new MavenResourcesExecution();
        mavenResourcesExecution.setEscapeString( escapeString );
        mavenResourcesExecution.setSupportMultiLineFiltering( supportMultiLineFiltering );
        mavenResourcesExecution.setMavenProject( mavenProject );
        if ( filters == null )
        {
            filters = getProject().getBuild().getFilters();
        }
        mavenResourcesExecution.setFilters( filters );
        mavenResourcesExecution.setEscapedBackslashesInFilePath( escapedBackslashesInFilePath );
        mavenResourcesExecution.setMavenSession( this.session );
        mavenResourcesExecution.setEscapeString( this.escapeString );
        mavenResourcesExecution.setSupportMultiLineFiltering( supportMultiLineFiltering );

        defaultFilterWrappers = mavenFileFilter.getDefaultFilterWrappers( mavenResourcesExecution );

    }
    catch ( MavenFilteringException e )
    {
        getLog().error( "fail to build filering wrappers " + e.getMessage() );
        throw new MojoExecutionException( e.getMessage(), e );
    }

    final WarPackagingContext context =
        new DefaultWarPackagingContext( webapplicationDirectory, cache, overlayManager, defaultFilterWrappers,
                                        getNonFilteredFileExtensions(), filteringDeploymentDescriptors,
                                        this.artifactFactory, resourceEncoding, useJvmChmod );
    for ( WarPackagingTask warPackagingTask : packagingTasks )
    {
        warPackagingTask.performPackaging( context );
    }

    // Post packaging
    final List<WarPostPackagingTask> postPackagingTasks = getPostPackagingTasks();
    for ( WarPostPackagingTask task : postPackagingTasks )
    {
        task.performPostPackaging( context );
    }
    getLog().info( "Webapp assembled in [" + ( System.currentTimeMillis() - startTime ) + " msecs]" );

}