Improve performance of fat jar loading

Tweak 'fat jar' handling to generally improve performance:

- Allow JarURLConnection to throw a static FileNotFoundException when
  loading classes. This exception is thrown many times when attempting
  to load a class and is silently swallowed so there is no point in
  providing the entry name.
- Expose JarFile.getJarEntryData(AsciiBytes) and store AsciiBytes in
  the JarURLConnection. Previously AsciiBytes were created, discarded
  then created again.
- Use EMPTY_JAR_URL for the JarURLConnection super constructor. The URL
  is never actually used so we can improve performance by using a
  constant.
- Extract JarEntryName for possible caching. The jar entry name
  extracted from the URL is now contained in an inner JarEntryName
  class. This could be cached if necessary (although currently it is
  not because no perceivable performance benefit was observed)

Fixes gh-1119

spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/LaunchedURLClassLoader.java

@@ -25,6 +25,7 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.Enumeration;
 
+import org.springframework.boot.loader.jar.Handler;
 import org.springframework.boot.loader.jar.JarFile;
 
 /**
@@ -93,7 +94,6 @@ public class LaunchedURLClassLoader extends URLClassLoader {
 
 	@Override
 	public Enumeration<URL> getResources(String name) throws IOException {
-
 		if (this.rootClassLoader == null) {
 			return findResources(name);
 		}
@@ -116,6 +116,7 @@ public class LaunchedURLClassLoader extends URLClassLoader {
 				}
 				return localResources.nextElement();
 			}
+
 		};
 	}
 
@@ -128,7 +129,13 @@ public class LaunchedURLClassLoader extends URLClassLoader {
 		synchronized (this) {
 			Class<?> loadedClass = findLoadedClass(name);
 			if (loadedClass == null) {
-				loadedClass = doLoadClass(name);
+				Handler.setUseFastConnectionExceptions(true);
+				try {
+					loadedClass = doLoadClass(name);
+				}
+				finally {
+					Handler.setUseFastConnectionExceptions(false);
+				}
 			}
 			if (resolve) {
 				resolveClass(loadedClass);

spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/Handler.java

@@ -42,7 +42,7 @@ public class Handler extends URLStreamHandler {
 
 	private static final String FILE_PROTOCOL = "file:";
 
-	private static final String SEPARATOR = JarURLConnection.SEPARATOR;
+	private static final String SEPARATOR = "!/";
 
 	private static final String[] FALLBACK_HANDLERS = { "sun.net.www.protocol.jar.Handler" };
 
@@ -198,4 +198,14 @@ public class Handler extends URLStreamHandler {
 		cache.put(sourceFile, jarFile);
 	}
 
+	/**
+	 * Set if a generic static exception can be thrown when a URL cannot be connected.
+	 * This optimization is used during class loading to save creating lots of exceptions
+	 * which are then swallowed.
+	 * @param useFastConnectionExceptions if fast connection exceptions can be used.
+	 */
+	public static void setUseFastConnectionExceptions(boolean useFastConnectionExceptions) {
+		JarURLConnection.setUseFastExceptions(useFastConnectionExceptions);
+	}
+
 }

spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarFile.java

@@ -66,6 +66,8 @@ public class JarFile extends java.util.jar.JarFile implements Iterable<JarEntryD
 
 	private static final String HANDLERS_PACKAGE = "org.springframework.boot.loader";
 
+	private static final AsciiBytes SLASH = new AsciiBytes("/");
+
 	private final RandomAccessDataFile rootFile;
 
 	private final String name;
@@ -250,6 +252,13 @@ public class JarFile extends java.util.jar.JarFile implements Iterable<JarEntryD
 	}
 
 	public JarEntryData getJarEntryData(String name) {
+		if (name == null) {
+			return null;
+		}
+		return getJarEntryData(new AsciiBytes(name));
+	}
+
+	public JarEntryData getJarEntryData(AsciiBytes name) {
 		if (name == null) {
 			return null;
 		}
@@ -264,9 +273,9 @@ public class JarFile extends java.util.jar.JarFile implements Iterable<JarEntryD
 					entriesByName);
 		}
 
-		JarEntryData entryData = entriesByName.get(new AsciiBytes(name));
-		if (entryData == null && !name.endsWith("/")) {
-			entryData = entriesByName.get(new AsciiBytes(name + "/"));
+		JarEntryData entryData = entriesByName.get(name);
+		if (entryData == null && !name.endsWith(SLASH)) {
+			entryData = entriesByName.get(name.append(SLASH));
 		}
 		return entryData;
 	}

spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarURLConnection.java

@@ -22,6 +22,8 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
 import java.util.jar.Manifest;
 
 import org.springframework.boot.loader.util.AsciiBytes;
