Java tutorial
package org.piraso.maven; /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ import org.apache.maven.archiver.MavenArchiveConfiguration; import org.apache.maven.artifact.factory.ArtifactFactory; import org.apache.maven.execution.MavenSession; import org.apache.maven.model.Resource; import org.apache.maven.plugin.AbstractMojo; import org.apache.maven.plugin.MojoExecutionException; import org.apache.maven.plugin.MojoFailureException; import org.apache.maven.plugin.logging.Log; import org.apache.maven.plugins.annotations.Component; import org.apache.maven.plugins.annotations.Parameter; import org.apache.maven.project.MavenProject; import org.apache.maven.shared.filtering.MavenFileFilter; import org.apache.maven.shared.filtering.MavenFilteringException; import org.apache.maven.shared.filtering.MavenResourcesExecution; import org.apache.maven.shared.filtering.MavenResourcesFiltering; import org.codehaus.plexus.archiver.Archiver; import org.codehaus.plexus.archiver.jar.JarArchiver; import org.codehaus.plexus.archiver.manager.ArchiverManager; import org.codehaus.plexus.util.FileUtils; import org.codehaus.plexus.util.StringUtils; import org.piraso.maven.overlay.OverlayManager; import org.piraso.maven.packaging.*; import org.piraso.maven.util.WebappStructure; import org.piraso.maven.util.WebappStructureSerializer; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; /** * Contains common jobs for WAR mojos. * * @version $Id: AbstractWarMojo.java 1391186 2012-09-27 19:36:49Z krosenvold $ */ public abstract class AbstractWarMojo extends AbstractMojo { public static final String DEFAULT_FILE_NAME_MAPPING = "@{artifactId}@-@{version}@.@{extension}@"; public static final String DEFAULT_FILE_NAME_MAPPING_CLASSIFIER = "@{artifactId}@-@{version}@-@{classifier}@.@{extension}@"; private static final String[] EMPTY_STRING_ARRAY = {}; private static final String META_INF = "META-INF"; private static final String WEB_INF = "WEB-INF"; /** * The Maven project. */ @Component private MavenProject project; /** * The directory containing compiled classes. */ @Parameter(defaultValue = "${project.build.outputDirectory}", required = true, readonly = true) private File classesDirectory; /** * Whether a JAR file will be created for the classes in the webapp. Using this optional configuration * parameter will make the compiled classes to be archived into a JAR file * and the classes directory will then be excluded from the webapp. * * @since 2.0.1 */ @Parameter(property = "archiveClasses", defaultValue = "false") private boolean archiveClasses; /** * The encoding to use when copying filtered web resources. * * @since 2.3 */ @Parameter(property = "resourceEncoding", defaultValue = "${project.build.sourceEncoding}") private String resourceEncoding; /** * The JAR archiver needed for archiving the classes directory into a JAR file under WEB-INF/lib. */ @Component(role = Archiver.class, hint = "jar") private JarArchiver jarArchiver; /** * The directory where the webapp is built. */ @Parameter(defaultValue = "${project.build.directory}/${project.build.finalName}", required = true) private File webappDirectory; /** * Single directory for extra files to include in the WAR. This is where * you place your JSP files. */ @Parameter(defaultValue = "${basedir}/src/main/webapp", required = true) private File warSourceDirectory; /** * The list of webResources we want to transfer. */ @Parameter private Resource[] webResources; /** * Filters (property files) to include during the interpolation of the pom.xml. */ @Parameter private List<String> filters; /** * The path to the web.xml file to use. */ @Parameter(property = "maven.war.webxml") private File webXml; /** * The path to a configuration file for the servlet container. Note that * the file name may be different for different servlet containers. * Apache Tomcat uses a configuration file named context.xml. The file will * be copied to the META-INF directory. */ @Parameter(property = "maven.war.containerConfigXML") private File containerConfigXML; /** * Directory to unpack dependent WARs into if needed. */ @Parameter(defaultValue = "${project.build.directory}/war/work", required = true) private File workDirectory; /** * The file name mapping to use when copying libraries and TLDs. If no file mapping is * set (default) the files are copied with their standard names. * * @since 2.1-alpha-1 */ @Parameter private String outputFileNameMapping; /** * The file containing the webapp structure cache. * * @since 2.1-alpha-1 */ @Parameter(defaultValue = "${project.build.directory}/war/work/webapp-cache.xml", required = true) private File cacheFile; /** * Whether the cache should be used to save the status of the webapp * across multiple runs. Experimental feature so disabled by default. * * @since 2.1-alpha-1 */ @Parameter(property = "useCache", defaultValue = "false") private boolean useCache = false; /** */ @Component(role = ArtifactFactory.class) private ArtifactFactory artifactFactory; /** * To look up Archiver/UnArchiver implementations. */ @Component(role = ArchiverManager.class) private ArchiverManager archiverManager; /** */ @Component(role = MavenFileFilter.class, hint = "default") private MavenFileFilter mavenFileFilter; /** */ @Component(role = MavenResourcesFiltering.class, hint = "default") private MavenResourcesFiltering mavenResourcesFiltering; /** * The comma separated list of tokens to include when copying the content * of the warSourceDirectory. */ @Parameter(alias = "includes", defaultValue = "**") private String warSourceIncludes; /** * The comma separated list of tokens to exclude when copying the content * of the warSourceDirectory. */ @Parameter(alias = "excludes") private String warSourceExcludes; /** * The comma separated list of tokens to include when doing * a WAR overlay. * Default is '**' * * @deprecated Use <overlay>/<includes> instead */ @Parameter private String dependentWarIncludes = "**/**"; /** * The comma separated list of tokens to exclude when doing * a WAR overlay. * * @deprecated Use <overlay>/<excludes> instead */ @Parameter private String dependentWarExcludes = "META-INF/**"; /** * The overlays to apply. * * Each <overlay> element may contain: * <ul> * <li>id (defaults to <tt>currentBuild</tt>)</li> * <li>groupId (if this and artifactId are null, then the current project is treated as its own overlay)</li> * <li>artifactId (see above)</li> * <li>classifier</li> * <li>type</li> * <li>includes (a list of string patterns)</li> * <li>excludes (a list of string patterns)</li> * <li>filtered (defaults to false)</li> * <li>skip (defaults to false)</li> * <li>targetPath (defaults to root of webapp structure)</li> * * </ul> * * * * @since 2.1-alpha-1 */ @Parameter private List<Overlay> overlays = new ArrayList<Overlay>(); /** * A list of file extensions that should not be filtered. * <b>Will be used when filtering webResources and overlays.</b> * * @since 2.1-alpha-2 */ @Parameter private List<String> nonFilteredFileExtensions; /** * @since 2.1-alpha-2 */ @Component private MavenSession session; /** * To filter deployment descriptors. <b>Disabled by default.</b> * * @since 2.1-alpha-2 */ @Parameter(property = "maven.war.filteringDeploymentDescriptors", defaultValue = "false") private boolean filteringDeploymentDescriptors = false; /** * To escape interpolated values with Windows path * <code>c:\foo\bar</code> will be replaced with <code>c:\\foo\\bar</code>. * * @since 2.1-alpha-2 */ @Parameter(property = "maven.war.escapedBackslashesInFilePath", defaultValue = "false") private boolean escapedBackslashesInFilePath = false; /** * Expression preceded with this String won't be interpolated. * <code>\${foo}</code> will be replaced with <code>${foo}</code>. * * @since 2.1-beta-1 */ @Parameter(property = "maven.war.escapeString") protected String escapeString; /** * Indicates if zip archives (jar,zip etc) being added to the war should be * compressed again. Compressing again can result in smaller archive size, but * gives noticeably longer execution time. * * @since 2.3 */ @Parameter(defaultValue = "false") private boolean recompressZippedFiles; /** * The archive configuration to use. * See <a href="http://maven.apache.org/shared/maven-archiver/index.html">Maven Archiver Reference</a>. */ @Parameter private MavenArchiveConfiguration archive = new MavenArchiveConfiguration(); private final WebappStructureSerializer webappStructureSerialier = new WebappStructureSerializer(); private final Overlay currentProjectOverlay = Overlay.createInstance(); public Overlay getCurrentProjectOverlay() { return currentProjectOverlay; } /** * Returns a string array of the excludes to be used * when copying the content of the WAR source directory. * * @return an array of tokens to exclude */ protected String[] getExcludes() { List<String> excludeList = new ArrayList<String>(); if (StringUtils.isNotEmpty(warSourceExcludes)) { excludeList.addAll(Arrays.asList(StringUtils.split(warSourceExcludes, ","))); } // if webXML is specified, omit the one in the source directory if (webXml != null && StringUtils.isNotEmpty(webXml.getName())) { excludeList.add("**/" + WEB_INF + "/web.xml"); } // if contextXML is specified, omit the one in the source directory if (containerConfigXML != null && StringUtils.isNotEmpty(containerConfigXML.getName())) { excludeList.add("**/" + META_INF + "/" + containerConfigXML.getName()); } return (String[]) excludeList.toArray(EMPTY_STRING_ARRAY); } /** * Returns a string array of the includes to be used * when assembling/copying the WAR. * * @return an array of tokens to include */ protected String[] getIncludes() { return StringUtils.split(StringUtils.defaultString(warSourceIncludes), ","); } /** * Returns a string array of the excludes to be used * when adding dependent WAR as an overlay onto this WAR. * * @return an array of tokens to exclude */ protected String[] getDependentWarExcludes() { String[] excludes; if (StringUtils.isNotEmpty(dependentWarExcludes)) { excludes = StringUtils.split(dependentWarExcludes, ","); } else { excludes = EMPTY_STRING_ARRAY; } return excludes; } /** * Returns a string array of the includes to be used * when adding dependent WARs as an overlay onto this WAR. * * @return an array of tokens to include */ protected String[] getDependentWarIncludes() { return StringUtils.split(StringUtils.defaultString(dependentWarIncludes), ","); } public void buildExplodedWebapp(File webappDirectory) throws MojoExecutionException, MojoFailureException { webappDirectory.mkdirs(); try { buildWebapp(project, webappDirectory); } catch (IOException e) { throw new MojoExecutionException("Could not build webapp", e); } } /** * 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 project the maven project * @param webappDirectory the target directory * @throws org.apache.maven.plugin.MojoExecutionException if an error occurred while packaging the webapp * @throws org.apache.maven.plugin.MojoFailureException if an unexpected error occurred while packaging the webapp * @throws java.io.IOException if an error occurred while copying the files */ @SuppressWarnings("unchecked") public void buildWebapp(MavenProject project, File webappDirectory) throws MojoExecutionException, MojoFailureException, IOException { WebappStructure cache; if (useCache && cacheFile.exists()) { cache = new WebappStructure(project.getDependencies(), webappStructureSerialier.fromXml(cacheFile)); } else { cache = new WebappStructure(project.getDependencies(), null); } final long startTime = System.currentTimeMillis(); getLog().info("Assembling webapp [" + project.getArtifactId() + "] in [" + webappDirectory + "]"); final OverlayManager overlayManager = new OverlayManager(overlays, project, dependentWarIncludes, dependentWarExcludes, currentProjectOverlay); final List<WarPackagingTask> packagingTasks = getPackagingTasks(overlayManager); List<FileUtils.FilterWrapper> defaultFilterWrappers = null; try { MavenResourcesExecution mavenResourcesExecution = new MavenResourcesExecution(); mavenResourcesExecution.setEscapeString(escapeString); defaultFilterWrappers = mavenFileFilter.getDefaultFilterWrappers(project, filters, escapedBackslashesInFilePath, this.session, mavenResourcesExecution); } catch (MavenFilteringException e) { getLog().error("fail to build filering wrappers " + e.getMessage()); throw new MojoExecutionException(e.getMessage(), e); } final WarPackagingContext context = new DefaultWarPackagingContext(webappDirectory, cache, overlayManager, defaultFilterWrappers, getNonFilteredFileExtensions(), filteringDeploymentDescriptors, this.artifactFactory, resourceEncoding); 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]"); } /** * Returns a <tt>List</tt> of the {@link org.piraso.maven.packaging.WarPackagingTask} * instances to invoke to perform the packaging. * * @param overlayManager the overlay manager * @return the list of packaging tasks * @throws org.apache.maven.plugin.MojoExecutionException if the packaging tasks could not be built */ private List<WarPackagingTask> getPackagingTasks(OverlayManager overlayManager) throws MojoExecutionException { final List<WarPackagingTask> packagingTasks = new ArrayList<WarPackagingTask>(); if (useCache) { packagingTasks.add(new DependenciesAnalysisPackagingTask()); } final List<Overlay> resolvedOverlays = overlayManager.getOverlays(); for (Overlay overlay : resolvedOverlays) { if (overlay.isCurrentProject()) { packagingTasks.add(new WarProjectPackagingTask(webResources, webXml, containerConfigXML, currentProjectOverlay)); } else { packagingTasks.add(new OverlayPackagingTask(overlay, currentProjectOverlay)); } } return packagingTasks; } /** * Returns a <tt>List</tt> of the {@link org.piraso.maven.packaging.WarPostPackagingTask} * instances to invoke to perform the post-packaging. * * @return the list of post packaging tasks */ private List<WarPostPackagingTask> getPostPackagingTasks() { final List<WarPostPackagingTask> postPackagingTasks = new ArrayList<WarPostPackagingTask>(); if (useCache) { postPackagingTasks.add(new SaveWebappStructurePostPackagingTask(cacheFile)); } // TODO add lib scanning to detect duplicates return postPackagingTasks; } /** * WarPackagingContext default implementation */ private class DefaultWarPackagingContext implements WarPackagingContext { private final ArtifactFactory artifactFactory; private final String resourceEncoding; private final WebappStructure webappStructure; private final File webappDirectory; private final OverlayManager overlayManager; private final List<FileUtils.FilterWrapper> filterWrappers; private List<String> nonFilteredFileExtensions; private boolean filteringDeploymentDescriptors; public DefaultWarPackagingContext(File webappDirectory, final WebappStructure webappStructure, final OverlayManager overlayManager, List<FileUtils.FilterWrapper> filterWrappers, List<String> nonFilteredFileExtensions, boolean filteringDeploymentDescriptors, ArtifactFactory artifactFactory, String resourceEncoding) { this.webappDirectory = webappDirectory; this.webappStructure = webappStructure; this.overlayManager = overlayManager; this.filterWrappers = filterWrappers; this.artifactFactory = artifactFactory; this.filteringDeploymentDescriptors = filteringDeploymentDescriptors; this.nonFilteredFileExtensions = nonFilteredFileExtensions == null ? Collections.<String>emptyList() : nonFilteredFileExtensions; this.resourceEncoding = resourceEncoding; // This is kinda stupid but if we loop over the current overlays and we request the path structure // it will register it. This will avoid wrong warning messages in a later phase for (String overlayId : overlayManager.getOverlayIds()) { webappStructure.getStructure(overlayId); } } public MavenProject getProject() { return project; } public File getWebappDirectory() { return webappDirectory; } public File getClassesDirectory() { return classesDirectory; } public Log getLog() { return AbstractWarMojo.this.getLog(); } public String getOutputFileNameMapping() { return outputFileNameMapping; } public File getWebappSourceDirectory() { return warSourceDirectory; } public String[] getWebappSourceIncludes() { return getIncludes(); } public String[] getWebappSourceExcludes() { return getExcludes(); } public boolean archiveClasses() { return archiveClasses; } public File getOverlaysWorkDirectory() { return workDirectory; } public ArchiverManager getArchiverManager() { return archiverManager; } public MavenArchiveConfiguration getArchive() { return archive; } public JarArchiver getJarArchiver() { return jarArchiver; } public List<String> getFilters() { return filters; } public WebappStructure getWebappStructure() { return webappStructure; } public List<String> getOwnerIds() { return overlayManager.getOverlayIds(); } public MavenFileFilter getMavenFileFilter() { return mavenFileFilter; } public List<FileUtils.FilterWrapper> getFilterWrappers() { return filterWrappers; } public boolean isNonFilteredExtension(String fileName) { return !mavenResourcesFiltering.filteredFileExtension(fileName, nonFilteredFileExtensions); } public boolean isFilteringDeploymentDescriptors() { return filteringDeploymentDescriptors; } public ArtifactFactory getArtifactFactory() { return this.artifactFactory; } public MavenSession getSession() { return session; } public String getResourceEncoding() { return resourceEncoding; } } public MavenProject getProject() { return project; } public void setProject(MavenProject project) { this.project = project; } public File getClassesDirectory() { return classesDirectory; } public void setClassesDirectory(File classesDirectory) { this.classesDirectory = classesDirectory; } public File getWebappDirectory() { return webappDirectory; } public void setWebappDirectory(File webappDirectory) { this.webappDirectory = webappDirectory; } public File getWarSourceDirectory() { return warSourceDirectory; } public void setWarSourceDirectory(File warSourceDirectory) { this.warSourceDirectory = warSourceDirectory; } public File getWebXml() { return webXml; } public void setWebXml(File webXml) { this.webXml = webXml; } public File getContainerConfigXML() { return containerConfigXML; } public void setContainerConfigXML(File containerConfigXML) { this.containerConfigXML = containerConfigXML; } public String getOutputFileNameMapping() { return outputFileNameMapping; } public void setOutputFileNameMapping(String outputFileNameMapping) { this.outputFileNameMapping = outputFileNameMapping; } public List<Overlay> getOverlays() { return overlays; } public void setOverlays(List<Overlay> overlays) { this.overlays = overlays; } public void addOverlay(Overlay overlay) { overlays.add(overlay); } public boolean isArchiveClasses() { return archiveClasses; } public void setArchiveClasses(boolean archiveClasses) { this.archiveClasses = archiveClasses; } public JarArchiver getJarArchiver() { return jarArchiver; } public void setJarArchiver(JarArchiver jarArchiver) { this.jarArchiver = jarArchiver; } public Resource[] getWebResources() { return webResources; } public void setWebResources(Resource[] webResources) { this.webResources = webResources; } public List<String> getFilters() { return filters; } public void setFilters(List<String> filters) { this.filters = filters; } public File getWorkDirectory() { return workDirectory; } public void setWorkDirectory(File workDirectory) { this.workDirectory = workDirectory; } public File getCacheFile() { return cacheFile; } public void setCacheFile(File cacheFile) { this.cacheFile = cacheFile; } public String getWarSourceIncludes() { return warSourceIncludes; } public void setWarSourceIncludes(String warSourceIncludes) { this.warSourceIncludes = warSourceIncludes; } public String getWarSourceExcludes() { return warSourceExcludes; } public void setWarSourceExcludes(String warSourceExcludes) { this.warSourceExcludes = warSourceExcludes; } public boolean isUseCache() { return useCache; } public void setUseCache(boolean useCache) { this.useCache = useCache; } public MavenArchiveConfiguration getArchive() { return archive; } public List<String> getNonFilteredFileExtensions() { return nonFilteredFileExtensions; } public void setNonFilteredFileExtensions(List<String> nonFilteredFileExtensions) { this.nonFilteredFileExtensions = nonFilteredFileExtensions; } public ArtifactFactory getArtifactFactory() { return this.artifactFactory; } public void setArtifactFactory(ArtifactFactory artifactFactory) { this.artifactFactory = artifactFactory; } protected MavenSession getSession() { return this.session; } protected boolean isRecompressZippedFiles() { return recompressZippedFiles; } }