Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2012-2015 the original author or authors.
   *
   * Licensed 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.
  */
 
 package org.springframework.boot.loader.tools;
 
 import java.io.File;
 import java.util.Set;
Utility class that can be used to repackage an archive so that it can be executed using 'java -jar'.

Author(s):
Phillip Webb
Andy Wilkinson
 
 public class Repackager {
 
 	private static final String MAIN_CLASS_ATTRIBUTE = "Main-Class";
 
 	private static final String START_CLASS_ATTRIBUTE = "Start-Class";
 
 	private static final String BOOT_VERSION_ATTRIBUTE = "Spring-Boot-Version";
 
 	private static final byte[] ZIP_FILE_HEADER = new byte[] { 'P''K', 3, 4 };
 
 	private String mainClass;
 
 	private boolean backupSource = true;
 
 	private final File source;
 
 	private Layout layout;
 
 	public Repackager(File source) {
 		if (source == null || !source.exists() || !source.isFile()) {
 			throw new IllegalArgumentException("Source must refer to an existing file");
 		}
 		this. = source.getAbsoluteFile();
 		this. = Layouts.forFile(source);
 	}

Sets the main class that should be run. If not specified the value from the MANIFEST will be used, or if no manifest entry is found the archive will be searched for a suitable class.

Parameters:
mainClass the main class name
 
 	public void setMainClass(String mainClass) {
 		this. = mainClass;
 	}

Sets if source files should be backed up when they would be overwritten.

Parameters:
backupSource if source files should be backed up
 
 	public void setBackupSource(boolean backupSource) {
 		this. = backupSource;
 	}

Sets the layout to use for the jar. Defaults to Layouts.forFile(java.io.File).

Parameters:
layout the layout
 
 	public void setLayout(Layout layout) {
 		if (layout == null) {
 			throw new IllegalArgumentException("Layout must not be null");
 		}
 		this. = layout;
 	}

Repackage the source file so that it can be run using 'java -jar'

Parameters:
libraries the libraries required to run the archive
Throws:
java.io.IOException
 
 	public void repackage(Libraries librariesthrows IOException {
 		repackage(this.libraries);
 	}

Repackage to the given destination so that it can be launched using ' java -jar'

Parameters:
destination the destination file (may be the same as the source)
libraries the libraries required to run the archive
Throws:
java.io.IOException
	public void repackage(File destinationLibraries librariesthrows IOException {
		if (destination == null || destination.isDirectory()) {
			throw new IllegalArgumentException("Invalid destination");
		}
		if (libraries == null) {
			throw new IllegalArgumentException("Libraries must not be null");
		}
			return;
		}
		destination = destination.getAbsoluteFile();
		File workingSource = this.;
		if (this..equals(destination)) {
			workingSource = new File(this..getParentFile(), this..getName()
".original");
			workingSource.delete();
			renameFile(this.workingSource);
		}
		destination.delete();
		try {
			JarFile jarFileSource = new JarFile(workingSource);
			try {
				repackage(jarFileSourcedestinationlibraries);
			}
			finally {
				jarFileSource.close();
			}
		}
		finally {
			if (!this. && !this..equals(workingSource)) {
				deleteFile(workingSource);
			}
		}
	}
	private boolean alreadyRepackaged() throws IOException {
		JarFile jarFile = new JarFile(this.);
		try {
			Manifest manifest = jarFile.getManifest();
			return (manifest != null && manifest.getMainAttributes().getValue(
		}
		finally {
			jarFile.close();
		}
	}
	private void repackage(JarFile sourceJarFile destinationLibraries libraries)
			throws IOException {
		final JarWriter writer = new JarWriter(destination);
		try {
			final Set<Stringseen = new HashSet<String>();
			writer.writeManifest(buildManifest(sourceJar));
			libraries.doWithLibraries(new LibraryCallback() {
				public void library(Library librarythrows IOException {
					File file = library.getFile();
					if (isZip(file)) {
						String destination = Repackager.this.
										library.getScope());
						if (destination != null) {
							if (!seen.add(destination + library.getName())) {
								throw new IllegalStateException("Duplicate library "
library.getName());
							}
							writer.writeNestedLibrary(destinationlibrary);
						}
					}
				}
			});
			writer.writeEntries(sourceJar);
			if (this..isExecutable()) {
			}
		}
		finally {
			try {
				writer.close();
			}
			catch (Exception ex) {
				// Ignore
			}
		}
	}
	private boolean isZip(File file) {
		try {
			FileInputStream fileInputStream = new FileInputStream(file);
			try {
				return isZip(fileInputStream);
			}
			finally {
				fileInputStream.close();
			}
		}
		catch (IOException ex) {
			return false;
		}
	}
	private boolean isZip(InputStream inputStreamthrows IOException {
		for (int i = 0; i < .i++) {
			if (inputStream.read() != [i]) {
				return false;
			}
		}
		return true;
	}
	private Manifest buildManifest(JarFile sourcethrows IOException {
		Manifest manifest = source.getManifest();
		if (manifest == null) {
			manifest = new Manifest();
			manifest.getMainAttributes().putValue("Manifest-Version""1.0");
		}
		manifest = new Manifest(manifest);
		String startClass = this.;
		if (startClass == null) {
		}
		if (startClass == null) {
			startClass = findMainMethod(source);
		}
		String launcherClassName = this..getLauncherClassName();
		if (launcherClassName != null) {
					.putValue(launcherClassName);
			if (startClass == null) {
				throw new IllegalStateException("Unable to find main class");
			}
		}
		else if (startClass != null) {
		}
		return manifest;
	}
	protected String findMainMethod(JarFile sourcethrows IOException {
		return MainClassFinder.findSingleMainClass(source,
	}
	private void renameFile(File fileFile dest) {
		if (!file.renameTo(dest)) {
			throw new IllegalStateException("Unable to rename '" + file + "' to '" + dest
"'");
		}
	}
	private void deleteFile(File file) {
		if (!file.delete()) {
			throw new IllegalStateException("Unable to delete '" + file + "'");
		}
	}
New to GrepCode? Check out our FAQ X