Java ManifestException类代码示例

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
private File createArchiveFile( File targetDirectory, String directory, String archiveExt )
    throws NoSuchArchiverException, IOException, MojoExecutionException
{
    final MavenArchiver mavenArchiver = new MavenArchiver();

    mavenArchiver.setArchiver( jarArchiver );

    jarArchiver.addFileSet( new DefaultFileSet( targetDirectory ) );
    // jarArchiver.setDuplicateBehavior( duplicate );

    File resultArchive = getArchiveFile( getOutputDirectory(), getFinalName(), directory, archiveExt );

    mavenArchiver.setOutputFile( resultArchive );
    try
    {
        mavenArchiver.createArchive( getMavenSession(), getMavenProject(), getArchive() );
    }
    catch ( ArchiverException | ManifestException | DependencyResolutionRequiredException e )
    {
        getLog().error( e.getMessage(), e );
        throw new MojoExecutionException( e.getMessage(), e );
    }

    return resultArchive;

}
 

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
private static void addCustomManifestSections(@NotNull Manifest manifest, @NotNull Element mavenArchiveConfiguration)
  throws ManifestException {

  for (Element section : MavenJDOMUtil.findChildrenByPath(mavenArchiveConfiguration, "manifestSections", "manifestSection")) {
    Manifest.Section theSection = new Manifest.Section();

    final String sectionName = MavenJDOMUtil.findChildValueByPath(section, "name");
    theSection.setName(sectionName);

    final Element manifestEntries = section.getChild("manifestEntries");
    Map<String, String> entries = getManifestEntries(manifestEntries);

    if (!entries.isEmpty()) {
      for (Map.Entry<String, String> entry : entries.entrySet()) {
        Attribute attr = new Attribute(entry.getKey(), entry.getValue());
        theSection.addConfiguredAttribute(attr);
      }
    }
    manifest.addConfiguredSection(theSection);
  }
}
 

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
private static void addManifestEntries(@NotNull Manifest manifest, @NotNull Map<String, String> entries)
  throws ManifestException {
  if (!entries.isEmpty()) {
    for (Map.Entry<String, String> entry : entries.entrySet()) {
      Attribute attr = manifest.getMainSection().getAttribute(entry.getKey());
      if ("Class-Path".equals(entry.getKey()) && attr != null) {
        // Merge the user-supplied Class-Path value with the programmatically
        // generated Class-Path.  Note that the user-supplied value goes first
        // so that resources there will override any in the standard Class-Path.
        attr.setValue(entry.getValue() + " " + attr.getValue());
      }
      else {
        addManifestAttribute(manifest, entry.getKey(), entry.getValue());
      }
    }
  }
}
 

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
private Manifest getPluginManifest() throws ManifestException {
    getLog().debug("Generating plugin manifest");
    Manifest manifest = new Manifest();
    addAttribute(manifest, ManifestField.NAME.getFieldName(), pluginName);
    addAttribute(manifest, ManifestField.VERSION.getFieldName(), pluginVersion);
    addAttribute(manifest, ManifestField.DATE.getFieldName(), ZonedDateTime.now().format(DefaultManifestReader.DATE_FORMATTER));
    if (description != null) {
        addAttribute(manifest, ManifestField.DESCRIPTION.getFieldName(), description);
    }
    if (maintainer != null) {
        addAttribute(manifest, ManifestField.MAINTAINER.getFieldName(), maintainer);
    }
    if (depends != null) {
        addAttribute(manifest, ManifestField.DEPENDS.getFieldName(), joinDependencies(depends));
    }
    if (conflicts != null) {
        addAttribute(manifest, ManifestField.CONFLICTS.getFieldName(), joinDependencies(conflicts));
    }
    if (provides != null) {
        addAttribute(manifest, ManifestField.PROVIDES.getFieldName(), provides);
    }
    return manifest;
}
 

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
private File createArchiveFile( File unpackDirectory, File targetDirectory, String directory, String archiveExt )
    throws NoSuchArchiverException, IOException, MojoExecutionException
{
    final MavenArchiver mavenArchiver = new MavenArchiver();

    mavenArchiver.setArchiver( jarArchiver );

    jarArchiver.addFileSet( new DefaultFileSet( targetDirectory ) );
    jarArchiver.addFileSet( new DefaultFileSet( unpackDirectory ) );
    // jarArchiver.setDuplicateBehavior( duplicate );

    File resultArchive = getArchiveFile( getOutputDirectory(), getFinalName(), directory, archiveExt );

    mavenArchiver.setOutputFile( resultArchive );
    try
    {
        mavenArchiver.createArchive( getMavenSession(), getMavenProject(), getArchive() );
    }
    catch ( ArchiverException | ManifestException | DependencyResolutionRequiredException e )
    {
        getLog().error( e.getMessage(), e );
        throw new MojoExecutionException( e.getMessage(), e );
    }

    return resultArchive;

}
 

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
@NotNull
public java.util.jar.Manifest build() throws ManifestBuilderException {
  try {
    Element mavenPackagingPluginConfiguration = getMavenPackagingPluginConfiguration(myMavenProject);
    final Element mavenArchiveConfiguration =
      mavenPackagingPluginConfiguration != null ? mavenPackagingPluginConfiguration.getChild("archive") : null;

    if (mavenArchiveConfiguration == null) return getDefaultManifest(Collections.<String, String>emptyMap());

    final Element manifestEntries = mavenArchiveConfiguration.getChild("manifestEntries");
    Map<String, String> entries = getManifestEntries(manifestEntries);

    final Element manifestConfiguration = mavenArchiveConfiguration.getChild("manifest");
    final Manifest configuredManifest = getConfiguredManifest(myMavenProject, manifestConfiguration, entries);

    if (!entries.isEmpty()) {
      addManifestEntries(configuredManifest, entries);
    }

    addCustomManifestSections(configuredManifest, mavenArchiveConfiguration);

    Manifest finalManifest = getDefaultManifest(entries);
    // merge configured manifest
    merge(finalManifest, configuredManifest);

    // merge user supplied manifest
    final Manifest userSuppliedManifest = getUserSuppliedManifest(mavenArchiveConfiguration);
    merge(finalManifest, userSuppliedManifest);
    return finalManifest;
  }
  catch (ManifestException e) {
    throw new ManifestBuilderException(e);
  }
}
 

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
@NotNull
private Manifest getDefaultManifest(@NotNull Map<String, String> entries) throws ManifestException {
  Manifest finalManifest = new Manifest();
  addManifestAttribute(finalManifest, entries, "Created-By", ApplicationNamesInfo.getInstance().getFullProductName());
  addManifestAttribute(finalManifest, entries, "Built-By", System.getProperty("user.name"));
  if (!StringUtil.isEmpty(myJdkVersion)) {
    addManifestAttribute(finalManifest, entries, "Build-Jdk", myJdkVersion);
  }
  return finalManifest;
}
 

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
private void packageCompiledSources() throws DependencyResolutionRequiredException, IOException, ManifestException {
    MavenArchiver archiver = new MavenArchiver();
    archiver.setArchiver(sourcesArchiver);
    Path pluginJarFile = getDataOutputDirectory().resolve(PluginUtils.PLUGIN_IMPLEMENTATION_FILE);
    getLog().debug(String.format("Packing plugin sources to %s", pluginJarFile.toString()));
    archiver.setOutputFile(pluginJarFile.toFile());
    sourcesArchiver.addDirectory(compiledSourcesDir);
    archiver.createArchive(session, project, new MavenArchiveConfiguration());
}
 

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
private void packagePlugin() throws DependencyResolutionRequiredException, IOException, ManifestException {
    MavenArchiver archiver = new MavenArchiver();
    archiver.setArchiver(pluginArchiver);
    Path pluginFile = getPluginFile();
    getLog().info(String.format("Creating plugin file: %s", pluginFile));
    archiver.setOutputFile(pluginFile.toFile());
    pluginArchiver.addDirectory(dataOutputDirectory);
    pluginArchiver.addConfiguredManifest(getPluginManifest());
    archiver.createArchive(session, project, new MavenArchiveConfiguration());
}
 

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
protected Manifest createManifest() throws ManifestException {
    Manifest manifest = new Manifest();
    //manifest.getMainSection().addConfiguredAttribute(new Manifest.Attribute("Bundle-Name", project.getName()));
    //manifest.getMainSection().addConfiguredAttribute(new Manifest.Attribute("Bundle-SymbolicName", project.getArtifactId()));
    //manifest.getMainSection().addConfiguredAttribute(new Manifest.Attribute(
        //"Bundle-Version", fixBundleVersion(project.getVersion())));
    return manifest;
}
 

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
/**
 * Generates the mar.
 * 
 * @param marFile
 *            the target mar file
 * @throws IOException
 * @throws ArchiverException
 * @throws ManifestException
 * @throws DependencyResolutionRequiredException
 */