@@ -33,51 +35,73 @@ import org.springframework.boot.loader.util.AsciiBytes;
  */
 class JarURLConnection extends java.net.JarURLConnection {
 
-	static final String PROTOCOL = "jar";
+	private static final FileNotFoundException FILE_NOT_FOUND_EXCEPTION = new FileNotFoundException();
 
-	static final String SEPARATOR = "!/";
+	private static final String SEPARATOR = "!/";
 
-	private static final String PREFIX = PROTOCOL + ":" + "file:";
+	private static final URL EMPTY_JAR_URL;
+
+	static {
+		try {
+			EMPTY_JAR_URL = new URL("jar:", null, 0, "file:!/", new URLStreamHandler() {
+				@Override
+				protected URLConnection openConnection(URL u) throws IOException {
+					// Stub URLStreamHandler to prevent the wrong JAR Handler from being
+					// Instantiated and cached.
+					return null;
+				}
+			});
+		}
+		catch (MalformedURLException ex) {
+			throw new IllegalStateException(ex);
+		}
+	}
+
+	private static final JarEntryName EMPTY_JAR_ENTRY_NAME = new JarEntryName("");
+
+	private static ThreadLocal<Boolean> useFastExceptions = new ThreadLocal<Boolean>();
+
+	private final String jarFileUrlSpec;
 
 	private final JarFile jarFile;
 
 	private JarEntryData jarEntryData;
 
-	private String jarEntryName;
-
-	private String contentType;
-
 	private URL jarFileUrl;
 
+	private JarEntryName jarEntryName;
+
 	protected JarURLConnection(URL url, JarFile jarFile) throws MalformedURLException {
-		super(new URL(buildRootUrl(jarFile)));
+		// What we pass to super is ultimately ignored
+		super(EMPTY_JAR_URL);
 		this.url = url;
 		this.jarFile = jarFile;
-
 		String spec = url.getFile();
 		int separator = spec.lastIndexOf(SEPARATOR);
 		if (separator == -1) {
 			throw new MalformedURLException("no " + SEPARATOR + " found in url spec:"
 					+ spec);
 		}
-		if (separator + 2 != spec.length()) {
-			this.jarEntryName = decode(spec.substring(separator + 2));
-		}
+		this.jarFileUrlSpec = spec.substring(0, separator);
+		this.jarEntryName = getJarEntryName(spec.substring(separator + 2));
+	}
 
-		String container = spec.substring(0, separator);
-		if (container.indexOf(SEPARATOR) == -1) {
-			this.jarFileUrl = new URL(container);
-		}
-		else {
-			this.jarFileUrl = new URL("jar:" + container);
+	private JarEntryName getJarEntryName(String spec) {
+		if (spec.length() == 0) {
+			return EMPTY_JAR_ENTRY_NAME;
 		}
+		return new JarEntryName(spec);
 	}
 
 	@Override
 	public void connect() throws IOException {
-		if (this.jarEntryName != null) {
-			this.jarEntryData = this.jarFile.getJarEntryData(this.jarEntryName);
+		if (!this.jarEntryName.isEmpty()) {
+			this.jarEntryData = this.jarFile.getJarEntryData(this.jarEntryName
+					.asAsciiBytes());
 			if (this.jarEntryData == null) {
+				if (Boolean.TRUE.equals(useFastExceptions.get())) {
+					throw FILE_NOT_FOUND_EXCEPTION;
+				}
 				throw new FileNotFoundException("JAR entry " + this.jarEntryName
 						+ " not found in " + this.jarFile.getName());
 			}
@@ -103,9 +127,24 @@ class JarURLConnection extends java.net.JarURLConnection {
 
 	@Override
 	public URL getJarFileURL() {
+		if (this.jarFileUrl == null) {
+			this.jarFileUrl = buildJarFileUrl();
+		}
 		return this.jarFileUrl;
 	}
 
+	private URL buildJarFileUrl() {
+		try {
+			if (this.jarFileUrlSpec.indexOf(SEPARATOR) == -1) {
+				return new URL(this.jarFileUrlSpec);
+			}
+			return new URL("jar:" + this.jarFileUrlSpec);
+		}
+		catch (MalformedURLException ex) {
+			throw new IllegalStateException(ex);
+		}
+	}
+
 	@Override
 	public JarEntry getJarEntry() throws IOException {
 		connect();
@@ -114,13 +153,13 @@ class JarURLConnection extends java.net.JarURLConnection {
 
 	@Override
 	public String getEntryName() {
-		return this.jarEntryName;
+		return this.jarEntryName.toString();
 	}
 
 	@Override
 	public InputStream getInputStream() throws IOException {
 		connect();
-		if (this.jarEntryName == null) {
+		if (this.jarEntryName.isEmpty()) {
 			throw new IOException("no entry name specified");
 		}
 		return this.jarEntryData.getInputStream();
@@ -130,8 +169,10 @@ class JarURLConnection extends java.net.JarURLConnection {
 	public int getContentLength() {
 		try {
 			connect();
-			return this.jarEntryData == null ? this.jarFile.size() : this.jarEntryData
-					.getSize();
+			if (this.jarEntryData != null) {
+				return this.jarEntryData.getSize();
+			}
+			return this.jarFile.size();
 		}
 		catch (IOException ex) {
 			return -1;
@@ -146,58 +187,86 @@ class JarURLConnection extends java.net.JarURLConnection {
 
 	@Override
 	public String getContentType() {
-		if (this.contentType == null) {
-			// Guess the content type, don't bother with steams as mark is not
-			// supported
-			this.contentType = (this.jarEntryName == null ? "x-java/jar" : null);
-			this.contentType = (this.contentType == null ? guessContentTypeFromName(this.jarEntryName)
-					: this.contentType);
-			this.contentType = (this.contentType == null ? "content/unknown"
-					: this.contentType);
-		}
-		return this.contentType;
+		return this.jarEntryName.getContentType();
 	}
 
-	private static String buildRootUrl(JarFile jarFile) {
-		String path = jarFile.getRootJarFile().getFile().getPath();
-		StringBuilder builder = new StringBuilder(PREFIX.length() + path.length()
-				+ SEPARATOR.length());
-		builder.append(PREFIX);
-		builder.append(path);
-		builder.append(SEPARATOR);
-		return builder.toString();
+	static void setUseFastExceptions(boolean useFastExceptions) {
+		JarURLConnection.useFastExceptions.set(useFastExceptions);
 	}
 
-	private static String decode(String source) {
-		int length = source.length();
-		if ((length == 0) || (source.indexOf('%') < 0)) {
-			return source;
+	/**
+	 * A JarEntryName parsed from a URL String.
+	 */
+	private static class JarEntryName {
+
+		private final AsciiBytes name;
+
+		private String contentType;
+
+		public JarEntryName(String spec) {
+			this.name = decode(spec);
 		}
-		ByteArrayOutputStream bos = new ByteArrayOutputStream(length);
-		for (int i = 0; i < length; i++) {
-			int ch = source.charAt(i);
-			if (ch == '%') {
-				if ((i + 2) >= length) {
-					throw new IllegalArgumentException("Invalid encoded sequence \""
-							+ source.substring(i) + "\"");
-				}
-				ch = decodeEscapeSequence(source, i);
-				i += 2;
+
+		private AsciiBytes decode(String source) {
+			int length = (source == null ? 0 : source.length());
+			if ((length == 0) || (source.indexOf('%') < 0)) {
+				return new AsciiBytes(source);
 			}
-			bos.write(ch);
+			ByteArrayOutputStream bos = new ByteArrayOutputStream(length);
+			for (int i = 0; i < length; i++) {
+				int ch = source.charAt(i);
+				if (ch == '%') {
+					if ((i + 2) >= length) {
+						throw new IllegalArgumentException("Invalid encoded sequence \""
+								+ source.substring(i) + "\"");
+					}
+					ch = decodeEscapeSequence(source, i);
+					i += 2;
+				}
+				bos.write(ch);
+			}
+			// AsciiBytes is what is used to store the JarEntries so make it symmetric
+			return new AsciiBytes(bos.toByteArray());
+		}
+
+		private char decodeEscapeSequence(String source, int i) {
+			int hi = Character.digit(source.charAt(i + 1), 16);
+			int lo = Character.digit(source.charAt(i + 2), 16);
+			if (hi == -1 || lo == -1) {
+				throw new IllegalArgumentException("Invalid encoded sequence \""
+						+ source.substring(i) + "\"");
+			}
+			return ((char) ((hi << 4) + lo));
+		}
+
+		@Override
+		public String toString() {
+			return this.name.toString();
+		}
+
+		public AsciiBytes asAsciiBytes() {
+			return this.name;
+		}
+
+		public boolean isEmpty() {
+			return this.name.length() == 0;
+		}
+
+		public String getContentType() {
+			if (this.contentType == null) {
+				this.contentType = deduceContentType();
+			}
+			return this.contentType;
+		}
+
+		private String deduceContentType() {
+			// Guess the content type, don't bother with streams as mark is not supported
+			String type = (isEmpty() ? "x-java/jar" : null);
+			type = (type != null ? type : guessContentTypeFromName(toString()));
+			type = (type != null ? type : "content/unknown");
+			return type;
 		}
-		// AsciiBytes is what is used to store the JarEntries so make it symmetric
-		return new AsciiBytes(bos.toByteArray()).toString();
 
 	}
 
-	private static char decodeEscapeSequence(String source, int i) {
-		int hi = Character.digit(source.charAt(i + 1), 16);
-		int lo = Character.digit(source.charAt(i + 2), 16);
-		if (hi == -1 || lo == -1) {
-			throw new IllegalArgumentException("Invalid encoded sequence \""
-					+ source.substring(i) + "\"");
-		}
-		return ((char) ((hi << 4) + lo));
-	}
 }

spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/util/AsciiBytes.java

@@ -128,6 +128,13 @@ public final class AsciiBytes {
 		return append(string.getBytes(UTF_8));
 	}
 
+	public AsciiBytes append(AsciiBytes asciiBytes) {
+		if (asciiBytes == null || asciiBytes.length() == 0) {
+			return this;
+		}
+		return append(asciiBytes.bytes);
+	}
+
 	public AsciiBytes append(byte[] bytes) {
 		if (bytes == null || bytes.length == 0) {
 			return this;