private void performPackaging( File marFile )
    throws IOException, ArchiverException, ManifestException, DependencyResolutionRequiredException,
    MojoExecutionException
{

    buildExplodedMar( );

    // generate mar file
    getLog().info( "Generating mar " + marFile.getAbsolutePath() );
    MavenArchiver archiver = new MavenArchiver();
    archiver.setArchiver( jarArchiver );
    archiver.setOutputFile( marFile );
    jarArchiver.addDirectory( marDirectory );

    // create archive
    archiver.createArchive( project, archive );

    if ( classifier != null )
    {
        projectHelper.attachArtifact( project, "mar", classifier, marFile );
    }
    else
    {
        Artifact artifact = project.getArtifact();
        if ( primaryArtifact )
        {
            artifact.setFile( marFile );
        }
        else if ( artifact.getFile() == null || artifact.getFile().isDirectory() )
        {
            artifact.setFile( marFile );
        }
        else
        {
            projectHelper.attachArtifact( project, "mar", marFile );
        }
    }
}
 

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
/**
 * Generates the aar.
 *
 * @param aarFile the target aar file
 * @throws IOException
 * @throws ArchiverException
 * @throws ManifestException
 * @throws DependencyResolutionRequiredException
 *
 */
private void performPackaging(File aarFile)
        throws IOException, ArchiverException, ManifestException,
        DependencyResolutionRequiredException,
        MojoExecutionException {

    buildExplodedAar();

    // generate aar file
    getLog().info("Generating aar " + aarFile.getAbsolutePath());
    MavenArchiver archiver = new MavenArchiver();
    archiver.setArchiver(jarArchiver);
    archiver.setOutputFile(aarFile);
    jarArchiver.addDirectory(aarDirectory);

    // create archive
    archiver.createArchive(project, archive);

    if (classifier != null) {
        projectHelper.attachArtifact(project, "aar", classifier, aarFile);
    } else {
        Artifact artifact = project.getArtifact();
        if (primaryArtifact) {
            artifact.setFile(aarFile);
        } else if (artifact.getFile() == null || artifact.getFile().isDirectory()) {
            artifact.setFile(aarFile);
        } else {
            projectHelper.attachArtifact(project, "aar", aarFile);
        }
    }
}
 

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
private File process() throws IOException, ManifestException {
    getLog().info("Building webjar for " + project.getArtifactId());
    File output = new File(buildDirectory, webjar.getOutputFileName());
    FileUtils.deleteQuietly(output);

    // Compute the set of selected files:
    Collection<File> selected = webjar.getSelectedFiles();
    if (selected.isEmpty()) {
        getLog().warn("No file selected in the webjar - skipping creation");
        return null;
    }
    String root = computeRoot();

    FileUtils.deleteQuietly(output);

    // Web jar are jar file, so use the Plexus Archiver.
    JarArchiver archiver = new JarArchiver();
    archiver.enableLogging(new PlexusLoggerWrapper(getLog()));
    String base = webjar.getFileset().getDirectory();
    for (File file : selected) {
        final String destFileName = root + "/" + file.getAbsolutePath().substring(base.length() + 1);
        getLog().debug(file.getName() + " => " + destFileName);
        archiver.addFile(file, destFileName);
    }

    // Extend the manifest with webjar data - this is not required by the webjar specification
    Manifest manifest = Manifest.getDefaultManifest();
    manifest.getMainSection().addConfiguredAttribute(new Manifest.Attribute("Webjar-Name", webjar.getName()));
    manifest.getMainSection().addConfiguredAttribute(new Manifest.Attribute("Webjar-Version", webjar.getVersion()));
    manifest.getMainSection().addConfiguredAttribute(new Manifest.Attribute("Created-By", "Wisdom Framework " +
            BuildConstants.get("WISDOM_PLUGIN_VERSION")));
    archiver.addConfiguredManifest(manifest);
    archiver.setDestFile(output);
    archiver.createArchive();
    return output;
}
 

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
/**
     * Generates the webapp according to the <tt>mode</tt> attribute.
     *
     * @param warFile the target WAR file
     * @throws IOException                           if an error occurred while copying files
     * @throws ArchiverException                     if the archive could not be created
     * @throws ManifestException                     if the manifest could not be created
     * @throws DependencyResolutionRequiredException if an error occurred while resolving the dependencies
     * @throws MojoExecutionException                if the execution failed
     * @throws MojoFailureException                  if a fatal exception occurred
     */
    private void performPackaging(File warFile)
            throws IOException, ManifestException, DependencyResolutionRequiredException, MojoExecutionException,
            MojoFailureException {
        getLog().info("Packaging app");

        buildExplodedWebapp(getWebappDirectory());

        TemplateTask templateTask = new TemplateTask(getWebappDirectory(),getLog());
        templateTask.createBinFile();

        MavenArchiver archiver = new MavenArchiver();

        archiver.setArchiver(warArchiver);

        archiver.setOutputFile(warFile);

        // CHECKSTYLE_OFF: LineLength
        getLog().debug("Excluding " + Arrays.asList(getPackagingExcludes()) + " from the generated app archive.");
        getLog().debug("Including " + Arrays.asList(getPackagingIncludes()) + " in the generated app archive.");
        // CHECKSTYLE_ON: LineLength

        warArchiver.addDirectory(getWebappDirectory(), getPackagingIncludes(), getPackagingExcludes());

//        final File webXmlFile = new File(getWebappDirectory(), "WEB-INF/web.xml");
//        if (webXmlFile.exists()) {
//            warArchiver.setWebxml(webXmlFile);
//        }

        warArchiver.setRecompressAddedZips(isRecompressZippedFiles());

        warArchiver.setIncludeEmptyDirs(isIncludeEmptyDirectories());

        if (!failOnMissingWebXml) {
            getLog().debug("Build won't fail if web.xml file is missing.");
            warArchiver.setExpectWebXml(false);
        }

        // create archive
        archiver.createArchive(getSession(), getProject(), getArchive());

        // create the classes to be attached if necessary
        if (isAttachClasses()) {
            if (isArchiveClasses() && getJarArchiver().getDestFile() != null) {
                // special handling in case of archived classes: MWAR-240
                File targetClassesFile = getTargetClassesFile();
                FileUtils.copyFile(getJarArchiver().getDestFile(), targetClassesFile);
                projectHelper.attachArtifact(getProject(), "jar", getClassesClassifier(), targetClassesFile);
            } else {
                ClassesPackager packager = new ClassesPackager();
                final File classesDirectory = packager.getClassesDirectory(getWebappDirectory());
                if (classesDirectory.exists()) {
                    getLog().info("Packaging classes");
                    packager.packageClasses(classesDirectory, getTargetClassesFile(), getJarArchiver(), getSession(),
                            getProject(), getArchive());
                    projectHelper.attachArtifact(getProject(), "jar", getClassesClassifier(), getTargetClassesFile());
                }
            }
        }

        if (this.classifier != null) {
            projectHelper.attachArtifact(getProject(), "war", this.classifier, warFile);
        } else {
            Artifact artifact = getProject().getArtifact();
            if (primaryArtifact) {
                artifact.setFile(warFile);
            } else if (artifact.getFile() == null || artifact.getFile().isDirectory()) {
                artifact.setFile(warFile);
            }
        }
    }
 

import org.codehaus.plexus.archiver.jar.ManifestException; //导入依赖的package包/类
@NotNull
private static Manifest getConfiguredManifest(@NotNull MavenProject mavenProject,
                                              @Nullable Element manifestConfiguration,
                                              @NotNull Map<String, String> entries) throws ManifestException {
  final Manifest manifest = new Manifest();

  boolean isAddDefaultSpecificationEntries =
    Boolean.valueOf(MavenJDOMUtil.findChildValueByPath(manifestConfiguration, "addDefaultSpecificationEntries", "false"));
  if (isAddDefaultSpecificationEntries) {
    addManifestAttribute(manifest, entries, "Specification-Title", mavenProject.getName());
    addManifestAttribute(manifest, entries, "Specification-Version", mavenProject.getMavenId().getVersion());
  }

  boolean isAddDefaultImplementationEntries =
    Boolean.valueOf(MavenJDOMUtil.findChildValueByPath(manifestConfiguration, "addDefaultImplementationEntries", "false"));
  if (isAddDefaultImplementationEntries) {
    addManifestAttribute(manifest, entries, "Implementation-Title", mavenProject.getName());
    addManifestAttribute(manifest, entries, "Implementation-Version", mavenProject.getMavenId().getVersion());
    addManifestAttribute(manifest, entries, "Implementation-Vendor-Id", mavenProject.getMavenId().getGroupId());
  }

  String packageName = MavenJDOMUtil.findChildValueByPath(manifestConfiguration, "packageName");
  if (packageName != null) {
    addManifestAttribute(manifest, entries, "Package", packageName);
  }

  String mainClass = MavenJDOMUtil.findChildValueByPath(manifestConfiguration, "mainClass");
  if (!StringUtil.isEmpty(mainClass)) {
    addManifestAttribute(manifest, entries, "Main-Class", mainClass);
  }

  boolean isAddClasspath = Boolean.valueOf(MavenJDOMUtil.findChildValueByPath(manifestConfiguration, "addClasspath", "false"));
  if (isAddClasspath) {
    final ManifestImporter manifestImporter = ManifestImporter.getManifestImporter(mavenProject.getPackaging());
    String classpath = manifestImporter.getClasspath(mavenProject, manifestConfiguration);
    if (!classpath.isEmpty()) {
      addManifestAttribute(manifest, "Class-Path", classpath);
    }
  }
  return manifest;
}