iterator) {
+ this.iterator = iterator;
+ }
+
+ @Override
+ public boolean hasMoreElements() {
+ return this.iterator.hasNext();
+ }
+
+ @Override
+ public java.util.jar.JarEntry nextElement() {
+ return this.iterator.next();
+ }
+
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/JarFileEntries.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/JarFileEntries.java
new file mode 100644
index 0000000000..d151c8d80a
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/JarFileEntries.java
@@ -0,0 +1,491 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jar;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.jar.Attributes;
+import java.util.jar.Attributes.Name;
+import java.util.jar.JarInputStream;
+import java.util.jar.Manifest;
+import java.util.zip.ZipEntry;
+
+import org.springframework.boot.loader.data.RandomAccessData;
+
+/**
+ * Provides access to entries from a {@link JarFile}. In order to reduce memory
+ * consumption entry details are stored using arrays. The {@code hashCodes} array stores
+ * the hash code of the entry name, the {@code centralDirectoryOffsets} provides the
+ * offset to the central directory record and {@code positions} provides the original
+ * order position of the entry. The arrays are stored in hashCode order so that a binary
+ * search can be used to find a name.
+ *
+ * A typical Spring Boot application will have somewhere in the region of 10,500 entries
+ * which should consume about 122K.
+ *
+ * @author Phillip Webb
+ * @author Andy Wilkinson
+ */
+class JarFileEntries implements CentralDirectoryVisitor, Iterable {
+
+ private static final Runnable NO_VALIDATION = () -> {
+ };
+
+ private static final String META_INF_PREFIX = "META-INF/";
+
+ private static final Name MULTI_RELEASE = new Name("Multi-Release");
+
+ private static final int BASE_VERSION = 8;
+
+ private static final int RUNTIME_VERSION = Runtime.version().feature();
+
+ private static final long LOCAL_FILE_HEADER_SIZE = 30;
+
+ private static final char SLASH = '/';
+
+ private static final char NO_SUFFIX = 0;
+
+ protected static final int ENTRY_CACHE_SIZE = 25;
+
+ private final JarFile jarFile;
+
+ private final JarEntryFilter filter;
+
+ private RandomAccessData centralDirectoryData;
+
+ private int size;
+
+ private int[] hashCodes;
+
+ private Offsets centralDirectoryOffsets;
+
+ private int[] positions;
+
+ private Boolean multiReleaseJar;
+
+ private JarEntryCertification[] certifications;
+
+ private final Map entriesCache = Collections
+ .synchronizedMap(new LinkedHashMap<>(16, 0.75f, true) {
+
+ @Override
+ protected boolean removeEldestEntry(Map.Entry eldest) {
+ return size() >= ENTRY_CACHE_SIZE;
+ }
+
+ });
+
+ JarFileEntries(JarFile jarFile, JarEntryFilter filter) {
+ this.jarFile = jarFile;
+ this.filter = filter;
+ }
+
+ @Override
+ public void visitStart(CentralDirectoryEndRecord endRecord, RandomAccessData centralDirectoryData) {
+ int maxSize = endRecord.getNumberOfRecords();
+ this.centralDirectoryData = centralDirectoryData;
+ this.hashCodes = new int[maxSize];
+ this.centralDirectoryOffsets = Offsets.from(endRecord);
+ this.positions = new int[maxSize];
+ }
+
+ @Override
+ public void visitFileHeader(CentralDirectoryFileHeader fileHeader, long dataOffset) {
+ AsciiBytes name = applyFilter(fileHeader.getName());
+ if (name != null) {
+ add(name, dataOffset);
+ }
+ }
+
+ private void add(AsciiBytes name, long dataOffset) {
+ this.hashCodes[this.size] = name.hashCode();
+ this.centralDirectoryOffsets.set(this.size, dataOffset);
+ this.positions[this.size] = this.size;
+ this.size++;
+ }
+
+ @Override
+ public void visitEnd() {
+ sort(0, this.size - 1);
+ int[] positions = this.positions;
+ this.positions = new int[positions.length];
+ for (int i = 0; i < this.size; i++) {
+ this.positions[positions[i]] = i;
+ }
+ }
+
+ int getSize() {
+ return this.size;
+ }
+
+ private void sort(int left, int right) {
+ // Quick sort algorithm, uses hashCodes as the source but sorts all arrays
+ if (left < right) {
+ int pivot = this.hashCodes[left + (right - left) / 2];
+ int i = left;
+ int j = right;
+ while (i <= j) {
+ while (this.hashCodes[i] < pivot) {
+ i++;
+ }
+ while (this.hashCodes[j] > pivot) {
+ j--;
+ }
+ if (i <= j) {
+ swap(i, j);
+ i++;
+ j--;
+ }
+ }
+ if (left < j) {
+ sort(left, j);
+ }
+ if (right > i) {
+ sort(i, right);
+ }
+ }
+ }
+
+ private void swap(int i, int j) {
+ swap(this.hashCodes, i, j);
+ this.centralDirectoryOffsets.swap(i, j);
+ swap(this.positions, i, j);
+ }
+
+ @Override
+ public Iterator iterator() {
+ return new EntryIterator(NO_VALIDATION);
+ }
+
+ Iterator iterator(Runnable validator) {
+ return new EntryIterator(validator);
+ }
+
+ boolean containsEntry(CharSequence name) {
+ return getEntry(name, FileHeader.class, true) != null;
+ }
+
+ JarEntry getEntry(CharSequence name) {
+ return getEntry(name, JarEntry.class, true);
+ }
+
+ InputStream getInputStream(String name) throws IOException {
+ FileHeader entry = getEntry(name, FileHeader.class, false);
+ return getInputStream(entry);
+ }
+
+ InputStream getInputStream(FileHeader entry) throws IOException {
+ if (entry == null) {
+ return null;
+ }
+ InputStream inputStream = getEntryData(entry).getInputStream();
+ if (entry.getMethod() == ZipEntry.DEFLATED) {
+ inputStream = new ZipInflaterInputStream(inputStream, (int) entry.getSize());
+ }
+ return inputStream;
+ }
+
+ RandomAccessData getEntryData(String name) throws IOException {
+ FileHeader entry = getEntry(name, FileHeader.class, false);
+ if (entry == null) {
+ return null;
+ }
+ return getEntryData(entry);
+ }
+
+ private RandomAccessData getEntryData(FileHeader entry) throws IOException {
+ // aspectjrt-1.7.4.jar has a different ext bytes length in the
+ // local directory to the central directory. We need to re-read
+ // here to skip them
+ RandomAccessData data = this.jarFile.getData();
+ byte[] localHeader = data.read(entry.getLocalHeaderOffset(), LOCAL_FILE_HEADER_SIZE);
+ long nameLength = Bytes.littleEndianValue(localHeader, 26, 2);
+ long extraLength = Bytes.littleEndianValue(localHeader, 28, 2);
+ return data.getSubsection(entry.getLocalHeaderOffset() + LOCAL_FILE_HEADER_SIZE + nameLength + extraLength,
+ entry.getCompressedSize());
+ }
+
+ private T getEntry(CharSequence name, Class type, boolean cacheEntry) {
+ T entry = doGetEntry(name, type, cacheEntry, null);
+ if (!isMetaInfEntry(name) && isMultiReleaseJar()) {
+ int version = RUNTIME_VERSION;
+ AsciiBytes nameAlias = (entry instanceof JarEntry jarEntry) ? jarEntry.getAsciiBytesName()
+ : new AsciiBytes(name.toString());
+ while (version > BASE_VERSION) {
+ T versionedEntry = doGetEntry("META-INF/versions/" + version + "/" + name, type, cacheEntry, nameAlias);
+ if (versionedEntry != null) {
+ return versionedEntry;
+ }
+ version--;
+ }
+ }
+ return entry;
+ }
+
+ private boolean isMetaInfEntry(CharSequence name) {
+ return name.toString().startsWith(META_INF_PREFIX);
+ }
+
+ private boolean isMultiReleaseJar() {
+ Boolean multiRelease = this.multiReleaseJar;
+ if (multiRelease != null) {
+ return multiRelease;
+ }
+ try {
+ Manifest manifest = this.jarFile.getManifest();
+ if (manifest == null) {
+ multiRelease = false;
+ }
+ else {
+ Attributes attributes = manifest.getMainAttributes();
+ multiRelease = attributes.containsKey(MULTI_RELEASE);
+ }
+ }
+ catch (IOException ex) {
+ multiRelease = false;
+ }
+ this.multiReleaseJar = multiRelease;
+ return multiRelease;
+ }
+
+ private T doGetEntry(CharSequence name, Class type, boolean cacheEntry,
+ AsciiBytes nameAlias) {
+ int hashCode = AsciiBytes.hashCode(name);
+ T entry = getEntry(hashCode, name, NO_SUFFIX, type, cacheEntry, nameAlias);
+ if (entry == null) {
+ hashCode = AsciiBytes.hashCode(hashCode, SLASH);
+ entry = getEntry(hashCode, name, SLASH, type, cacheEntry, nameAlias);
+ }
+ return entry;
+ }
+
+ private T getEntry(int hashCode, CharSequence name, char suffix, Class type,
+ boolean cacheEntry, AsciiBytes nameAlias) {
+ int index = getFirstIndex(hashCode);
+ while (index >= 0 && index < this.size && this.hashCodes[index] == hashCode) {
+ T entry = getEntry(index, type, cacheEntry, nameAlias);
+ if (entry.hasName(name, suffix)) {
+ return entry;
+ }
+ index++;
+ }
+ return null;
+ }
+
+ @SuppressWarnings("unchecked")
+ private T getEntry(int index, Class type, boolean cacheEntry, AsciiBytes nameAlias) {
+ try {
+ long offset = this.centralDirectoryOffsets.get(index);
+ FileHeader cached = this.entriesCache.get(index);
+ FileHeader entry = (cached != null) ? cached
+ : CentralDirectoryFileHeader.fromRandomAccessData(this.centralDirectoryData, offset, this.filter);
+ if (CentralDirectoryFileHeader.class.equals(entry.getClass()) && type.equals(JarEntry.class)) {
+ entry = new JarEntry(this.jarFile, index, (CentralDirectoryFileHeader) entry, nameAlias);
+ }
+ if (cacheEntry && cached != entry) {
+ this.entriesCache.put(index, entry);
+ }
+ return (T) entry;
+ }
+ catch (IOException ex) {
+ throw new IllegalStateException(ex);
+ }
+ }
+
+ private int getFirstIndex(int hashCode) {
+ int index = Arrays.binarySearch(this.hashCodes, 0, this.size, hashCode);
+ if (index < 0) {
+ return -1;
+ }
+ while (index > 0 && this.hashCodes[index - 1] == hashCode) {
+ index--;
+ }
+ return index;
+ }
+
+ void clearCache() {
+ this.entriesCache.clear();
+ }
+
+ private AsciiBytes applyFilter(AsciiBytes name) {
+ return (this.filter != null) ? this.filter.apply(name) : name;
+ }
+
+ JarEntryCertification getCertification(JarEntry entry) throws IOException {
+ JarEntryCertification[] certifications = this.certifications;
+ if (certifications == null) {
+ certifications = new JarEntryCertification[this.size];
+ // We fall back to use JarInputStream to obtain the certs. This isn't that
+ // fast, but hopefully doesn't happen too often.
+ try (JarInputStream certifiedJarStream = new JarInputStream(this.jarFile.getData().getInputStream())) {
+ java.util.jar.JarEntry certifiedEntry;
+ while ((certifiedEntry = certifiedJarStream.getNextJarEntry()) != null) {
+ // Entry must be closed to trigger a read and set entry certificates
+ certifiedJarStream.closeEntry();
+ int index = getEntryIndex(certifiedEntry.getName());
+ if (index != -1) {
+ certifications[index] = JarEntryCertification.from(certifiedEntry);
+ }
+ }
+ }
+ this.certifications = certifications;
+ }
+ JarEntryCertification certification = certifications[entry.getIndex()];
+ return (certification != null) ? certification : JarEntryCertification.NONE;
+ }
+
+ private int getEntryIndex(CharSequence name) {
+ int hashCode = AsciiBytes.hashCode(name);
+ int index = getFirstIndex(hashCode);
+ while (index >= 0 && index < this.size && this.hashCodes[index] == hashCode) {
+ FileHeader candidate = getEntry(index, FileHeader.class, false, null);
+ if (candidate.hasName(name, NO_SUFFIX)) {
+ return index;
+ }
+ index++;
+ }
+ return -1;
+ }
+
+ private static void swap(int[] array, int i, int j) {
+ int temp = array[i];
+ array[i] = array[j];
+ array[j] = temp;
+ }
+
+ private static void swap(long[] array, int i, int j) {
+ long temp = array[i];
+ array[i] = array[j];
+ array[j] = temp;
+ }
+
+ /**
+ * Iterator for contained entries.
+ */
+ private final class EntryIterator implements Iterator {
+
+ private final Runnable validator;
+
+ private int index = 0;
+
+ private EntryIterator(Runnable validator) {
+ this.validator = validator;
+ validator.run();
+ }
+
+ @Override
+ public boolean hasNext() {
+ this.validator.run();
+ return this.index < JarFileEntries.this.size;
+ }
+
+ @Override
+ public JarEntry next() {
+ this.validator.run();
+ if (!hasNext()) {
+ throw new NoSuchElementException();
+ }
+ int entryIndex = JarFileEntries.this.positions[this.index];
+ this.index++;
+ return getEntry(entryIndex, JarEntry.class, false, null);
+ }
+
+ }
+
+ /**
+ * Interface to manage offsets to central directory records. Regular zip files are
+ * backed by an {@code int[]} based implementation, Zip64 files are backed by a
+ * {@code long[]} and will consume more memory.
+ */
+ private interface Offsets {
+
+ void set(int index, long value);
+
+ long get(int index);
+
+ void swap(int i, int j);
+
+ static Offsets from(CentralDirectoryEndRecord endRecord) {
+ int size = endRecord.getNumberOfRecords();
+ return endRecord.isZip64() ? new Zip64Offsets(size) : new ZipOffsets(size);
+ }
+
+ }
+
+ /**
+ * {@link Offsets} implementation for regular zip files.
+ */
+ private static final class ZipOffsets implements Offsets {
+
+ private final int[] offsets;
+
+ private ZipOffsets(int size) {
+ this.offsets = new int[size];
+ }
+
+ @Override
+ public void swap(int i, int j) {
+ JarFileEntries.swap(this.offsets, i, j);
+ }
+
+ @Override
+ public void set(int index, long value) {
+ this.offsets[index] = (int) value;
+ }
+
+ @Override
+ public long get(int index) {
+ return this.offsets[index];
+ }
+
+ }
+
+ /**
+ * {@link Offsets} implementation for zip64 files.
+ */
+ private static final class Zip64Offsets implements Offsets {
+
+ private final long[] offsets;
+
+ private Zip64Offsets(int size) {
+ this.offsets = new long[size];
+ }
+
+ @Override
+ public void swap(int i, int j) {
+ JarFileEntries.swap(this.offsets, i, j);
+ }
+
+ @Override
+ public void set(int index, long value) {
+ this.offsets[index] = value;
+ }
+
+ @Override
+ public long get(int index) {
+ return this.offsets[index];
+ }
+
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/JarFileWrapper.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/JarFileWrapper.java
new file mode 100644
index 0000000000..b65358947a
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/JarFileWrapper.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jar;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.security.Permission;
+import java.util.Enumeration;
+import java.util.jar.JarEntry;
+import java.util.jar.Manifest;
+import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+
+/**
+ * A wrapper used to create a copy of a {@link JarFile} so that it can be safely closed
+ * without closing the original.
+ *
+ * @author Phillip Webb
+ */
+class JarFileWrapper extends AbstractJarFile {
+
+ private final JarFile parent;
+
+ JarFileWrapper(JarFile parent) throws IOException {
+ super(parent.getRootJarFile().getFile());
+ this.parent = parent;
+ super.close();
+ }
+
+ @Override
+ URL getUrl() throws MalformedURLException {
+ return this.parent.getUrl();
+ }
+
+ @Override
+ JarFileType getType() {
+ return this.parent.getType();
+ }
+
+ @Override
+ Permission getPermission() {
+ return this.parent.getPermission();
+ }
+
+ @Override
+ public Manifest getManifest() throws IOException {
+ return this.parent.getManifest();
+ }
+
+ @Override
+ public Enumeration entries() {
+ return this.parent.entries();
+ }
+
+ @Override
+ public Stream stream() {
+ return this.parent.stream();
+ }
+
+ @Override
+ public JarEntry getJarEntry(String name) {
+ return this.parent.getJarEntry(name);
+ }
+
+ @Override
+ public ZipEntry getEntry(String name) {
+ return this.parent.getEntry(name);
+ }
+
+ @Override
+ InputStream getInputStream() throws IOException {
+ return this.parent.getInputStream();
+ }
+
+ @Override
+ public synchronized InputStream getInputStream(ZipEntry ze) throws IOException {
+ return this.parent.getInputStream(ze);
+ }
+
+ @Override
+ public String getComment() {
+ return this.parent.getComment();
+ }
+
+ @Override
+ public int size() {
+ return this.parent.size();
+ }
+
+ @Override
+ public String toString() {
+ return this.parent.toString();
+ }
+
+ @Override
+ public String getName() {
+ return this.parent.getName();
+ }
+
+ static JarFile unwrap(java.util.jar.JarFile jarFile) {
+ if (jarFile instanceof JarFile file) {
+ return file;
+ }
+ if (jarFile instanceof JarFileWrapper wrapper) {
+ return unwrap(wrapper.parent);
+ }
+ throw new IllegalStateException("Not a JarFile or Wrapper");
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/JarURLConnection.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/JarURLConnection.java
new file mode 100644
index 0000000000..859ae88ab0
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/JarURLConnection.java
@@ -0,0 +1,393 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jar;
+
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLEncoder;
+import java.net.URLStreamHandler;
+import java.security.Permission;
+
+/**
+ * {@link java.net.JarURLConnection} used to support {@link JarFile#getUrl()}.
+ *
+ * @author Phillip Webb
+ * @author Andy Wilkinson
+ * @author Rostyslav Dudka
+ */
+final class JarURLConnection extends java.net.JarURLConnection {
+
+ private static final ThreadLocal useFastExceptions = new ThreadLocal<>();
+
+ private static final FileNotFoundException FILE_NOT_FOUND_EXCEPTION = new FileNotFoundException(
+ "Jar file or entry not found");
+
+ private static final IllegalStateException NOT_FOUND_CONNECTION_EXCEPTION = new IllegalStateException(
+ FILE_NOT_FOUND_EXCEPTION);
+
+ private static final String SEPARATOR = "!/";
+
+ 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(new StringSequence(""));
+
+ private static final JarURLConnection NOT_FOUND_CONNECTION = JarURLConnection.notFound();
+
+ private final AbstractJarFile jarFile;
+
+ private Permission permission;
+
+ private URL jarFileUrl;
+
+ private final JarEntryName jarEntryName;
+
+ private java.util.jar.JarEntry jarEntry;
+
+ private JarURLConnection(URL url, AbstractJarFile jarFile, JarEntryName jarEntryName) throws IOException {
+ // What we pass to super is ultimately ignored
+ super(EMPTY_JAR_URL);
+ this.url = url;
+ this.jarFile = jarFile;
+ this.jarEntryName = jarEntryName;
+ }
+
+ @Override
+ public void connect() throws IOException {
+ if (this.jarFile == null) {
+ throw FILE_NOT_FOUND_EXCEPTION;
+ }
+ if (!this.jarEntryName.isEmpty() && this.jarEntry == null) {
+ this.jarEntry = this.jarFile.getJarEntry(getEntryName());
+ if (this.jarEntry == null) {
+ throwFileNotFound(this.jarEntryName, this.jarFile);
+ }
+ }
+ this.connected = true;
+ }
+
+ @Override
+ public java.util.jar.JarFile getJarFile() throws IOException {
+ connect();
+ return this.jarFile;
+ }
+
+ @Override
+ public URL getJarFileURL() {
+ if (this.jarFile == null) {
+ throw NOT_FOUND_CONNECTION_EXCEPTION;
+ }
+ if (this.jarFileUrl == null) {
+ this.jarFileUrl = buildJarFileUrl();
+ }
+ return this.jarFileUrl;
+ }
+
+ private URL buildJarFileUrl() {
+ try {
+ String spec = this.jarFile.getUrl().getFile();
+ if (spec.endsWith(SEPARATOR)) {
+ spec = spec.substring(0, spec.length() - SEPARATOR.length());
+ }
+ if (!spec.contains(SEPARATOR)) {
+ return new URL(spec);
+ }
+ return new URL("jar:" + spec);
+ }
+ catch (MalformedURLException ex) {
+ throw new IllegalStateException(ex);
+ }
+ }
+
+ @Override
+ public java.util.jar.JarEntry getJarEntry() throws IOException {
+ if (this.jarEntryName == null || this.jarEntryName.isEmpty()) {
+ return null;
+ }
+ connect();
+ return this.jarEntry;
+ }
+
+ @Override
+ public String getEntryName() {
+ if (this.jarFile == null) {
+ throw NOT_FOUND_CONNECTION_EXCEPTION;
+ }
+ return this.jarEntryName.toString();
+ }
+
+ @Override
+ public InputStream getInputStream() throws IOException {
+ if (this.jarFile == null) {
+ throw FILE_NOT_FOUND_EXCEPTION;
+ }
+ if (this.jarEntryName.isEmpty() && this.jarFile.getType() == JarFile.JarFileType.DIRECT) {
+ throw new IOException("no entry name specified");
+ }
+ connect();
+ InputStream inputStream = (this.jarEntryName.isEmpty() ? this.jarFile.getInputStream()
+ : this.jarFile.getInputStream(this.jarEntry));
+ if (inputStream == null) {
+ throwFileNotFound(this.jarEntryName, this.jarFile);
+ }
+ return inputStream;
+ }
+
+ private void throwFileNotFound(Object entry, AbstractJarFile jarFile) throws FileNotFoundException {
+ if (Boolean.TRUE.equals(useFastExceptions.get())) {
+ throw FILE_NOT_FOUND_EXCEPTION;
+ }
+ throw new FileNotFoundException("JAR entry " + entry + " not found in " + jarFile.getName());
+ }
+
+ @Override
+ public int getContentLength() {
+ long length = getContentLengthLong();
+ if (length > Integer.MAX_VALUE) {
+ return -1;
+ }
+ return (int) length;
+ }
+
+ @Override
+ public long getContentLengthLong() {
+ if (this.jarFile == null) {
+ return -1;
+ }
+ try {
+ if (this.jarEntryName.isEmpty()) {
+ return this.jarFile.size();
+ }
+ java.util.jar.JarEntry entry = getJarEntry();
+ return (entry != null) ? (int) entry.getSize() : -1;
+ }
+ catch (IOException ex) {
+ return -1;
+ }
+ }
+
+ @Override
+ public Object getContent() throws IOException {
+ connect();
+ return this.jarEntryName.isEmpty() ? this.jarFile : super.getContent();
+ }
+
+ @Override
+ public String getContentType() {
+ return (this.jarEntryName != null) ? this.jarEntryName.getContentType() : null;
+ }
+
+ @Override
+ public Permission getPermission() throws IOException {
+ if (this.jarFile == null) {
+ throw FILE_NOT_FOUND_EXCEPTION;
+ }
+ if (this.permission == null) {
+ this.permission = this.jarFile.getPermission();
+ }
+ return this.permission;
+ }
+
+ @Override
+ public long getLastModified() {
+ if (this.jarFile == null || this.jarEntryName.isEmpty()) {
+ return 0;
+ }
+ try {
+ java.util.jar.JarEntry entry = getJarEntry();
+ return (entry != null) ? entry.getTime() : 0;
+ }
+ catch (IOException ex) {
+ return 0;
+ }
+ }
+
+ static void setUseFastExceptions(boolean useFastExceptions) {
+ JarURLConnection.useFastExceptions.set(useFastExceptions);
+ }
+
+ static JarURLConnection get(URL url, JarFile jarFile) throws IOException {
+ StringSequence spec = new StringSequence(url.getFile());
+ int index = indexOfRootSpec(spec, jarFile.getPathFromRoot());
+ if (index == -1) {
+ return (Boolean.TRUE.equals(useFastExceptions.get()) ? NOT_FOUND_CONNECTION
+ : new JarURLConnection(url, null, EMPTY_JAR_ENTRY_NAME));
+ }
+ int separator;
+ while ((separator = spec.indexOf(SEPARATOR, index)) > 0) {
+ JarEntryName entryName = JarEntryName.get(spec.subSequence(index, separator));
+ JarEntry jarEntry = jarFile.getJarEntry(entryName.toCharSequence());
+ if (jarEntry == null) {
+ return JarURLConnection.notFound(jarFile, entryName);
+ }
+ jarFile = jarFile.getNestedJarFile(jarEntry);
+ index = separator + SEPARATOR.length();
+ }
+ JarEntryName jarEntryName = JarEntryName.get(spec, index);
+ if (Boolean.TRUE.equals(useFastExceptions.get()) && !jarEntryName.isEmpty()
+ && !jarFile.containsEntry(jarEntryName.toString())) {
+ return NOT_FOUND_CONNECTION;
+ }
+ return new JarURLConnection(url, jarFile.getWrapper(), jarEntryName);
+ }
+
+ private static int indexOfRootSpec(StringSequence file, String pathFromRoot) {
+ int separatorIndex = file.indexOf(SEPARATOR);
+ if (separatorIndex < 0 || !file.startsWith(pathFromRoot, separatorIndex)) {
+ return -1;
+ }
+ return separatorIndex + SEPARATOR.length() + pathFromRoot.length();
+ }
+
+ private static JarURLConnection notFound() {
+ try {
+ return notFound(null, null);
+ }
+ catch (IOException ex) {
+ throw new IllegalStateException(ex);
+ }
+ }
+
+ private static JarURLConnection notFound(JarFile jarFile, JarEntryName jarEntryName) throws IOException {
+ if (Boolean.TRUE.equals(useFastExceptions.get())) {
+ return NOT_FOUND_CONNECTION;
+ }
+ return new JarURLConnection(null, jarFile, jarEntryName);
+ }
+
+ /**
+ * A JarEntryName parsed from a URL String.
+ */
+ static class JarEntryName {
+
+ private final StringSequence name;
+
+ private String contentType;
+
+ JarEntryName(StringSequence spec) {
+ this.name = decode(spec);
+ }
+
+ private StringSequence decode(StringSequence source) {
+ if (source.isEmpty() || (source.indexOf('%') < 0)) {
+ return source;
+ }
+ ByteArrayOutputStream bos = new ByteArrayOutputStream(source.length());
+ write(source.toString(), bos);
+ // AsciiBytes is what is used to store the JarEntries so make it symmetric
+ return new StringSequence(AsciiBytes.toString(bos.toByteArray()));
+ }
+
+ private void write(String source, ByteArrayOutputStream outputStream) {
+ int length = source.length();
+ for (int i = 0; i < length; i++) {
+ int c = source.charAt(i);
+ if (c > 127) {
+ try {
+ String encoded = URLEncoder.encode(String.valueOf((char) c), "UTF-8");
+ write(encoded, outputStream);
+ }
+ catch (UnsupportedEncodingException ex) {
+ throw new IllegalStateException(ex);
+ }
+ }
+ else {
+ if (c == '%') {
+ if ((i + 2) >= length) {
+ throw new IllegalArgumentException(
+ "Invalid encoded sequence \"" + source.substring(i) + "\"");
+ }
+ c = decodeEscapeSequence(source, i);
+ i += 2;
+ }
+ outputStream.write(c);
+ }
+ }
+ }
+
+ 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));
+ }
+
+ CharSequence toCharSequence() {
+ return this.name;
+ }
+
+ @Override
+ public String toString() {
+ return this.name.toString();
+ }
+
+ boolean isEmpty() {
+ return this.name.isEmpty();
+ }
+
+ 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;
+ }
+
+ static JarEntryName get(StringSequence spec) {
+ return get(spec, 0);
+ }
+
+ static JarEntryName get(StringSequence spec, int beginIndex) {
+ if (spec.length() <= beginIndex) {
+ return EMPTY_JAR_ENTRY_NAME;
+ }
+ return new JarEntryName(spec.subSequence(beginIndex));
+ }
+
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/StringSequence.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/StringSequence.java
new file mode 100644
index 0000000000..12850a4ebe
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/StringSequence.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jar;
+
+import java.util.Objects;
+
+/**
+ * A {@link CharSequence} backed by a single shared {@link String}. Unlike a regular
+ * {@link String}, {@link #subSequence(int, int)} operations will not copy the underlying
+ * character array.
+ *
+ * @author Phillip Webb
+ */
+final class StringSequence implements CharSequence {
+
+ private final String source;
+
+ private final int start;
+
+ private final int end;
+
+ private int hash;
+
+ StringSequence(String source) {
+ this(source, 0, (source != null) ? source.length() : -1);
+ }
+
+ StringSequence(String source, int start, int end) {
+ Objects.requireNonNull(source, "Source must not be null");
+ if (start < 0) {
+ throw new StringIndexOutOfBoundsException(start);
+ }
+ if (end > source.length()) {
+ throw new StringIndexOutOfBoundsException(end);
+ }
+ this.source = source;
+ this.start = start;
+ this.end = end;
+ }
+
+ StringSequence subSequence(int start) {
+ return subSequence(start, length());
+ }
+
+ @Override
+ public StringSequence subSequence(int start, int end) {
+ int subSequenceStart = this.start + start;
+ int subSequenceEnd = this.start + end;
+ if (subSequenceStart > this.end) {
+ throw new StringIndexOutOfBoundsException(start);
+ }
+ if (subSequenceEnd > this.end) {
+ throw new StringIndexOutOfBoundsException(end);
+ }
+ if (start == 0 && subSequenceEnd == this.end) {
+ return this;
+ }
+ return new StringSequence(this.source, subSequenceStart, subSequenceEnd);
+ }
+
+ /**
+ * Returns {@code true} if the sequence is empty. Public to be compatible with JDK 15.
+ * @return {@code true} if {@link #length()} is {@code 0}, otherwise {@code false}
+ */
+ public boolean isEmpty() {
+ return length() == 0;
+ }
+
+ @Override
+ public int length() {
+ return this.end - this.start;
+ }
+
+ @Override
+ public char charAt(int index) {
+ return this.source.charAt(this.start + index);
+ }
+
+ int indexOf(char ch) {
+ return this.source.indexOf(ch, this.start) - this.start;
+ }
+
+ int indexOf(String str) {
+ return this.source.indexOf(str, this.start) - this.start;
+ }
+
+ int indexOf(String str, int fromIndex) {
+ return this.source.indexOf(str, this.start + fromIndex) - this.start;
+ }
+
+ boolean startsWith(String prefix) {
+ return startsWith(prefix, 0);
+ }
+
+ boolean startsWith(String prefix, int offset) {
+ int prefixLength = prefix.length();
+ int length = length();
+ if (length - prefixLength - offset < 0) {
+ return false;
+ }
+ return this.source.startsWith(prefix, this.start + offset);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!(obj instanceof CharSequence other)) {
+ return false;
+ }
+ int n = length();
+ if (n != other.length()) {
+ return false;
+ }
+ int i = 0;
+ while (n-- != 0) {
+ if (charAt(i) != other.charAt(i)) {
+ return false;
+ }
+ i++;
+ }
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = this.hash;
+ if (hash == 0 && length() > 0) {
+ for (int i = this.start; i < this.end; i++) {
+ hash = 31 * hash + this.source.charAt(i);
+ }
+ this.hash = hash;
+ }
+ return hash;
+ }
+
+ @Override
+ public String toString() {
+ return this.source.substring(this.start, this.end);
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/ZipInflaterInputStream.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/ZipInflaterInputStream.java
new file mode 100644
index 0000000000..67624460cc
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/ZipInflaterInputStream.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jar;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.zip.Inflater;
+import java.util.zip.InflaterInputStream;
+
+/**
+ * {@link InflaterInputStream} that supports the writing of an extra "dummy" byte (which
+ * is required with JDK 6) and returns accurate available() results.
+ *
+ * @author Phillip Webb
+ */
+class ZipInflaterInputStream extends InflaterInputStream {
+
+ private int available;
+
+ private boolean extraBytesWritten;
+
+ ZipInflaterInputStream(InputStream inputStream, int size) {
+ super(inputStream, new Inflater(true), getInflaterBufferSize(size));
+ this.available = size;
+ }
+
+ @Override
+ public int available() throws IOException {
+ if (this.available < 0) {
+ return super.available();
+ }
+ return this.available;
+ }
+
+ @Override
+ public int read(byte[] b, int off, int len) throws IOException {
+ int result = super.read(b, off, len);
+ if (result != -1) {
+ this.available -= result;
+ }
+ return result;
+ }
+
+ @Override
+ public void close() throws IOException {
+ super.close();
+ this.inf.end();
+ }
+
+ @Override
+ protected void fill() throws IOException {
+ try {
+ super.fill();
+ }
+ catch (EOFException ex) {
+ if (this.extraBytesWritten) {
+ throw ex;
+ }
+ this.len = 1;
+ this.buf[0] = 0x0;
+ this.extraBytesWritten = true;
+ this.inf.setInput(this.buf, 0, this.len);
+ }
+ }
+
+ private static int getInflaterBufferSize(long size) {
+ size += 2; // inflater likes some space
+ size = (size > 65536) ? 8192 : size;
+ size = (size <= 0) ? 4096 : size;
+ return (int) size;
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/package-info.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/package-info.java
new file mode 100644
index 0000000000..638afe45f4
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jar/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.
+ */
+
+/**
+ * Support for loading and manipulating JAR/WAR files.
+ */
+package org.springframework.boot.loader.jar;
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jarmode/JarMode.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jarmode/JarMode.java
new file mode 100644
index 0000000000..162e4a6a73
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jarmode/JarMode.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jarmode;
+
+/**
+ * Interface registered in {@code spring.factories} to provides extended 'jarmode'
+ * support.
+ *
+ * @author Phillip Webb
+ * @since 2.3.0
+ */
+public interface JarMode {
+
+ /**
+ * Returns if this accepts and can run the given mode.
+ * @param mode the mode to check
+ * @return if this instance accepts the mode
+ */
+ boolean accepts(String mode);
+
+ /**
+ * Run the jar in the given mode.
+ * @param mode the mode to use
+ * @param args any program arguments
+ */
+ void run(String mode, String[] args);
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jarmode/JarModeLauncher.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jarmode/JarModeLauncher.java
new file mode 100644
index 0000000000..600266a241
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jarmode/JarModeLauncher.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jarmode;
+
+import java.util.List;
+
+import org.springframework.core.io.support.SpringFactoriesLoader;
+import org.springframework.util.ClassUtils;
+
+/**
+ * Delegate class used to launch the uber jar in a specific mode.
+ *
+ * @author Phillip Webb
+ * @since 2.3.0
+ */
+public final class JarModeLauncher {
+
+ static final String DISABLE_SYSTEM_EXIT = JarModeLauncher.class.getName() + ".DISABLE_SYSTEM_EXIT";
+
+ private JarModeLauncher() {
+ }
+
+ public static void main(String[] args) {
+ String mode = System.getProperty("jarmode");
+ List candidates = SpringFactoriesLoader.loadFactories(JarMode.class,
+ ClassUtils.getDefaultClassLoader());
+ for (JarMode candidate : candidates) {
+ if (candidate.accepts(mode)) {
+ candidate.run(mode, args);
+ return;
+ }
+ }
+ System.err.println("Unsupported jarmode '" + mode + "'");
+ if (!Boolean.getBoolean(DISABLE_SYSTEM_EXIT)) {
+ System.exit(1);
+ }
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jarmode/TestJarMode.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jarmode/TestJarMode.java
new file mode 100644
index 0000000000..2e17175690
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jarmode/TestJarMode.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jarmode;
+
+import java.util.Arrays;
+
+/**
+ * {@link JarMode} for testing.
+ *
+ * @author Phillip Webb
+ */
+class TestJarMode implements JarMode {
+
+ @Override
+ public boolean accepts(String mode) {
+ return "test".equals(mode);
+ }
+
+ @Override
+ public void run(String mode, String[] args) {
+ System.out.println("running in " + mode + " jar mode " + Arrays.asList(args));
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jarmode/package-info.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jarmode/package-info.java
new file mode 100644
index 0000000000..2f3b5a74e8
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/jarmode/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.
+ */
+
+/**
+ * Support for launching the JAR using jarmode.
+ *
+ * @see org.springframework.boot.loader.jarmode.JarModeLauncher
+ */
+package org.springframework.boot.loader.jarmode;
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/launch/JarLauncher.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/launch/JarLauncher.java
new file mode 100644
index 0000000000..5beb8d1096
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/launch/JarLauncher.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.launch;
+
+/**
+ * Repackaged {@link org.springframework.boot.loader.JarLauncher}.
+ *
+ * @author Phillip Webb
+ * @since 3.2.0
+ */
+public final class JarLauncher {
+
+ private JarLauncher() {
+ }
+
+ public static void main(String[] args) throws Exception {
+ org.springframework.boot.loader.JarLauncher.main(args);
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/launch/PropertiesLauncher.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/launch/PropertiesLauncher.java
new file mode 100644
index 0000000000..d80fb0bb71
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/launch/PropertiesLauncher.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.launch;
+
+/**
+ * Repackaged {@link org.springframework.boot.loader.PropertiesLauncher}.
+ *
+ * @author Phillip Webb
+ * @since 3.2.0
+ */
+public final class PropertiesLauncher {
+
+ private PropertiesLauncher() {
+ }
+
+ public static void main(String[] args) throws Exception {
+ org.springframework.boot.loader.PropertiesLauncher.main(args);
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/launch/WarLauncher.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/launch/WarLauncher.java
new file mode 100644
index 0000000000..9392d3bf2b
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/launch/WarLauncher.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.launch;
+
+/**
+ * Repackaged {@link org.springframework.boot.loader.WarLauncher}.
+ *
+ * @author Phillip Webb
+ * @since 3.2.0
+ */
+public final class WarLauncher {
+
+ private WarLauncher() {
+ }
+
+ public static void main(String[] args) throws Exception {
+ org.springframework.boot.loader.WarLauncher.main(args);
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/launch/package-info.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/launch/package-info.java
new file mode 100644
index 0000000000..7968d509a2
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/launch/package-info.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.
+ */
+
+/**
+ * Repackaged launcher classes.
+ *
+ * @see org.springframework.boot.loader.launch.JarLauncher
+ * @see org.springframework.boot.loader.launch.WarLauncher
+ */
+package org.springframework.boot.loader.launch;
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/package-info.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/package-info.java
new file mode 100644
index 0000000000..4b32f644f5
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.
+ */
+
+/**
+ * System that allows self-contained JAR/WAR archives to be launched using
+ * {@code java -jar}. Archives can include nested packaged dependency JARs (there is no
+ * need to create shade style jars) and are executed without unpacking. The only
+ * constraint is that nested JARs must be stored in the archive uncompressed.
+ *
+ * @see org.springframework.boot.loader.JarLauncher
+ * @see org.springframework.boot.loader.WarLauncher
+ */
+package org.springframework.boot.loader;
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/util/SystemPropertyUtils.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/util/SystemPropertyUtils.java
new file mode 100644
index 0000000000..df00705e9e
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/util/SystemPropertyUtils.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.util;
+
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Properties;
+import java.util.Set;
+
+/**
+ * Helper class for resolving placeholders in texts. Usually applied to file paths.
+ *
+ * A text may contain {@code $ ...} placeholders, to be resolved as system properties:
+ * e.g. {@code $ user.dir}. Default values can be supplied using the ":" separator between
+ * key and value.
+ *
+ * Adapted from Spring.
+ *
+ * @author Juergen Hoeller
+ * @author Rob Harrop
+ * @author Dave Syer
+ * @since 1.0.0
+ * @see System#getProperty(String)
+ */
+public abstract class SystemPropertyUtils {
+
+ /**
+ * Prefix for system property placeholders: "${".
+ */
+ public static final String PLACEHOLDER_PREFIX = "${";
+
+ /**
+ * Suffix for system property placeholders: "}".
+ */
+ public static final String PLACEHOLDER_SUFFIX = "}";
+
+ /**
+ * Value separator for system property placeholders: ":".
+ */
+ public static final String VALUE_SEPARATOR = ":";
+
+ private static final String SIMPLE_PREFIX = PLACEHOLDER_PREFIX.substring(1);
+
+ /**
+ * Resolve ${...} placeholders in the given text, replacing them with corresponding
+ * system property values.
+ * @param text the String to resolve
+ * @return the resolved String
+ * @throws IllegalArgumentException if there is an unresolvable placeholder
+ * @see #PLACEHOLDER_PREFIX
+ * @see #PLACEHOLDER_SUFFIX
+ */
+ public static String resolvePlaceholders(String text) {
+ if (text == null) {
+ return text;
+ }
+ return parseStringValue(null, text, text, new HashSet<>());
+ }
+
+ /**
+ * Resolve ${...} placeholders in the given text, replacing them with corresponding
+ * system property values.
+ * @param properties a properties instance to use in addition to System
+ * @param text the String to resolve
+ * @return the resolved String
+ * @throws IllegalArgumentException if there is an unresolvable placeholder
+ * @see #PLACEHOLDER_PREFIX
+ * @see #PLACEHOLDER_SUFFIX
+ */
+ public static String resolvePlaceholders(Properties properties, String text) {
+ if (text == null) {
+ return text;
+ }
+ return parseStringValue(properties, text, text, new HashSet<>());
+ }
+
+ private static String parseStringValue(Properties properties, String value, String current,
+ Set visitedPlaceholders) {
+
+ StringBuilder buf = new StringBuilder(current);
+
+ int startIndex = current.indexOf(PLACEHOLDER_PREFIX);
+ while (startIndex != -1) {
+ int endIndex = findPlaceholderEndIndex(buf, startIndex);
+ if (endIndex != -1) {
+ String placeholder = buf.substring(startIndex + PLACEHOLDER_PREFIX.length(), endIndex);
+ String originalPlaceholder = placeholder;
+ if (!visitedPlaceholders.add(originalPlaceholder)) {
+ throw new IllegalArgumentException(
+ "Circular placeholder reference '" + originalPlaceholder + "' in property definitions");
+ }
+ // Recursive invocation, parsing placeholders contained in the
+ // placeholder
+ // key.
+ placeholder = parseStringValue(properties, value, placeholder, visitedPlaceholders);
+ // Now obtain the value for the fully resolved key...
+ String propVal = resolvePlaceholder(properties, value, placeholder);
+ if (propVal == null) {
+ int separatorIndex = placeholder.indexOf(VALUE_SEPARATOR);
+ if (separatorIndex != -1) {
+ String actualPlaceholder = placeholder.substring(0, separatorIndex);
+ String defaultValue = placeholder.substring(separatorIndex + VALUE_SEPARATOR.length());
+ propVal = resolvePlaceholder(properties, value, actualPlaceholder);
+ if (propVal == null) {
+ propVal = defaultValue;
+ }
+ }
+ }
+ if (propVal != null) {
+ // Recursive invocation, parsing placeholders contained in the
+ // previously resolved placeholder value.
+ propVal = parseStringValue(properties, value, propVal, visitedPlaceholders);
+ buf.replace(startIndex, endIndex + PLACEHOLDER_SUFFIX.length(), propVal);
+ startIndex = buf.indexOf(PLACEHOLDER_PREFIX, startIndex + propVal.length());
+ }
+ else {
+ // Proceed with unprocessed value.
+ startIndex = buf.indexOf(PLACEHOLDER_PREFIX, endIndex + PLACEHOLDER_SUFFIX.length());
+ }
+ visitedPlaceholders.remove(originalPlaceholder);
+ }
+ else {
+ startIndex = -1;
+ }
+ }
+
+ return buf.toString();
+ }
+
+ private static String resolvePlaceholder(Properties properties, String text, String placeholderName) {
+ String propVal = getProperty(placeholderName, null, text);
+ if (propVal != null) {
+ return propVal;
+ }
+ return (properties != null) ? properties.getProperty(placeholderName) : null;
+ }
+
+ public static String getProperty(String key) {
+ return getProperty(key, null, "");
+ }
+
+ public static String getProperty(String key, String defaultValue) {
+ return getProperty(key, defaultValue, "");
+ }
+
+ /**
+ * Search the System properties and environment variables for a value with the
+ * provided key. Environment variables in {@code UPPER_CASE} style are allowed where
+ * System properties would normally be {@code lower.case}.
+ * @param key the key to resolve
+ * @param defaultValue the default value
+ * @param text optional extra context for an error message if the key resolution fails
+ * (e.g. if System properties are not accessible)
+ * @return a static property value or null of not found
+ */
+ public static String getProperty(String key, String defaultValue, String text) {
+ try {
+ String propVal = System.getProperty(key);
+ if (propVal == null) {
+ // Fall back to searching the system environment.
+ propVal = System.getenv(key);
+ }
+ if (propVal == null) {
+ // Try with underscores.
+ String name = key.replace('.', '_');
+ propVal = System.getenv(name);
+ }
+ if (propVal == null) {
+ // Try uppercase with underscores as well.
+ String name = key.toUpperCase(Locale.ENGLISH).replace('.', '_');
+ propVal = System.getenv(name);
+ }
+ if (propVal != null) {
+ return propVal;
+ }
+ }
+ catch (Throwable ex) {
+ System.err.println("Could not resolve key '" + key + "' in '" + text
+ + "' as system property or in environment: " + ex);
+ }
+ return defaultValue;
+ }
+
+ private static int findPlaceholderEndIndex(CharSequence buf, int startIndex) {
+ int index = startIndex + PLACEHOLDER_PREFIX.length();
+ int withinNestedPlaceholder = 0;
+ while (index < buf.length()) {
+ if (substringMatch(buf, index, PLACEHOLDER_SUFFIX)) {
+ if (withinNestedPlaceholder > 0) {
+ withinNestedPlaceholder--;
+ index = index + PLACEHOLDER_SUFFIX.length();
+ }
+ else {
+ return index;
+ }
+ }
+ else if (substringMatch(buf, index, SIMPLE_PREFIX)) {
+ withinNestedPlaceholder++;
+ index = index + SIMPLE_PREFIX.length();
+ }
+ else {
+ index++;
+ }
+ }
+ return -1;
+ }
+
+ private static boolean substringMatch(CharSequence str, int index, CharSequence substring) {
+ for (int j = 0; j < substring.length(); j++) {
+ int i = index + j;
+ if (i >= str.length() || str.charAt(i) != substring.charAt(j)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/util/package-info.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/util/package-info.java
new file mode 100644
index 0000000000..d3d7eef2d9
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/main/java/org/springframework/boot/loader/util/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.
+ */
+
+/**
+ * Utilities used by Spring Boot's JAR loading.
+ */
+package org.springframework.boot.loader.util;
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/AbstractExecutableArchiveLauncherTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/AbstractExecutableArchiveLauncherTests.java
new file mode 100644
index 0000000000..60e3cb2765
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/AbstractExecutableArchiveLauncherTests.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
+import java.util.zip.CRC32;
+import java.util.zip.ZipEntry;
+
+import org.junit.jupiter.api.io.TempDir;
+
+import org.springframework.boot.loader.archive.Archive;
+import org.springframework.util.FileCopyUtils;
+
+/**
+ * Base class for testing {@link ExecutableArchiveLauncher} implementations.
+ *
+ * @author Andy Wilkinson
+ * @author Madhura Bhave
+ * @author Scott Frederick
+ */
+public abstract class AbstractExecutableArchiveLauncherTests {
+
+ @TempDir
+ File tempDir;
+
+ protected File createJarArchive(String name, String entryPrefix) throws IOException {
+ return createJarArchive(name, entryPrefix, false, Collections.emptyList());
+ }
+
+ @SuppressWarnings("resource")
+ protected File createJarArchive(String name, String entryPrefix, boolean indexed, List extraLibs)
+ throws IOException {
+ return createJarArchive(name, null, entryPrefix, indexed, extraLibs);
+ }
+
+ @SuppressWarnings("resource")
+ protected File createJarArchive(String name, Manifest manifest, String entryPrefix, boolean indexed,
+ List extraLibs) throws IOException {
+ File archive = new File(this.tempDir, name);
+ JarOutputStream jarOutputStream = new JarOutputStream(new FileOutputStream(archive));
+ if (manifest != null) {
+ jarOutputStream.putNextEntry(new JarEntry("META-INF/"));
+ jarOutputStream.putNextEntry(new JarEntry("META-INF/MANIFEST.MF"));
+ manifest.write(jarOutputStream);
+ jarOutputStream.closeEntry();
+ }
+ jarOutputStream.putNextEntry(new JarEntry(entryPrefix + "/"));
+ jarOutputStream.putNextEntry(new JarEntry(entryPrefix + "/classes/"));
+ jarOutputStream.putNextEntry(new JarEntry(entryPrefix + "/lib/"));
+ if (indexed) {
+ jarOutputStream.putNextEntry(new JarEntry(entryPrefix + "/classpath.idx"));
+ Writer writer = new OutputStreamWriter(jarOutputStream, StandardCharsets.UTF_8);
+ writer.write("- \"" + entryPrefix + "/lib/foo.jar\"\n");
+ writer.write("- \"" + entryPrefix + "/lib/bar.jar\"\n");
+ writer.write("- \"" + entryPrefix + "/lib/baz.jar\"\n");
+ writer.flush();
+ jarOutputStream.closeEntry();
+ }
+ addNestedJars(entryPrefix, "/lib/foo.jar", jarOutputStream);
+ addNestedJars(entryPrefix, "/lib/bar.jar", jarOutputStream);
+ addNestedJars(entryPrefix, "/lib/baz.jar", jarOutputStream);
+ for (String lib : extraLibs) {
+ addNestedJars(entryPrefix, "/lib/" + lib, jarOutputStream);
+ }
+ jarOutputStream.close();
+ return archive;
+ }
+
+ private void addNestedJars(String entryPrefix, String lib, JarOutputStream jarOutputStream) throws IOException {
+ JarEntry libFoo = new JarEntry(entryPrefix + lib);
+ libFoo.setMethod(ZipEntry.STORED);
+ ByteArrayOutputStream fooJarStream = new ByteArrayOutputStream();
+ new JarOutputStream(fooJarStream).close();
+ libFoo.setSize(fooJarStream.size());
+ CRC32 crc32 = new CRC32();
+ crc32.update(fooJarStream.toByteArray());
+ libFoo.setCrc(crc32.getValue());
+ jarOutputStream.putNextEntry(libFoo);
+ jarOutputStream.write(fooJarStream.toByteArray());
+ }
+
+ protected File explode(File archive) throws IOException {
+ File exploded = new File(this.tempDir, "exploded");
+ exploded.mkdirs();
+ JarFile jarFile = new JarFile(archive);
+ Enumeration entries = jarFile.entries();
+ while (entries.hasMoreElements()) {
+ JarEntry entry = entries.nextElement();
+ File entryFile = new File(exploded, entry.getName());
+ if (entry.isDirectory()) {
+ entryFile.mkdirs();
+ }
+ else {
+ FileCopyUtils.copy(jarFile.getInputStream(entry), new FileOutputStream(entryFile));
+ }
+ }
+ jarFile.close();
+ return exploded;
+ }
+
+ protected Set getUrls(List archives) throws MalformedURLException {
+ Set urls = new LinkedHashSet<>(archives.size());
+ for (Archive archive : archives) {
+ urls.add(archive.getUrl());
+ }
+ return urls;
+ }
+
+ protected final URL toUrl(File file) {
+ try {
+ return file.toURI().toURL();
+ }
+ catch (MalformedURLException ex) {
+ throw new IllegalStateException(ex);
+ }
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/ClassPathIndexFileTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/ClassPathIndexFileTests.java
new file mode 100644
index 0000000000..4cd1b4e8d2
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/ClassPathIndexFileTests.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+
+/**
+ * Tests for {@link ClassPathIndexFile}.
+ *
+ * @author Madhura Bhave
+ * @author Phillip Webb
+ */
+class ClassPathIndexFileTests {
+
+ @TempDir
+ File temp;
+
+ @Test
+ void loadIfPossibleWhenRootIsNotFileReturnsNull() {
+ assertThatIllegalArgumentException()
+ .isThrownBy(() -> ClassPathIndexFile.loadIfPossible(new URL("https://example.com/file"), "test.idx"))
+ .withMessage("URL does not reference a file");
+ }
+
+ @Test
+ void loadIfPossibleWhenRootDoesNotExistReturnsNull() throws Exception {
+ File root = new File(this.temp, "missing");
+ assertThat(ClassPathIndexFile.loadIfPossible(root.toURI().toURL(), "test.idx")).isNull();
+ }
+
+ @Test
+ void loadIfPossibleWhenRootIsDirectoryThrowsException() throws Exception {
+ File root = new File(this.temp, "directory");
+ root.mkdirs();
+ assertThat(ClassPathIndexFile.loadIfPossible(root.toURI().toURL(), "test.idx")).isNull();
+ }
+
+ @Test
+ void loadIfPossibleReturnsInstance() throws Exception {
+ ClassPathIndexFile indexFile = copyAndLoadTestIndexFile();
+ assertThat(indexFile).isNotNull();
+ }
+
+ @Test
+ void sizeReturnsNumberOfLines() throws Exception {
+ ClassPathIndexFile indexFile = copyAndLoadTestIndexFile();
+ assertThat(indexFile.size()).isEqualTo(5);
+ }
+
+ @Test
+ void getUrlsReturnsUrls() throws Exception {
+ ClassPathIndexFile indexFile = copyAndLoadTestIndexFile();
+ List urls = indexFile.getUrls();
+ List expected = new ArrayList<>();
+ expected.add(new File(this.temp, "BOOT-INF/layers/one/lib/a.jar"));
+ expected.add(new File(this.temp, "BOOT-INF/layers/one/lib/b.jar"));
+ expected.add(new File(this.temp, "BOOT-INF/layers/one/lib/c.jar"));
+ expected.add(new File(this.temp, "BOOT-INF/layers/two/lib/d.jar"));
+ expected.add(new File(this.temp, "BOOT-INF/layers/two/lib/e.jar"));
+ assertThat(urls).containsExactly(expected.stream().map(this::toUrl).toArray(URL[]::new));
+ }
+
+ private URL toUrl(File file) {
+ try {
+ return file.toURI().toURL();
+ }
+ catch (MalformedURLException ex) {
+ throw new IllegalStateException(ex);
+ }
+ }
+
+ private ClassPathIndexFile copyAndLoadTestIndexFile() throws IOException {
+ copyTestIndexFile();
+ ClassPathIndexFile indexFile = ClassPathIndexFile.loadIfPossible(this.temp.toURI().toURL(), "test.idx");
+ return indexFile;
+ }
+
+ private void copyTestIndexFile() throws IOException {
+ Files.copy(getClass().getResourceAsStream("classpath-index-file.idx"),
+ new File(this.temp, "test.idx").toPath());
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/JarLauncherTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/JarLauncherTests.java
new file mode 100644
index 0000000000..afa32a7c4f
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/JarLauncherTests.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.jar.Attributes;
+import java.util.jar.Attributes.Name;
+import java.util.jar.Manifest;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.boot.loader.archive.Archive;
+import org.springframework.boot.loader.archive.ExplodedArchive;
+import org.springframework.boot.loader.archive.JarFileArchive;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.test.tools.SourceFile;
+import org.springframework.core.test.tools.TestCompiler;
+import org.springframework.util.FileCopyUtils;
+import org.springframework.util.function.ThrowingConsumer;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link JarLauncher}.
+ *
+ * @author Andy Wilkinson
+ * @author Madhura Bhave
+ */
+class JarLauncherTests extends AbstractExecutableArchiveLauncherTests {
+
+ @Test
+ void explodedJarHasOnlyBootInfClassesAndContentsOfBootInfLibOnClasspath() throws Exception {
+ File explodedRoot = explode(createJarArchive("archive.jar", "BOOT-INF"));
+ JarLauncher launcher = new JarLauncher(new ExplodedArchive(explodedRoot, true));
+ List archives = new ArrayList<>();
+ launcher.getClassPathArchivesIterator().forEachRemaining(archives::add);
+ assertThat(getUrls(archives)).containsExactlyInAnyOrder(getExpectedFileUrls(explodedRoot));
+ for (Archive archive : archives) {
+ archive.close();
+ }
+ }
+
+ @Test
+ void archivedJarHasOnlyBootInfClassesAndContentsOfBootInfLibOnClasspath() throws Exception {
+ File jarRoot = createJarArchive("archive.jar", "BOOT-INF");
+ try (JarFileArchive archive = new JarFileArchive(jarRoot)) {
+ JarLauncher launcher = new JarLauncher(archive);
+ List classPathArchives = new ArrayList<>();
+ launcher.getClassPathArchivesIterator().forEachRemaining(classPathArchives::add);
+ assertThat(classPathArchives).hasSize(4);
+ assertThat(getUrls(classPathArchives)).containsOnly(
+ new URL("jar:" + jarRoot.toURI().toURL() + "!/BOOT-INF/classes!/"),
+ new URL("jar:" + jarRoot.toURI().toURL() + "!/BOOT-INF/lib/foo.jar!/"),
+ new URL("jar:" + jarRoot.toURI().toURL() + "!/BOOT-INF/lib/bar.jar!/"),
+ new URL("jar:" + jarRoot.toURI().toURL() + "!/BOOT-INF/lib/baz.jar!/"));
+ for (Archive classPathArchive : classPathArchives) {
+ classPathArchive.close();
+ }
+ }
+ }
+
+ @Test
+ void explodedJarShouldPreserveClasspathOrderWhenIndexPresent() throws Exception {
+ File explodedRoot = explode(createJarArchive("archive.jar", "BOOT-INF", true, Collections.emptyList()));
+ JarLauncher launcher = new JarLauncher(new ExplodedArchive(explodedRoot, true));
+ Iterator archives = launcher.getClassPathArchivesIterator();
+ URLClassLoader classLoader = (URLClassLoader) launcher.createClassLoader(archives);
+ URL[] urls = classLoader.getURLs();
+ assertThat(urls).containsExactly(getExpectedFileUrls(explodedRoot));
+ }
+
+ @Test
+ void jarFilesPresentInBootInfLibsAndNotInClasspathIndexShouldBeAddedAfterBootInfClasses() throws Exception {
+ ArrayList extraLibs = new ArrayList<>(Arrays.asList("extra-1.jar", "extra-2.jar"));
+ File explodedRoot = explode(createJarArchive("archive.jar", "BOOT-INF", true, extraLibs));
+ JarLauncher launcher = new JarLauncher(new ExplodedArchive(explodedRoot, true));
+ Iterator archives = launcher.getClassPathArchivesIterator();
+ URLClassLoader classLoader = (URLClassLoader) launcher.createClassLoader(archives);
+ URL[] urls = classLoader.getURLs();
+ List expectedFiles = getExpectedFilesWithExtraLibs(explodedRoot);
+ URL[] expectedFileUrls = expectedFiles.stream().map(this::toUrl).toArray(URL[]::new);
+ assertThat(urls).containsExactly(expectedFileUrls);
+ }
+
+ @Test
+ void explodedJarDefinedPackagesIncludeManifestAttributes() {
+ Manifest manifest = new Manifest();
+ Attributes attributes = manifest.getMainAttributes();
+ attributes.put(Name.MANIFEST_VERSION, "1.0");
+ attributes.put(Name.IMPLEMENTATION_TITLE, "test");
+ SourceFile sourceFile = SourceFile.of("explodedsample/ExampleClass.java",
+ new ClassPathResource("explodedsample/ExampleClass.txt"));
+ TestCompiler.forSystem().compile(sourceFile, ThrowingConsumer.of((compiled) -> {
+ File explodedRoot = explode(
+ createJarArchive("archive.jar", manifest, "BOOT-INF", true, Collections.emptyList()));
+ File target = new File(explodedRoot, "BOOT-INF/classes/explodedsample/ExampleClass.class");
+ target.getParentFile().mkdirs();
+ FileCopyUtils.copy(compiled.getClassLoader().getResourceAsStream("explodedsample/ExampleClass.class"),
+ new FileOutputStream(target));
+ JarLauncher launcher = new JarLauncher(new ExplodedArchive(explodedRoot, true));
+ Iterator archives = launcher.getClassPathArchivesIterator();
+ URLClassLoader classLoader = (URLClassLoader) launcher.createClassLoader(archives);
+ Class loaded = classLoader.loadClass("explodedsample.ExampleClass");
+ assertThat(loaded.getPackage().getImplementationTitle()).isEqualTo("test");
+ }));
+ }
+
+ protected final URL[] getExpectedFileUrls(File explodedRoot) {
+ return getExpectedFiles(explodedRoot).stream().map(this::toUrl).toArray(URL[]::new);
+ }
+
+ protected final List getExpectedFiles(File parent) {
+ List expected = new ArrayList<>();
+ expected.add(new File(parent, "BOOT-INF/classes"));
+ expected.add(new File(parent, "BOOT-INF/lib/foo.jar"));
+ expected.add(new File(parent, "BOOT-INF/lib/bar.jar"));
+ expected.add(new File(parent, "BOOT-INF/lib/baz.jar"));
+ return expected;
+ }
+
+ protected final List getExpectedFilesWithExtraLibs(File parent) {
+ List expected = new ArrayList<>();
+ expected.add(new File(parent, "BOOT-INF/classes"));
+ expected.add(new File(parent, "BOOT-INF/lib/extra-1.jar"));
+ expected.add(new File(parent, "BOOT-INF/lib/extra-2.jar"));
+ expected.add(new File(parent, "BOOT-INF/lib/foo.jar"));
+ expected.add(new File(parent, "BOOT-INF/lib/bar.jar"));
+ expected.add(new File(parent, "BOOT-INF/lib/baz.jar"));
+ return expected;
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/LaunchedURLClassLoaderTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/LaunchedURLClassLoaderTests.java
new file mode 100644
index 0000000000..58084bba8a
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/LaunchedURLClassLoaderTests.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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;
+
+import java.io.File;
+import java.io.InputStream;
+import java.net.JarURLConnection;
+import java.net.URL;
+import java.net.URLConnection;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import org.springframework.boot.loader.jar.JarFile;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link LaunchedURLClassLoader}.
+ *
+ * @author Dave Syer
+ * @author Phillip Webb
+ * @author Andy Wilkinson
+ */
+@SuppressWarnings("resource")
+class LaunchedURLClassLoaderTests {
+
+ @TempDir
+ File tempDir;
+
+ @Test
+ void resolveResourceFromArchive() throws Exception {
+ LaunchedURLClassLoader loader = new LaunchedURLClassLoader(
+ new URL[] { new URL("jar:file:src/test/resources/jars/app.jar!/") }, getClass().getClassLoader());
+ assertThat(loader.getResource("demo/Application.java")).isNotNull();
+ }
+
+ @Test
+ void resolveResourcesFromArchive() throws Exception {
+ LaunchedURLClassLoader loader = new LaunchedURLClassLoader(
+ new URL[] { new URL("jar:file:src/test/resources/jars/app.jar!/") }, getClass().getClassLoader());
+ assertThat(loader.getResources("demo/Application.java").hasMoreElements()).isTrue();
+ }
+
+ @Test
+ void resolveRootPathFromArchive() throws Exception {
+ LaunchedURLClassLoader loader = new LaunchedURLClassLoader(
+ new URL[] { new URL("jar:file:src/test/resources/jars/app.jar!/") }, getClass().getClassLoader());
+ assertThat(loader.getResource("")).isNotNull();
+ }
+
+ @Test
+ void resolveRootResourcesFromArchive() throws Exception {
+ LaunchedURLClassLoader loader = new LaunchedURLClassLoader(
+ new URL[] { new URL("jar:file:src/test/resources/jars/app.jar!/") }, getClass().getClassLoader());
+ assertThat(loader.getResources("").hasMoreElements()).isTrue();
+ }
+
+ @Test
+ void resolveFromNested() throws Exception {
+ File file = new File(this.tempDir, "test.jar");
+ TestJarCreator.createTestJar(file);
+ try (JarFile jarFile = new JarFile(file)) {
+ URL url = jarFile.getUrl();
+ try (LaunchedURLClassLoader loader = new LaunchedURLClassLoader(new URL[] { url }, null)) {
+ URL resource = loader.getResource("nested.jar!/3.dat");
+ assertThat(resource).hasToString(url + "nested.jar!/3.dat");
+ try (InputStream input = resource.openConnection().getInputStream()) {
+ assertThat(input.read()).isEqualTo(3);
+ }
+ }
+ }
+ }
+
+ @Test
+ void resolveFromNestedWhileThreadIsInterrupted() throws Exception {
+ File file = new File(this.tempDir, "test.jar");
+ TestJarCreator.createTestJar(file);
+ try (JarFile jarFile = new JarFile(file)) {
+ URL url = jarFile.getUrl();
+ try (LaunchedURLClassLoader loader = new LaunchedURLClassLoader(new URL[] { url }, null)) {
+ Thread.currentThread().interrupt();
+ URL resource = loader.getResource("nested.jar!/3.dat");
+ assertThat(resource).hasToString(url + "nested.jar!/3.dat");
+ URLConnection connection = resource.openConnection();
+ try (InputStream input = connection.getInputStream()) {
+ assertThat(input.read()).isEqualTo(3);
+ }
+ ((JarURLConnection) connection).getJarFile().close();
+ }
+ finally {
+ Thread.interrupted();
+ }
+ }
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/PropertiesLauncherTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/PropertiesLauncherTests.java
new file mode 100644
index 0000000000..ab7c296b38
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/PropertiesLauncherTests.java
@@ -0,0 +1,433 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.lang.ref.SoftReference;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.jar.Attributes;
+import java.util.jar.Manifest;
+
+import org.assertj.core.api.Condition;
+import org.awaitility.Awaitility;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.io.TempDir;
+
+import org.springframework.boot.loader.archive.Archive;
+import org.springframework.boot.loader.archive.ExplodedArchive;
+import org.springframework.boot.loader.archive.JarFileArchive;
+import org.springframework.boot.loader.jar.Handler;
+import org.springframework.boot.loader.jar.JarFile;
+import org.springframework.boot.testsupport.system.CapturedOutput;
+import org.springframework.boot.testsupport.system.OutputCaptureExtension;
+import org.springframework.core.io.FileSystemResource;
+import org.springframework.test.util.ReflectionTestUtils;
+import org.springframework.util.FileCopyUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
+import static org.hamcrest.Matchers.containsString;
+
+/**
+ * Tests for {@link PropertiesLauncher}.
+ *
+ * @author Dave Syer
+ * @author Andy Wilkinson
+ */
+@ExtendWith(OutputCaptureExtension.class)
+class PropertiesLauncherTests {
+
+ @TempDir
+ File tempDir;
+
+ private PropertiesLauncher launcher;
+
+ private ClassLoader contextClassLoader;
+
+ private CapturedOutput output;
+
+ @BeforeEach
+ void setup(CapturedOutput capturedOutput) throws Exception {
+ this.contextClassLoader = Thread.currentThread().getContextClassLoader();
+ clearHandlerCache();
+ System.setProperty("loader.home", new File("src/test/resources").getAbsolutePath());
+ this.output = capturedOutput;
+ }
+
+ @AfterEach
+ void close() throws Exception {
+ Thread.currentThread().setContextClassLoader(this.contextClassLoader);
+ System.clearProperty("loader.home");
+ System.clearProperty("loader.path");
+ System.clearProperty("loader.main");
+ System.clearProperty("loader.config.name");
+ System.clearProperty("loader.config.location");
+ System.clearProperty("loader.system");
+ System.clearProperty("loader.classLoader");
+ clearHandlerCache();
+ if (this.launcher != null) {
+ this.launcher.close();
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private void clearHandlerCache() throws Exception {
+ Map rootFileCache = ((SoftReference>) ReflectionTestUtils
+ .getField(Handler.class, "rootFileCache")).get();
+ if (rootFileCache != null) {
+ for (JarFile rootJarFile : rootFileCache.values()) {
+ rootJarFile.close();
+ }
+ rootFileCache.clear();
+ }
+ }
+
+ @Test
+ void testDefaultHome() {
+ System.clearProperty("loader.home");
+ this.launcher = new PropertiesLauncher();
+ assertThat(this.launcher.getHomeDirectory()).isEqualTo(new File(System.getProperty("user.dir")));
+ }
+
+ @Test
+ void testAlternateHome() throws Exception {
+ System.setProperty("loader.home", "src/test/resources/home");
+ this.launcher = new PropertiesLauncher();
+ assertThat(this.launcher.getHomeDirectory()).isEqualTo(new File(System.getProperty("loader.home")));
+ assertThat(this.launcher.getMainClass()).isEqualTo("demo.HomeApplication");
+ }
+
+ @Test
+ void testNonExistentHome() {
+ System.setProperty("loader.home", "src/test/resources/nonexistent");
+ assertThatIllegalStateException().isThrownBy(PropertiesLauncher::new)
+ .withMessageContaining("Invalid source directory")
+ .withCauseInstanceOf(IllegalArgumentException.class);
+ }
+
+ @Test
+ void testUserSpecifiedMain() throws Exception {
+ this.launcher = new PropertiesLauncher();
+ assertThat(this.launcher.getMainClass()).isEqualTo("demo.Application");
+ assertThat(System.getProperty("loader.main")).isNull();
+ }
+
+ @Test
+ void testUserSpecifiedConfigName() throws Exception {
+ System.setProperty("loader.config.name", "foo");
+ this.launcher = new PropertiesLauncher();
+ assertThat(this.launcher.getMainClass()).isEqualTo("my.Application");
+ assertThat(ReflectionTestUtils.getField(this.launcher, "paths")).hasToString("[etc/]");
+ }
+
+ @Test
+ void testRootOfClasspathFirst() throws Exception {
+ System.setProperty("loader.config.name", "bar");
+ this.launcher = new PropertiesLauncher();
+ assertThat(this.launcher.getMainClass()).isEqualTo("my.BarApplication");
+ }
+
+ @Test
+ void testUserSpecifiedDotPath() {
+ System.setProperty("loader.path", ".");
+ this.launcher = new PropertiesLauncher();
+ assertThat(ReflectionTestUtils.getField(this.launcher, "paths")).hasToString("[.]");
+ }
+
+ @Test
+ void testUserSpecifiedSlashPath() throws Exception {
+ System.setProperty("loader.path", "jars/");
+ this.launcher = new PropertiesLauncher();
+ assertThat(ReflectionTestUtils.getField(this.launcher, "paths")).hasToString("[jars/]");
+ List archives = new ArrayList<>();
+ this.launcher.getClassPathArchivesIterator().forEachRemaining(archives::add);
+ assertThat(archives).areExactly(1, endingWith("app.jar"));
+ }
+
+ @Test
+ void testUserSpecifiedWildcardPath() throws Exception {
+ System.setProperty("loader.path", "jars/*");
+ System.setProperty("loader.main", "demo.Application");
+ this.launcher = new PropertiesLauncher();
+ assertThat(ReflectionTestUtils.getField(this.launcher, "paths")).hasToString("[jars/]");
+ this.launcher.launch(new String[0]);
+ waitFor("Hello World");
+ }
+
+ @Test
+ void testUserSpecifiedJarPath() throws Exception {
+ System.setProperty("loader.path", "jars/app.jar");
+ System.setProperty("loader.main", "demo.Application");
+ this.launcher = new PropertiesLauncher();
+ assertThat(ReflectionTestUtils.getField(this.launcher, "paths")).hasToString("[jars/app.jar]");
+ this.launcher.launch(new String[0]);
+ waitFor("Hello World");
+ }
+
+ @Test
+ void testUserSpecifiedRootOfJarPath() throws Exception {
+ System.setProperty("loader.path", "jar:file:./src/test/resources/nested-jars/app.jar!/");
+ this.launcher = new PropertiesLauncher();
+ assertThat(ReflectionTestUtils.getField(this.launcher, "paths"))
+ .hasToString("[jar:file:./src/test/resources/nested-jars/app.jar!/]");
+ List archives = new ArrayList<>();
+ this.launcher.getClassPathArchivesIterator().forEachRemaining(archives::add);
+ assertThat(archives).areExactly(1, endingWith("foo.jar!/"));
+ assertThat(archives).areExactly(1, endingWith("app.jar"));
+ }
+
+ @Test
+ void testUserSpecifiedRootOfJarPathWithDot() throws Exception {
+ System.setProperty("loader.path", "nested-jars/app.jar!/./");
+ this.launcher = new PropertiesLauncher();
+ List archives = new ArrayList<>();
+ this.launcher.getClassPathArchivesIterator().forEachRemaining(archives::add);
+ assertThat(archives).areExactly(1, endingWith("foo.jar!/"));
+ assertThat(archives).areExactly(1, endingWith("app.jar"));
+ }
+
+ @Test
+ void testUserSpecifiedRootOfJarPathWithDotAndJarPrefix() throws Exception {
+ System.setProperty("loader.path", "jar:file:./src/test/resources/nested-jars/app.jar!/./");
+ this.launcher = new PropertiesLauncher();
+ List archives = new ArrayList<>();
+ this.launcher.getClassPathArchivesIterator().forEachRemaining(archives::add);
+ assertThat(archives).areExactly(1, endingWith("foo.jar!/"));
+ }
+
+ @Test
+ void testUserSpecifiedJarFileWithNestedArchives() throws Exception {
+ System.setProperty("loader.path", "nested-jars/app.jar");
+ System.setProperty("loader.main", "demo.Application");
+ this.launcher = new PropertiesLauncher();
+ List archives = new ArrayList<>();
+ this.launcher.getClassPathArchivesIterator().forEachRemaining(archives::add);
+ assertThat(archives).areExactly(1, endingWith("foo.jar!/"));
+ assertThat(archives).areExactly(1, endingWith("app.jar"));
+ }
+
+ @Test
+ void testUserSpecifiedNestedJarPath() throws Exception {
+ System.setProperty("loader.path", "nested-jars/nested-jar-app.jar!/BOOT-INF/classes/");
+ System.setProperty("loader.main", "demo.Application");
+ this.launcher = new PropertiesLauncher();
+ assertThat(ReflectionTestUtils.getField(this.launcher, "paths"))
+ .hasToString("[nested-jars/nested-jar-app.jar!/BOOT-INF/classes/]");
+ this.launcher.launch(new String[0]);
+ waitFor("Hello World");
+ }
+
+ @Test
+ void testUserSpecifiedDirectoryContainingJarFileWithNestedArchives() throws Exception {
+ System.setProperty("loader.path", "nested-jars");
+ System.setProperty("loader.main", "demo.Application");
+ this.launcher = new PropertiesLauncher();
+ this.launcher.launch(new String[0]);
+ waitFor("Hello World");
+ }
+
+ @Test
+ void testUserSpecifiedJarPathWithDot() throws Exception {
+ System.setProperty("loader.path", "./jars/app.jar");
+ System.setProperty("loader.main", "demo.Application");
+ this.launcher = new PropertiesLauncher();
+ assertThat(ReflectionTestUtils.getField(this.launcher, "paths")).hasToString("[jars/app.jar]");
+ this.launcher.launch(new String[0]);
+ waitFor("Hello World");
+ }
+
+ @Test
+ void testUserSpecifiedClassLoader() throws Exception {
+ System.setProperty("loader.path", "jars/app.jar");
+ System.setProperty("loader.classLoader", URLClassLoader.class.getName());
+ this.launcher = new PropertiesLauncher();
+ assertThat(ReflectionTestUtils.getField(this.launcher, "paths")).hasToString("[jars/app.jar]");
+ this.launcher.launch(new String[0]);
+ waitFor("Hello World");
+ }
+
+ @Test
+ void testUserSpecifiedClassPathOrder() throws Exception {
+ System.setProperty("loader.path", "more-jars/app.jar,jars/app.jar");
+ System.setProperty("loader.classLoader", URLClassLoader.class.getName());
+ this.launcher = new PropertiesLauncher();
+ assertThat(ReflectionTestUtils.getField(this.launcher, "paths"))
+ .hasToString("[more-jars/app.jar, jars/app.jar]");
+ this.launcher.launch(new String[0]);
+ waitFor("Hello Other World");
+ }
+
+ @Test
+ void testCustomClassLoaderCreation() throws Exception {
+ System.setProperty("loader.classLoader", TestLoader.class.getName());
+ this.launcher = new PropertiesLauncher();
+ ClassLoader loader = this.launcher.createClassLoader(archives());
+ assertThat(loader).isNotNull();
+ assertThat(loader.getClass().getName()).isEqualTo(TestLoader.class.getName());
+ }
+
+ private Iterator archives() throws Exception {
+ List archives = new ArrayList<>();
+ String path = System.getProperty("java.class.path");
+ for (String url : path.split(File.pathSeparator)) {
+ Archive archive = archive(url);
+ if (archive != null) {
+ archives.add(archive);
+ }
+ }
+ return archives.iterator();
+ }
+
+ private Archive archive(String url) throws IOException {
+ File file = new FileSystemResource(url).getFile();
+ if (!file.exists()) {
+ return null;
+ }
+ if (url.endsWith(".jar")) {
+ return new JarFileArchive(file);
+ }
+ return new ExplodedArchive(file);
+ }
+
+ @Test
+ void testUserSpecifiedConfigPathWins() throws Exception {
+ System.setProperty("loader.config.name", "foo");
+ System.setProperty("loader.config.location", "classpath:bar.properties");
+ this.launcher = new PropertiesLauncher();
+ assertThat(this.launcher.getMainClass()).isEqualTo("my.BarApplication");
+ }
+
+ @Test
+ void testSystemPropertySpecifiedMain() throws Exception {
+ System.setProperty("loader.main", "foo.Bar");
+ this.launcher = new PropertiesLauncher();
+ assertThat(this.launcher.getMainClass()).isEqualTo("foo.Bar");
+ }
+
+ @Test
+ void testSystemPropertiesSet() {
+ System.setProperty("loader.system", "true");
+ new PropertiesLauncher();
+ assertThat(System.getProperty("loader.main")).isEqualTo("demo.Application");
+ }
+
+ @Test
+ void testArgsEnhanced() throws Exception {
+ System.setProperty("loader.args", "foo");
+ this.launcher = new PropertiesLauncher();
+ assertThat(Arrays.asList(this.launcher.getArgs("bar"))).hasToString("[foo, bar]");
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ void testLoadPathCustomizedUsingManifest() throws Exception {
+ System.setProperty("loader.home", this.tempDir.getAbsolutePath());
+ Manifest manifest = new Manifest();
+ manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
+ manifest.getMainAttributes().putValue("Loader-Path", "/foo.jar, /bar");
+ File manifestFile = new File(this.tempDir, "META-INF/MANIFEST.MF");
+ manifestFile.getParentFile().mkdirs();
+ try (FileOutputStream manifestStream = new FileOutputStream(manifestFile)) {
+ manifest.write(manifestStream);
+ }
+ this.launcher = new PropertiesLauncher();
+ assertThat((List) ReflectionTestUtils.getField(this.launcher, "paths")).containsExactly("/foo.jar",
+ "/bar/");
+ }
+
+ @Test
+ void testManifestWithPlaceholders() throws Exception {
+ System.setProperty("loader.home", "src/test/resources/placeholders");
+ this.launcher = new PropertiesLauncher();
+ assertThat(this.launcher.getMainClass()).isEqualTo("demo.FooApplication");
+ }
+
+ @Test
+ void encodedFileUrlLoaderPathIsHandledCorrectly() throws Exception {
+ File loaderPath = new File(this.tempDir, "loader path");
+ loaderPath.mkdir();
+ System.setProperty("loader.path", loaderPath.toURI().toURL().toString());
+ this.launcher = new PropertiesLauncher();
+ List archives = new ArrayList<>();
+ this.launcher.getClassPathArchivesIterator().forEachRemaining(archives::add);
+ assertThat(archives).hasSize(1);
+ File archiveRoot = (File) ReflectionTestUtils.getField(archives.get(0), "root");
+ assertThat(archiveRoot).isEqualTo(loaderPath);
+ }
+
+ @Test // gh-21575
+ void loadResourceFromJarFile() throws Exception {
+ File jarFile = new File(this.tempDir, "app.jar");
+ TestJarCreator.createTestJar(jarFile);
+ System.setProperty("loader.home", this.tempDir.getAbsolutePath());
+ System.setProperty("loader.path", "app.jar");
+ this.launcher = new PropertiesLauncher();
+ try {
+ this.launcher.launch(new String[0]);
+ }
+ catch (Exception ex) {
+ // Expected ClassNotFoundException
+ LaunchedURLClassLoader classLoader = (LaunchedURLClassLoader) Thread.currentThread()
+ .getContextClassLoader();
+ classLoader.close();
+ }
+ URL resource = new URL("jar:" + jarFile.toURI() + "!/nested.jar!/3.dat");
+ byte[] bytes = FileCopyUtils.copyToByteArray(resource.openStream());
+ assertThat(bytes).isNotEmpty();
+ }
+
+ private void waitFor(String value) {
+ Awaitility.waitAtMost(Duration.ofSeconds(5)).until(this.output::toString, containsString(value));
+ }
+
+ private Condition endingWith(String value) {
+ return new Condition<>() {
+
+ @Override
+ public boolean matches(Archive archive) {
+ return archive.toString().endsWith(value);
+ }
+
+ };
+ }
+
+ static class TestLoader extends URLClassLoader {
+
+ TestLoader(ClassLoader parent) {
+ super(new URL[0], parent);
+ }
+
+ @Override
+ protected Class findClass(String name) throws ClassNotFoundException {
+ return super.findClass(name);
+ }
+
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/TestJarCreator.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/TestJarCreator.java
new file mode 100644
index 0000000000..c5c5fd3b95
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/TestJarCreator.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.jar.Attributes;
+import java.util.jar.JarEntry;
+import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
+import java.util.zip.CRC32;
+import java.util.zip.ZipEntry;
+
+/**
+ * Creates a simple test jar.
+ *
+ * @author Phillip Webb
+ */
+public abstract class TestJarCreator {
+
+ private static final int BASE_VERSION = 8;
+
+ private static final int RUNTIME_VERSION;
+
+ static {
+ int version;
+ try {
+ Object runtimeVersion = Runtime.class.getMethod("version").invoke(null);
+ version = (int) runtimeVersion.getClass().getMethod("major").invoke(runtimeVersion);
+ }
+ catch (Throwable ex) {
+ version = BASE_VERSION;
+ }
+ RUNTIME_VERSION = version;
+ }
+
+ public static void createTestJar(File file) throws Exception {
+ createTestJar(file, false);
+ }
+
+ public static void createTestJar(File file, boolean unpackNested) throws Exception {
+ FileOutputStream fileOutputStream = new FileOutputStream(file);
+ try (JarOutputStream jarOutputStream = new JarOutputStream(fileOutputStream)) {
+ jarOutputStream.setComment("outer");
+ writeManifest(jarOutputStream, "j1");
+ writeEntry(jarOutputStream, "1.dat", 1);
+ writeEntry(jarOutputStream, "2.dat", 2);
+ writeDirEntry(jarOutputStream, "d/");
+ writeEntry(jarOutputStream, "d/9.dat", 9);
+ writeDirEntry(jarOutputStream, "special/");
+ writeEntry(jarOutputStream, "special/\u00EB.dat", '\u00EB');
+ writeNestedEntry("nested.jar", unpackNested, jarOutputStream);
+ writeNestedEntry("another-nested.jar", unpackNested, jarOutputStream);
+ writeNestedEntry("space nested.jar", unpackNested, jarOutputStream);
+ writeNestedMultiReleaseEntry("multi-release.jar", unpackNested, jarOutputStream);
+ }
+ }
+
+ private static void writeNestedEntry(String name, boolean unpackNested, JarOutputStream jarOutputStream)
+ throws Exception {
+ writeNestedEntry(name, unpackNested, jarOutputStream, false);
+ }
+
+ private static void writeNestedMultiReleaseEntry(String name, boolean unpackNested, JarOutputStream jarOutputStream)
+ throws Exception {
+ writeNestedEntry(name, unpackNested, jarOutputStream, true);
+ }
+
+ private static void writeNestedEntry(String name, boolean unpackNested, JarOutputStream jarOutputStream,
+ boolean multiRelease) throws Exception {
+ JarEntry nestedEntry = new JarEntry(name);
+ byte[] nestedJarData = getNestedJarData(multiRelease);
+ nestedEntry.setSize(nestedJarData.length);
+ nestedEntry.setCompressedSize(nestedJarData.length);
+ if (unpackNested) {
+ nestedEntry.setComment("UNPACK:0000000000000000000000000000000000000000");
+ }
+ CRC32 crc32 = new CRC32();
+ crc32.update(nestedJarData);
+ nestedEntry.setCrc(crc32.getValue());
+ nestedEntry.setMethod(ZipEntry.STORED);
+ jarOutputStream.putNextEntry(nestedEntry);
+ jarOutputStream.write(nestedJarData);
+ jarOutputStream.closeEntry();
+ }
+
+ private static byte[] getNestedJarData(boolean multiRelease) throws Exception {
+ ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+ JarOutputStream jarOutputStream = new JarOutputStream(byteArrayOutputStream);
+ jarOutputStream.setComment("nested");
+ writeManifest(jarOutputStream, "j2", multiRelease);
+ if (multiRelease) {
+ writeEntry(jarOutputStream, "multi-release.dat", BASE_VERSION);
+ writeEntry(jarOutputStream, String.format("META-INF/versions/%d/multi-release.dat", RUNTIME_VERSION),
+ RUNTIME_VERSION);
+ }
+ else {
+ writeEntry(jarOutputStream, "3.dat", 3);
+ writeEntry(jarOutputStream, "4.dat", 4);
+ writeEntry(jarOutputStream, "\u00E4.dat", '\u00E4');
+ }
+ jarOutputStream.close();
+ return byteArrayOutputStream.toByteArray();
+ }
+
+ private static void writeManifest(JarOutputStream jarOutputStream, String name) throws Exception {
+ writeManifest(jarOutputStream, name, false);
+ }
+
+ private static void writeManifest(JarOutputStream jarOutputStream, String name, boolean multiRelease)
+ throws Exception {
+ writeDirEntry(jarOutputStream, "META-INF/");
+ Manifest manifest = new Manifest();
+ manifest.getMainAttributes().putValue("Built-By", name);
+ manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
+ if (multiRelease) {
+ manifest.getMainAttributes().putValue("Multi-Release", Boolean.toString(true));
+ }
+ jarOutputStream.putNextEntry(new ZipEntry("META-INF/MANIFEST.MF"));
+ manifest.write(jarOutputStream);
+ jarOutputStream.closeEntry();
+ }
+
+ private static void writeDirEntry(JarOutputStream jarOutputStream, String name) throws IOException {
+ jarOutputStream.putNextEntry(new JarEntry(name));
+ jarOutputStream.closeEntry();
+ }
+
+ private static void writeEntry(JarOutputStream jarOutputStream, String name, int data) throws IOException {
+ jarOutputStream.putNextEntry(new JarEntry(name));
+ jarOutputStream.write(new byte[] { (byte) data });
+ jarOutputStream.closeEntry();
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/WarLauncherTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/WarLauncherTests.java
new file mode 100644
index 0000000000..fbab8d36ed
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/WarLauncherTests.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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;
+
+import java.io.File;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.boot.loader.archive.Archive;
+import org.springframework.boot.loader.archive.ExplodedArchive;
+import org.springframework.boot.loader.archive.JarFileArchive;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link WarLauncher}.
+ *
+ * @author Andy Wilkinson
+ * @author Scott Frederick
+ */
+class WarLauncherTests extends AbstractExecutableArchiveLauncherTests {
+
+ @Test
+ void explodedWarHasOnlyWebInfClassesAndContentsOfWebInfLibOnClasspath() throws Exception {
+ File explodedRoot = explode(createJarArchive("archive.war", "WEB-INF"));
+ WarLauncher launcher = new WarLauncher(new ExplodedArchive(explodedRoot, true));
+ List archives = new ArrayList<>();
+ launcher.getClassPathArchivesIterator().forEachRemaining(archives::add);
+ assertThat(getUrls(archives)).containsExactlyInAnyOrder(getExpectedFileUrls(explodedRoot));
+ for (Archive archive : archives) {
+ archive.close();
+ }
+ }
+
+ @Test
+ void archivedWarHasOnlyWebInfClassesAndContentsOfWebInfLibOnClasspath() throws Exception {
+ File jarRoot = createJarArchive("archive.war", "WEB-INF");
+ try (JarFileArchive archive = new JarFileArchive(jarRoot)) {
+ WarLauncher launcher = new WarLauncher(archive);
+ List classPathArchives = new ArrayList<>();
+ launcher.getClassPathArchivesIterator().forEachRemaining(classPathArchives::add);
+ assertThat(getUrls(classPathArchives)).containsOnly(
+ new URL("jar:" + jarRoot.toURI().toURL() + "!/WEB-INF/classes!/"),
+ new URL("jar:" + jarRoot.toURI().toURL() + "!/WEB-INF/lib/foo.jar!/"),
+ new URL("jar:" + jarRoot.toURI().toURL() + "!/WEB-INF/lib/bar.jar!/"),
+ new URL("jar:" + jarRoot.toURI().toURL() + "!/WEB-INF/lib/baz.jar!/"));
+ for (Archive classPathArchive : classPathArchives) {
+ classPathArchive.close();
+ }
+ }
+ }
+
+ @Test
+ void explodedWarShouldPreserveClasspathOrderWhenIndexPresent() throws Exception {
+ File explodedRoot = explode(createJarArchive("archive.war", "WEB-INF", true, Collections.emptyList()));
+ WarLauncher launcher = new WarLauncher(new ExplodedArchive(explodedRoot, true));
+ Iterator archives = launcher.getClassPathArchivesIterator();
+ URLClassLoader classLoader = (URLClassLoader) launcher.createClassLoader(archives);
+ URL[] urls = classLoader.getURLs();
+ assertThat(urls).containsExactly(getExpectedFileUrls(explodedRoot));
+ }
+
+ @Test
+ void warFilesPresentInWebInfLibsAndNotInClasspathIndexShouldBeAddedAfterWebInfClasses() throws Exception {
+ ArrayList extraLibs = new ArrayList<>(Arrays.asList("extra-1.jar", "extra-2.jar"));
+ File explodedRoot = explode(createJarArchive("archive.war", "WEB-INF", true, extraLibs));
+ WarLauncher launcher = new WarLauncher(new ExplodedArchive(explodedRoot, true));
+ Iterator archives = launcher.getClassPathArchivesIterator();
+ URLClassLoader classLoader = (URLClassLoader) launcher.createClassLoader(archives);
+ URL[] urls = classLoader.getURLs();
+ List expectedFiles = getExpectedFilesWithExtraLibs(explodedRoot);
+ URL[] expectedFileUrls = expectedFiles.stream().map(this::toUrl).toArray(URL[]::new);
+ assertThat(urls).containsExactly(expectedFileUrls);
+ }
+
+ protected final URL[] getExpectedFileUrls(File explodedRoot) {
+ return getExpectedFiles(explodedRoot).stream().map(this::toUrl).toArray(URL[]::new);
+ }
+
+ protected final List getExpectedFiles(File parent) {
+ List expected = new ArrayList<>();
+ expected.add(new File(parent, "WEB-INF/classes"));
+ expected.add(new File(parent, "WEB-INF/lib/foo.jar"));
+ expected.add(new File(parent, "WEB-INF/lib/bar.jar"));
+ expected.add(new File(parent, "WEB-INF/lib/baz.jar"));
+ return expected;
+ }
+
+ protected final List getExpectedFilesWithExtraLibs(File parent) {
+ List expected = new ArrayList<>();
+ expected.add(new File(parent, "WEB-INF/classes"));
+ expected.add(new File(parent, "WEB-INF/lib/extra-1.jar"));
+ expected.add(new File(parent, "WEB-INF/lib/extra-2.jar"));
+ expected.add(new File(parent, "WEB-INF/lib/foo.jar"));
+ expected.add(new File(parent, "WEB-INF/lib/bar.jar"));
+ expected.add(new File(parent, "WEB-INF/lib/baz.jar"));
+ return expected;
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/archive/ExplodedArchiveTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/archive/ExplodedArchiveTests.java
new file mode 100755
index 0000000000..77d2ce185c
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/archive/ExplodedArchiveTests.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.archive;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import org.springframework.boot.loader.TestJarCreator;
+import org.springframework.boot.loader.archive.Archive.Entry;
+import org.springframework.util.FileCopyUtils;
+import org.springframework.util.StringUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link ExplodedArchive}.
+ *
+ * @author Phillip Webb
+ * @author Dave Syer
+ * @author Andy Wilkinson
+ */
+class ExplodedArchiveTests {
+
+ @TempDir
+ File tempDir;
+
+ private File rootDirectory;
+
+ private ExplodedArchive archive;
+
+ @BeforeEach
+ void setup() throws Exception {
+ createArchive();
+ }
+
+ @AfterEach
+ void tearDown() throws Exception {
+ if (this.archive != null) {
+ this.archive.close();
+ }
+ }
+
+ private void createArchive() throws Exception {
+ createArchive(null);
+ }
+
+ private void createArchive(String directoryName) throws Exception {
+ File file = new File(this.tempDir, "test.jar");
+ TestJarCreator.createTestJar(file);
+ this.rootDirectory = (StringUtils.hasText(directoryName) ? new File(this.tempDir, directoryName)
+ : new File(this.tempDir, UUID.randomUUID().toString()));
+ JarFile jarFile = new JarFile(file);
+ Enumeration entries = jarFile.entries();
+ while (entries.hasMoreElements()) {
+ JarEntry entry = entries.nextElement();
+ File destination = new File(this.rootDirectory.getAbsolutePath() + File.separator + entry.getName());
+ destination.getParentFile().mkdirs();
+ if (entry.isDirectory()) {
+ destination.mkdir();
+ }
+ else {
+ FileCopyUtils.copy(jarFile.getInputStream(entry), new FileOutputStream(destination));
+ }
+ }
+ this.archive = new ExplodedArchive(this.rootDirectory);
+ jarFile.close();
+ }
+
+ @Test
+ void getManifest() throws Exception {
+ assertThat(this.archive.getManifest().getMainAttributes().getValue("Built-By")).isEqualTo("j1");
+ }
+
+ @Test
+ void getEntries() {
+ Map entries = getEntriesMap(this.archive);
+ assertThat(entries).hasSize(12);
+ }
+
+ @Test
+ void getUrl() throws Exception {
+ assertThat(this.archive.getUrl()).isEqualTo(this.rootDirectory.toURI().toURL());
+ }
+
+ @Test
+ void getUrlWithSpaceInPath() throws Exception {
+ createArchive("spaces in the name");
+ assertThat(this.archive.getUrl()).isEqualTo(this.rootDirectory.toURI().toURL());
+ }
+
+ @Test
+ void getNestedArchive() throws Exception {
+ Entry entry = getEntriesMap(this.archive).get("nested.jar");
+ Archive nested = this.archive.getNestedArchive(entry);
+ assertThat(nested.getUrl()).hasToString(this.rootDirectory.toURI() + "nested.jar");
+ nested.close();
+ }
+
+ @Test
+ void nestedDirArchive() throws Exception {
+ Entry entry = getEntriesMap(this.archive).get("d/");
+ Archive nested = this.archive.getNestedArchive(entry);
+ Map nestedEntries = getEntriesMap(nested);
+ assertThat(nestedEntries).hasSize(1);
+ assertThat(nested.getUrl()).hasToString("file:" + this.rootDirectory.toURI().getPath() + "d/");
+ }
+
+ @Test
+ void getNonRecursiveEntriesForRoot() throws Exception {
+ try (ExplodedArchive explodedArchive = new ExplodedArchive(new File("/"), false)) {
+ Map entries = getEntriesMap(explodedArchive);
+ assertThat(entries).hasSizeGreaterThan(1);
+ }
+ }
+
+ @Test
+ void getNonRecursiveManifest() throws Exception {
+ try (ExplodedArchive explodedArchive = new ExplodedArchive(new File("src/test/resources/root"))) {
+ assertThat(explodedArchive.getManifest()).isNotNull();
+ Map entries = getEntriesMap(explodedArchive);
+ assertThat(entries).hasSize(4);
+ }
+ }
+
+ @Test
+ void getNonRecursiveManifestEvenIfNonRecursive() throws Exception {
+ try (ExplodedArchive explodedArchive = new ExplodedArchive(new File("src/test/resources/root"), false)) {
+ assertThat(explodedArchive.getManifest()).isNotNull();
+ Map entries = getEntriesMap(explodedArchive);
+ assertThat(entries).hasSize(3);
+ }
+ }
+
+ @Test
+ void getResourceAsStream() throws Exception {
+ try (ExplodedArchive explodedArchive = new ExplodedArchive(new File("src/test/resources/root"))) {
+ assertThat(explodedArchive.getManifest()).isNotNull();
+ URLClassLoader loader = new URLClassLoader(new URL[] { explodedArchive.getUrl() });
+ assertThat(loader.getResourceAsStream("META-INF/spring/application.xml")).isNotNull();
+ loader.close();
+ }
+ }
+
+ @Test
+ void getResourceAsStreamNonRecursive() throws Exception {
+ try (ExplodedArchive explodedArchive = new ExplodedArchive(new File("src/test/resources/root"), false)) {
+ assertThat(explodedArchive.getManifest()).isNotNull();
+ URLClassLoader loader = new URLClassLoader(new URL[] { explodedArchive.getUrl() });
+ assertThat(loader.getResourceAsStream("META-INF/spring/application.xml")).isNotNull();
+ loader.close();
+ }
+ }
+
+ private Map getEntriesMap(Archive archive) {
+ Map entries = new HashMap<>();
+ for (Archive.Entry entry : archive) {
+ entries.put(entry.getName(), entry);
+ }
+ return entries;
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/archive/JarFileArchiveTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/archive/JarFileArchiveTests.java
new file mode 100755
index 0000000000..4b2ce93af6
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/archive/JarFileArchiveTests.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.archive;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.jar.JarEntry;
+import java.util.jar.JarOutputStream;
+import java.util.zip.CRC32;
+import java.util.zip.ZipEntry;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import org.springframework.boot.loader.TestJarCreator;
+import org.springframework.boot.loader.archive.Archive.Entry;
+import org.springframework.boot.loader.jar.JarFile;
+import org.springframework.util.FileCopyUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link JarFileArchive}.
+ *
+ * @author Phillip Webb
+ * @author Andy Wilkinson
+ * @author Camille Vienot
+ */
+class JarFileArchiveTests {
+
+ @TempDir
+ File tempDir;
+
+ private File rootJarFile;
+
+ private JarFileArchive archive;
+
+ private String rootJarFileUrl;
+
+ @BeforeEach
+ void setup() throws Exception {
+ setup(false);
+ }
+
+ @AfterEach
+ void tearDown() throws Exception {
+ this.archive.close();
+ }
+
+ private void setup(boolean unpackNested) throws Exception {
+ this.rootJarFile = new File(this.tempDir, "root.jar");
+ this.rootJarFileUrl = this.rootJarFile.toURI().toString();
+ TestJarCreator.createTestJar(this.rootJarFile, unpackNested);
+ if (this.archive != null) {
+ this.archive.close();
+ }
+ this.archive = new JarFileArchive(this.rootJarFile);
+ }
+
+ @Test
+ void getManifest() throws Exception {
+ assertThat(this.archive.getManifest().getMainAttributes().getValue("Built-By")).isEqualTo("j1");
+ }
+
+ @Test
+ void getEntries() {
+ Map entries = getEntriesMap(this.archive);
+ assertThat(entries).hasSize(12);
+ }
+
+ @Test
+ void getUrl() throws Exception {
+ URL url = this.archive.getUrl();
+ assertThat(url).hasToString(this.rootJarFileUrl);
+ }
+
+ @Test
+ void getNestedArchive() throws Exception {
+ Entry entry = getEntriesMap(this.archive).get("nested.jar");
+ try (Archive nested = this.archive.getNestedArchive(entry)) {
+ assertThat(nested.getUrl()).hasToString("jar:" + this.rootJarFileUrl + "!/nested.jar!/");
+ }
+ }
+
+ @Test
+ void getNestedUnpackedArchive() throws Exception {
+ setup(true);
+ Entry entry = getEntriesMap(this.archive).get("nested.jar");
+ try (Archive nested = this.archive.getNestedArchive(entry)) {
+ assertThat(nested.getUrl().toString()).startsWith("file:");
+ assertThat(nested.getUrl().toString()).endsWith("/nested.jar");
+ }
+ }
+
+ @Test
+ void unpackedLocationsAreUniquePerArchive() throws Exception {
+ setup(true);
+ Entry entry = getEntriesMap(this.archive).get("nested.jar");
+ URL firstNestedUrl;
+ try (Archive firstNested = this.archive.getNestedArchive(entry)) {
+ firstNestedUrl = firstNested.getUrl();
+ }
+ this.archive.close();
+ setup(true);
+ entry = getEntriesMap(this.archive).get("nested.jar");
+ try (Archive secondNested = this.archive.getNestedArchive(entry)) {
+ URL secondNestedUrl = secondNested.getUrl();
+ assertThat(secondNestedUrl).isNotEqualTo(firstNestedUrl);
+ }
+ }
+
+ @Test
+ void unpackedLocationsFromSameArchiveShareSameParent() throws Exception {
+ setup(true);
+ try (Archive nestedArchive = this.archive.getNestedArchive(getEntriesMap(this.archive).get("nested.jar"));
+ Archive anotherNestedArchive = this.archive
+ .getNestedArchive(getEntriesMap(this.archive).get("another-nested.jar"))) {
+ File nested = new File(nestedArchive.getUrl().toURI());
+ File anotherNested = new File(anotherNestedArchive.getUrl().toURI());
+ assertThat(nested).hasParent(anotherNested.getParent());
+ }
+ }
+
+ @Test
+ void filesInZip64ArchivesAreAllListed() throws IOException {
+ File file = new File(this.tempDir, "test.jar");
+ FileCopyUtils.copy(writeZip64Jar(), file);
+ try (JarFileArchive zip64Archive = new JarFileArchive(file)) {
+ @SuppressWarnings("deprecation")
+ Iterator entries = zip64Archive.iterator();
+ for (int i = 0; i < 65537; i++) {
+ assertThat(entries.hasNext()).as(i + "nth file is present").isTrue();
+ entries.next();
+ }
+ }
+ }
+
+ @Test
+ void nestedZip64ArchivesAreHandledGracefully() throws Exception {
+ File file = new File(this.tempDir, "test.jar");
+ try (JarOutputStream output = new JarOutputStream(new FileOutputStream(file))) {
+ JarEntry zip64JarEntry = new JarEntry("nested/zip64.jar");
+ output.putNextEntry(zip64JarEntry);
+ byte[] zip64JarData = writeZip64Jar();
+ zip64JarEntry.setSize(zip64JarData.length);
+ zip64JarEntry.setCompressedSize(zip64JarData.length);
+ zip64JarEntry.setMethod(ZipEntry.STORED);
+ CRC32 crc32 = new CRC32();
+ crc32.update(zip64JarData);
+ zip64JarEntry.setCrc(crc32.getValue());
+ output.write(zip64JarData);
+ output.closeEntry();
+ }
+ try (JarFile jarFile = new JarFile(file)) {
+ ZipEntry nestedEntry = jarFile.getEntry("nested/zip64.jar");
+ try (JarFile nestedJarFile = jarFile.getNestedJarFile(nestedEntry)) {
+ Iterator iterator = nestedJarFile.iterator();
+ for (int i = 0; i < 65537; i++) {
+ assertThat(iterator.hasNext()).as(i + "nth file is present").isTrue();
+ iterator.next();
+ }
+ }
+ }
+ }
+
+ private byte[] writeZip64Jar() throws IOException {
+ ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+ try (JarOutputStream jarOutput = new JarOutputStream(bytes)) {
+ for (int i = 0; i < 65537; i++) {
+ jarOutput.putNextEntry(new JarEntry(i + ".dat"));
+ jarOutput.closeEntry();
+ }
+ }
+ return bytes.toByteArray();
+ }
+
+ private Map getEntriesMap(Archive archive) {
+ Map entries = new HashMap<>();
+ for (Archive.Entry entry : archive) {
+ entries.put(entry.getName(), entry);
+ }
+ return entries;
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/data/RandomAccessDataFileTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/data/RandomAccessDataFileTests.java
new file mode 100644
index 0000000000..6713814def
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/data/RandomAccessDataFileTests.java
@@ -0,0 +1,300 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.data;
+
+import java.io.EOFException;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.assertj.core.api.Assertions.assertThatNullPointerException;
+
+/**
+ * Tests for {@link RandomAccessDataFile}.
+ *
+ * @author Phillip Webb
+ * @author Andy Wilkinson
+ */
+class RandomAccessDataFileTests {
+
+ private static final byte[] BYTES;
+
+ static {
+ BYTES = new byte[256];
+ for (int i = 0; i < BYTES.length; i++) {
+ BYTES[i] = (byte) i;
+ }
+ }
+
+ private File tempFile;
+
+ private RandomAccessDataFile file;
+
+ private InputStream inputStream;
+
+ @BeforeEach
+ void setup(@TempDir File tempDir) throws Exception {
+ this.tempFile = new File(tempDir, "tempFile");
+ FileOutputStream outputStream = new FileOutputStream(this.tempFile);
+ outputStream.write(BYTES);
+ outputStream.close();
+ this.file = new RandomAccessDataFile(this.tempFile);
+ this.inputStream = this.file.getInputStream();
+ }
+
+ @AfterEach
+ void cleanup() throws Exception {
+ this.inputStream.close();
+ this.file.close();
+ }
+
+ @Test
+ void fileNotNull() {
+ assertThatIllegalArgumentException().isThrownBy(() -> new RandomAccessDataFile(null))
+ .withMessageContaining("File must not be null");
+ }
+
+ @Test
+ void fileExists() {
+ File file = new File("/does/not/exist");
+ assertThatIllegalArgumentException().isThrownBy(() -> new RandomAccessDataFile(file))
+ .withMessageContaining(String.format("File %s must exist", file.getAbsolutePath()));
+ }
+
+ @Test
+ void readWithOffsetAndLengthShouldRead() throws Exception {
+ byte[] read = this.file.read(2, 3);
+ assertThat(read).isEqualTo(new byte[] { 2, 3, 4 });
+ }
+
+ @Test
+ void readWhenOffsetIsBeyondEOFShouldThrowException() {
+ assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> this.file.read(257, 0));
+ }
+
+ @Test
+ void readWhenOffsetIsBeyondEndOfSubsectionShouldThrowException() {
+ RandomAccessData subsection = this.file.getSubsection(0, 10);
+ assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> subsection.read(11, 0));
+ }
+
+ @Test
+ void readWhenOffsetPlusLengthGreaterThanEOFShouldThrowException() {
+ assertThatExceptionOfType(EOFException.class).isThrownBy(() -> this.file.read(256, 1));
+ }
+
+ @Test
+ void readWhenOffsetPlusLengthGreaterThanEndOfSubsectionShouldThrowException() {
+ RandomAccessData subsection = this.file.getSubsection(0, 10);
+ assertThatExceptionOfType(EOFException.class).isThrownBy(() -> subsection.read(10, 1));
+ }
+
+ @Test
+ void inputStreamRead() throws Exception {
+ for (int i = 0; i <= 255; i++) {
+ assertThat(this.inputStream.read()).isEqualTo(i);
+ }
+ }
+
+ @Test
+ void inputStreamReadNullBytes() {
+ assertThatNullPointerException().isThrownBy(() -> this.inputStream.read(null))
+ .withMessage("Bytes must not be null");
+ }
+
+ @Test
+ void inputStreamReadNullBytesWithOffset() {
+ assertThatNullPointerException().isThrownBy(() -> this.inputStream.read(null, 0, 1))
+ .withMessage("Bytes must not be null");
+ }
+
+ @Test
+ void inputStreamReadBytes() throws Exception {
+ byte[] b = new byte[256];
+ int amountRead = this.inputStream.read(b);
+ assertThat(b).isEqualTo(BYTES);
+ assertThat(amountRead).isEqualTo(256);
+ }
+
+ @Test
+ void inputStreamReadOffsetBytes() throws Exception {
+ byte[] b = new byte[7];
+ this.inputStream.skip(1);
+ int amountRead = this.inputStream.read(b, 2, 3);
+ assertThat(b).isEqualTo(new byte[] { 0, 0, 1, 2, 3, 0, 0 });
+ assertThat(amountRead).isEqualTo(3);
+ }
+
+ @Test
+ void inputStreamReadMoreBytesThanAvailable() throws Exception {
+ byte[] b = new byte[257];
+ int amountRead = this.inputStream.read(b);
+ assertThat(b).startsWith(BYTES);
+ assertThat(amountRead).isEqualTo(256);
+ }
+
+ @Test
+ void inputStreamReadPastEnd() throws Exception {
+ this.inputStream.skip(255);
+ assertThat(this.inputStream.read()).isEqualTo(0xFF);
+ assertThat(this.inputStream.read()).isEqualTo(-1);
+ assertThat(this.inputStream.read()).isEqualTo(-1);
+ }
+
+ @Test
+ void inputStreamReadZeroLength() throws Exception {
+ byte[] b = new byte[] { 0x0F };
+ int amountRead = this.inputStream.read(b, 0, 0);
+ assertThat(b).isEqualTo(new byte[] { 0x0F });
+ assertThat(amountRead).isZero();
+ assertThat(this.inputStream.read()).isZero();
+ }
+
+ @Test
+ void inputStreamSkip() throws Exception {
+ long amountSkipped = this.inputStream.skip(4);
+ assertThat(this.inputStream.read()).isEqualTo(4);
+ assertThat(amountSkipped).isEqualTo(4L);
+ }
+
+ @Test
+ void inputStreamSkipMoreThanAvailable() throws Exception {
+ long amountSkipped = this.inputStream.skip(257);
+ assertThat(this.inputStream.read()).isEqualTo(-1);
+ assertThat(amountSkipped).isEqualTo(256L);
+ }
+
+ @Test
+ void inputStreamSkipPastEnd() throws Exception {
+ this.inputStream.skip(256);
+ long amountSkipped = this.inputStream.skip(1);
+ assertThat(amountSkipped).isZero();
+ }
+
+ @Test
+ void inputStreamAvailable() throws Exception {
+ assertThat(this.inputStream.available()).isEqualTo(256);
+ this.inputStream.skip(56);
+ assertThat(this.inputStream.available()).isEqualTo(200);
+ this.inputStream.skip(200);
+ assertThat(this.inputStream.available()).isZero();
+ }
+
+ @Test
+ void subsectionNegativeOffset() {
+ assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> this.file.getSubsection(-1, 1));
+ }
+
+ @Test
+ void subsectionNegativeLength() {
+ assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> this.file.getSubsection(0, -1));
+ }
+
+ @Test
+ void subsectionZeroLength() throws Exception {
+ RandomAccessData subsection = this.file.getSubsection(0, 0);
+ assertThat(subsection.getInputStream().read()).isEqualTo(-1);
+ }
+
+ @Test
+ void subsectionTooBig() {
+ this.file.getSubsection(0, 256);
+ assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> this.file.getSubsection(0, 257));
+ }
+
+ @Test
+ void subsectionTooBigWithOffset() {
+ this.file.getSubsection(1, 255);
+ assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> this.file.getSubsection(1, 256));
+ }
+
+ @Test
+ void subsection() throws Exception {
+ RandomAccessData subsection = this.file.getSubsection(1, 1);
+ assertThat(subsection.getInputStream().read()).isOne();
+ }
+
+ @Test
+ void inputStreamReadPastSubsection() throws Exception {
+ RandomAccessData subsection = this.file.getSubsection(1, 2);
+ InputStream inputStream = subsection.getInputStream();
+ assertThat(inputStream.read()).isOne();
+ assertThat(inputStream.read()).isEqualTo(2);
+ assertThat(inputStream.read()).isEqualTo(-1);
+ }
+
+ @Test
+ void inputStreamReadBytesPastSubsection() throws Exception {
+ RandomAccessData subsection = this.file.getSubsection(1, 2);
+ InputStream inputStream = subsection.getInputStream();
+ byte[] b = new byte[3];
+ int amountRead = inputStream.read(b);
+ assertThat(b).isEqualTo(new byte[] { 1, 2, 0 });
+ assertThat(amountRead).isEqualTo(2);
+ }
+
+ @Test
+ void inputStreamSkipPastSubsection() throws Exception {
+ RandomAccessData subsection = this.file.getSubsection(1, 2);
+ InputStream inputStream = subsection.getInputStream();
+ assertThat(inputStream.skip(3)).isEqualTo(2L);
+ assertThat(inputStream.read()).isEqualTo(-1);
+ }
+
+ @Test
+ void inputStreamSkipNegative() throws Exception {
+ assertThat(this.inputStream.skip(-1)).isZero();
+ }
+
+ @Test
+ void getFile() {
+ assertThat(this.file.getFile()).isEqualTo(this.tempFile);
+ }
+
+ @Test
+ void concurrentReads() throws Exception {
+ ExecutorService executorService = Executors.newFixedThreadPool(20);
+ List> results = new ArrayList<>();
+ for (int i = 0; i < 100; i++) {
+ results.add(executorService.submit(() -> {
+ InputStream subsectionInputStream = RandomAccessDataFileTests.this.file.getSubsection(0, 256)
+ .getInputStream();
+ byte[] b = new byte[256];
+ subsectionInputStream.read(b);
+ return Arrays.equals(b, BYTES);
+ }));
+ }
+ for (Future future : results) {
+ assertThat(future.get()).isTrue();
+ }
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/AsciiBytesTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/AsciiBytesTests.java
new file mode 100644
index 0000000000..dd25050163
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/AsciiBytesTests.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jar;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+/**
+ * Tests for {@link AsciiBytes}.
+ *
+ * @author Phillip Webb
+ * @author Andy Wilkinson
+ */
+class AsciiBytesTests {
+
+ private static final char NO_SUFFIX = 0;
+
+ @Test
+ void createFromBytes() {
+ AsciiBytes bytes = new AsciiBytes(new byte[] { 65, 66 });
+ assertThat(bytes).hasToString("AB");
+ }
+
+ @Test
+ void createFromBytesWithOffset() {
+ AsciiBytes bytes = new AsciiBytes(new byte[] { 65, 66, 67, 68 }, 1, 2);
+ assertThat(bytes).hasToString("BC");
+ }
+
+ @Test
+ void createFromString() {
+ AsciiBytes bytes = new AsciiBytes("AB");
+ assertThat(bytes).hasToString("AB");
+ }
+
+ @Test
+ void length() {
+ AsciiBytes b1 = new AsciiBytes(new byte[] { 65, 66 });
+ AsciiBytes b2 = new AsciiBytes(new byte[] { 65, 66, 67, 68 }, 1, 2);
+ assertThat(b1.length()).isEqualTo(2);
+ assertThat(b2.length()).isEqualTo(2);
+ }
+
+ @Test
+ void startWith() {
+ AsciiBytes abc = new AsciiBytes(new byte[] { 65, 66, 67 });
+ AsciiBytes ab = new AsciiBytes(new byte[] { 65, 66 });
+ AsciiBytes bc = new AsciiBytes(new byte[] { 65, 66, 67 }, 1, 2);
+ AsciiBytes abcd = new AsciiBytes(new byte[] { 65, 66, 67, 68 });
+ assertThat(abc.startsWith(abc)).isTrue();
+ assertThat(abc.startsWith(ab)).isTrue();
+ assertThat(abc.startsWith(bc)).isFalse();
+ assertThat(abc.startsWith(abcd)).isFalse();
+ }
+
+ @Test
+ void endsWith() {
+ AsciiBytes abc = new AsciiBytes(new byte[] { 65, 66, 67 });
+ AsciiBytes bc = new AsciiBytes(new byte[] { 65, 66, 67 }, 1, 2);
+ AsciiBytes ab = new AsciiBytes(new byte[] { 65, 66 });
+ AsciiBytes aabc = new AsciiBytes(new byte[] { 65, 65, 66, 67 });
+ assertThat(abc.endsWith(abc)).isTrue();
+ assertThat(abc.endsWith(bc)).isTrue();
+ assertThat(abc.endsWith(ab)).isFalse();
+ assertThat(abc.endsWith(aabc)).isFalse();
+ }
+
+ @Test
+ void substringFromBeingIndex() {
+ AsciiBytes abcd = new AsciiBytes(new byte[] { 65, 66, 67, 68 });
+ assertThat(abcd.substring(0)).hasToString("ABCD");
+ assertThat(abcd.substring(1)).hasToString("BCD");
+ assertThat(abcd.substring(2)).hasToString("CD");
+ assertThat(abcd.substring(3)).hasToString("D");
+ assertThat(abcd.substring(4).toString()).isEmpty();
+ assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> abcd.substring(5));
+ }
+
+ @Test
+ void substring() {
+ AsciiBytes abcd = new AsciiBytes(new byte[] { 65, 66, 67, 68 });
+ assertThat(abcd.substring(0, 4)).hasToString("ABCD");
+ assertThat(abcd.substring(1, 3)).hasToString("BC");
+ assertThat(abcd.substring(3, 4)).hasToString("D");
+ assertThat(abcd.substring(3, 3).toString()).isEmpty();
+ assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> abcd.substring(3, 5));
+ }
+
+ @Test
+ void hashCodeAndEquals() {
+ AsciiBytes abcd = new AsciiBytes(new byte[] { 65, 66, 67, 68 });
+ AsciiBytes bc = new AsciiBytes(new byte[] { 66, 67 });
+ AsciiBytes bc_substring = new AsciiBytes(new byte[] { 65, 66, 67, 68 }).substring(1, 3);
+ AsciiBytes bc_string = new AsciiBytes("BC");
+ assertThat(bc).hasSameHashCodeAs(bc);
+ assertThat(bc).hasSameHashCodeAs(bc_substring);
+ assertThat(bc).hasSameHashCodeAs(bc_string);
+ assertThat(bc).isEqualTo(bc);
+ assertThat(bc).isEqualTo(bc_substring);
+ assertThat(bc).isEqualTo(bc_string);
+ assertThat(bc.hashCode()).isNotEqualTo(abcd.hashCode());
+ assertThat(bc).isNotEqualTo(abcd);
+ }
+
+ @Test
+ void hashCodeSameAsString() {
+ hashCodeSameAsString("abcABC123xyz!");
+ }
+
+ @Test
+ void hashCodeSameAsStringWithSpecial() {
+ hashCodeSameAsString("special/\u00EB.dat");
+ }
+
+ @Test
+ void hashCodeSameAsStringWithCyrillicCharacters() {
+ hashCodeSameAsString("\u0432\u0435\u0441\u043D\u0430");
+ }
+
+ @Test
+ void hashCodeSameAsStringWithEmoji() {
+ hashCodeSameAsString("\ud83d\udca9");
+ }
+
+ private void hashCodeSameAsString(String input) {
+ assertThat(new AsciiBytes(input)).hasSameHashCodeAs(input);
+ }
+
+ @Test
+ void matchesSameAsString() {
+ matchesSameAsString("abcABC123xyz!");
+ }
+
+ @Test
+ void matchesSameAsStringWithSpecial() {
+ matchesSameAsString("special/\u00EB.dat");
+ }
+
+ @Test
+ void matchesSameAsStringWithCyrillicCharacters() {
+ matchesSameAsString("\u0432\u0435\u0441\u043D\u0430");
+ }
+
+ @Test
+ void matchesDifferentLengths() {
+ assertThat(new AsciiBytes("abc").matches("ab", NO_SUFFIX)).isFalse();
+ assertThat(new AsciiBytes("abc").matches("abcd", NO_SUFFIX)).isFalse();
+ assertThat(new AsciiBytes("abc").matches("abc", NO_SUFFIX)).isTrue();
+ assertThat(new AsciiBytes("abc").matches("a", 'b')).isFalse();
+ assertThat(new AsciiBytes("abc").matches("abc", 'd')).isFalse();
+ assertThat(new AsciiBytes("abc").matches("ab", 'c')).isTrue();
+ }
+
+ @Test
+ void matchesSuffix() {
+ assertThat(new AsciiBytes("ab").matches("a", 'b')).isTrue();
+ }
+
+ @Test
+ void matchesSameAsStringWithEmoji() {
+ matchesSameAsString("\ud83d\udca9");
+ }
+
+ @Test
+ void hashCodeFromInstanceMatchesHashCodeFromString() {
+ String name = "fonts/宋体/simsun.ttf";
+ assertThat(new AsciiBytes(name).hashCode()).isEqualTo(AsciiBytes.hashCode(name));
+ }
+
+ @Test
+ void instanceCreatedFromCharSequenceMatchesSameCharSequence() {
+ String name = "fonts/宋体/simsun.ttf";
+ assertThat(new AsciiBytes(name).matches(name, NO_SUFFIX)).isTrue();
+ }
+
+ private void matchesSameAsString(String input) {
+ assertThat(new AsciiBytes(input).matches(input, NO_SUFFIX)).isTrue();
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/CentralDirectoryParserTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/CentralDirectoryParserTests.java
new file mode 100644
index 0000000000..4d15c21fe3
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/CentralDirectoryParserTests.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jar;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import org.springframework.boot.loader.TestJarCreator;
+import org.springframework.boot.loader.data.RandomAccessData;
+import org.springframework.boot.loader.data.RandomAccessDataFile;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link CentralDirectoryParser}.
+ *
+ * @author Phillip Webb
+ */
+class CentralDirectoryParserTests {
+
+ private File jarFile;
+
+ private RandomAccessDataFile jarData;
+
+ @BeforeEach
+ void setup(@TempDir File tempDir) throws Exception {
+ this.jarFile = new File(tempDir, "test.jar");
+ TestJarCreator.createTestJar(this.jarFile);
+ this.jarData = new RandomAccessDataFile(this.jarFile);
+ }
+
+ @AfterEach
+ void tearDown() throws IOException {
+ this.jarData.close();
+ }
+
+ @Test
+ void visitsInOrder() throws Exception {
+ MockCentralDirectoryVisitor visitor = new MockCentralDirectoryVisitor();
+ CentralDirectoryParser parser = new CentralDirectoryParser();
+ parser.addVisitor(visitor);
+ parser.parse(this.jarData, false);
+ List invocations = visitor.getInvocations();
+ assertThat(invocations).startsWith("visitStart").endsWith("visitEnd").contains("visitFileHeader");
+ }
+
+ @Test
+ void visitRecords() throws Exception {
+ Collector collector = new Collector();
+ CentralDirectoryParser parser = new CentralDirectoryParser();
+ parser.addVisitor(collector);
+ parser.parse(this.jarData, false);
+ Iterator headers = collector.getHeaders().iterator();
+ assertThat(headers.next().getName()).hasToString("META-INF/");
+ assertThat(headers.next().getName()).hasToString("META-INF/MANIFEST.MF");
+ assertThat(headers.next().getName()).hasToString("1.dat");
+ assertThat(headers.next().getName()).hasToString("2.dat");
+ assertThat(headers.next().getName()).hasToString("d/");
+ assertThat(headers.next().getName()).hasToString("d/9.dat");
+ assertThat(headers.next().getName()).hasToString("special/");
+ assertThat(headers.next().getName()).hasToString("special/\u00EB.dat");
+ assertThat(headers.next().getName()).hasToString("nested.jar");
+ assertThat(headers.next().getName()).hasToString("another-nested.jar");
+ assertThat(headers.next().getName()).hasToString("space nested.jar");
+ assertThat(headers.next().getName()).hasToString("multi-release.jar");
+ assertThat(headers.hasNext()).isFalse();
+ }
+
+ static class Collector implements CentralDirectoryVisitor {
+
+ private final List headers = new ArrayList<>();
+
+ @Override
+ public void visitStart(CentralDirectoryEndRecord endRecord, RandomAccessData centralDirectoryData) {
+ }
+
+ @Override
+ public void visitFileHeader(CentralDirectoryFileHeader fileHeader, long dataOffset) {
+ this.headers.add(fileHeader.clone());
+ }
+
+ @Override
+ public void visitEnd() {
+ }
+
+ List getHeaders() {
+ return this.headers;
+ }
+
+ }
+
+ static class MockCentralDirectoryVisitor implements CentralDirectoryVisitor {
+
+ private final List invocations = new ArrayList<>();
+
+ @Override
+ public void visitStart(CentralDirectoryEndRecord endRecord, RandomAccessData centralDirectoryData) {
+ this.invocations.add("visitStart");
+ }
+
+ @Override
+ public void visitFileHeader(CentralDirectoryFileHeader fileHeader, long dataOffset) {
+ this.invocations.add("visitFileHeader");
+ }
+
+ @Override
+ public void visitEnd() {
+ this.invocations.add("visitEnd");
+ }
+
+ List getInvocations() {
+ return this.invocations;
+ }
+
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/HandlerTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/HandlerTests.java
new file mode 100644
index 0000000000..1a64de6431
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/HandlerTests.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jar;
+
+import java.io.File;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.io.TempDir;
+
+import org.springframework.boot.loader.TestJarCreator;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link Handler}.
+ *
+ * @author Andy Wilkinson
+ */
+@ExtendWith(JarUrlProtocolHandler.class)
+class HandlerTests {
+
+ private final Handler handler = new Handler();
+
+ @Test
+ void parseUrlWithJarRootContextAndAbsoluteSpecThatUsesContext() throws MalformedURLException {
+ String spec = "/entry.txt";
+ URL context = createUrl("file:example.jar!/");
+ this.handler.parseURL(context, spec, 0, spec.length());
+ assertThat(context.toExternalForm()).isEqualTo("jar:file:example.jar!/entry.txt");
+ }
+
+ @Test
+ void parseUrlWithDirectoryEntryContextAndAbsoluteSpecThatUsesContext() throws MalformedURLException {
+ String spec = "/entry.txt";
+ URL context = createUrl("file:example.jar!/dir/");
+ this.handler.parseURL(context, spec, 0, spec.length());
+ assertThat(context.toExternalForm()).isEqualTo("jar:file:example.jar!/entry.txt");
+ }
+
+ @Test
+ void parseUrlWithJarRootContextAndRelativeSpecThatUsesContext() throws MalformedURLException {
+ String spec = "entry.txt";
+ URL context = createUrl("file:example.jar!/");
+ this.handler.parseURL(context, spec, 0, spec.length());
+ assertThat(context.toExternalForm()).isEqualTo("jar:file:example.jar!/entry.txt");
+ }
+
+ @Test
+ void parseUrlWithDirectoryEntryContextAndRelativeSpecThatUsesContext() throws MalformedURLException {
+ String spec = "entry.txt";
+ URL context = createUrl("file:example.jar!/dir/");
+ this.handler.parseURL(context, spec, 0, spec.length());
+ assertThat(context.toExternalForm()).isEqualTo("jar:file:example.jar!/dir/entry.txt");
+ }
+
+ @Test
+ void parseUrlWithFileEntryContextAndRelativeSpecThatUsesContext() throws MalformedURLException {
+ String spec = "entry.txt";
+ URL context = createUrl("file:example.jar!/dir/file");
+ this.handler.parseURL(context, spec, 0, spec.length());
+ assertThat(context.toExternalForm()).isEqualTo("jar:file:example.jar!/dir/entry.txt");
+ }
+
+ @Test
+ void parseUrlWithSpecThatIgnoresContext() throws MalformedURLException {
+ JarFile.registerUrlProtocolHandler();
+ String spec = "jar:file:/other.jar!/nested!/entry.txt";
+ URL context = createUrl("file:example.jar!/dir/file");
+ this.handler.parseURL(context, spec, 0, spec.length());
+ assertThat(context.toExternalForm()).isEqualTo("jar:jar:file:/other.jar!/nested!/entry.txt");
+ }
+
+ @Test
+ void sameFileReturnsFalseForUrlsWithDifferentProtocols() throws MalformedURLException {
+ assertThat(this.handler.sameFile(new URL("jar:file:foo.jar!/content.txt"), new URL("file:/foo.jar"))).isFalse();
+ }
+
+ @Test
+ void sameFileReturnsFalseForDifferentFileInSameJar() throws MalformedURLException {
+ assertThat(this.handler.sameFile(new URL("jar:file:foo.jar!/the/path/to/the/first/content.txt"),
+ new URL("jar:file:/foo.jar!/content.txt")))
+ .isFalse();
+ }
+
+ @Test
+ void sameFileReturnsFalseForSameFileInDifferentJars() throws MalformedURLException {
+ assertThat(this.handler.sameFile(new URL("jar:file:/the/path/to/the/first.jar!/content.txt"),
+ new URL("jar:file:/second.jar!/content.txt")))
+ .isFalse();
+ }
+
+ @Test
+ void sameFileReturnsTrueForSameFileInSameJar() throws MalformedURLException {
+ assertThat(this.handler.sameFile(new URL("jar:file:/the/path/to/the/first.jar!/content.txt"),
+ new URL("jar:file:/the/path/to/the/first.jar!/content.txt")))
+ .isTrue();
+ }
+
+ @Test
+ void sameFileReturnsTrueForUrlsThatReferenceSameFileViaNestedArchiveAndFromRootOfJar()
+ throws MalformedURLException {
+ assertThat(this.handler.sameFile(new URL("jar:file:/test.jar!/BOOT-INF/classes!/foo.txt"),
+ new URL("jar:file:/test.jar!/BOOT-INF/classes/foo.txt")))
+ .isTrue();
+ }
+
+ @Test
+ void hashCodesAreEqualForUrlsThatReferenceSameFileViaNestedArchiveAndFromRootOfJar() throws MalformedURLException {
+ assertThat(this.handler.hashCode(new URL("jar:file:/test.jar!/BOOT-INF/classes!/foo.txt")))
+ .isEqualTo(this.handler.hashCode(new URL("jar:file:/test.jar!/BOOT-INF/classes/foo.txt")));
+ }
+
+ @Test
+ void urlWithSpecReferencingParentDirectory() throws MalformedURLException {
+ assertStandardAndCustomHandlerUrlsAreEqual("file:/test.jar!/BOOT-INF/classes!/xsd/directoryA/a.xsd",
+ "../directoryB/c/d/e.xsd");
+ }
+
+ @Test
+ void urlWithSpecReferencingAncestorDirectoryOutsideJarStopsAtJarRoot() throws MalformedURLException {
+ assertStandardAndCustomHandlerUrlsAreEqual("file:/test.jar!/BOOT-INF/classes!/xsd/directoryA/a.xsd",
+ "../../../../../../directoryB/b.xsd");
+ }
+
+ @Test
+ void urlWithSpecReferencingCurrentDirectory() throws MalformedURLException {
+ assertStandardAndCustomHandlerUrlsAreEqual("file:/test.jar!/BOOT-INF/classes!/xsd/directoryA/a.xsd",
+ "./directoryB/c/d/e.xsd");
+ }
+
+ @Test
+ void urlWithRef() throws MalformedURLException {
+ assertStandardAndCustomHandlerUrlsAreEqual("file:/test.jar!/BOOT-INF/classes", "!/foo.txt#alpha");
+ }
+
+ @Test
+ void urlWithQuery() throws MalformedURLException {
+ assertStandardAndCustomHandlerUrlsAreEqual("file:/test.jar!/BOOT-INF/classes", "!/foo.txt?alpha");
+ }
+
+ @Test
+ void fallbackToJdksJarUrlStreamHandler(@TempDir File tempDir) throws Exception {
+ File testJar = new File(tempDir, "test.jar");
+ TestJarCreator.createTestJar(testJar);
+ URLConnection connection = new URL(null, "jar:" + testJar.toURI().toURL() + "!/nested.jar!/", this.handler)
+ .openConnection();
+ assertThat(connection).isInstanceOf(JarURLConnection.class);
+ ((JarURLConnection) connection).getJarFile().close();
+ URLConnection jdkConnection = new URL(null, "jar:file:" + testJar.toURI().toURL() + "!/nested.jar!/",
+ this.handler)
+ .openConnection();
+ assertThat(jdkConnection).isNotInstanceOf(JarURLConnection.class);
+ assertThat(jdkConnection.getClass().getName()).endsWith(".JarURLConnection");
+ }
+
+ @Test
+ void whenJarHasAPlusInItsPathConnectionJarFileMatchesOriginalJarFile(@TempDir File tempDir) throws Exception {
+ File testJar = new File(tempDir, "t+e+s+t.jar");
+ TestJarCreator.createTestJar(testJar);
+ URL url = new URL(null, "jar:" + testJar.toURI().toURL() + "!/nested.jar!/3.dat", this.handler);
+ JarURLConnection connection = (JarURLConnection) url.openConnection();
+ try (JarFile jarFile = JarFileWrapper.unwrap(connection.getJarFile())) {
+ assertThat(jarFile.getRootJarFile().getFile()).isEqualTo(testJar);
+ }
+ }
+
+ @Test
+ void whenJarHasASpaceInItsPathConnectionJarFileMatchesOriginalJarFile(@TempDir File tempDir) throws Exception {
+ File testJar = new File(tempDir, "t e s t.jar");
+ TestJarCreator.createTestJar(testJar);
+ URL url = new URL(null, "jar:" + testJar.toURI().toURL() + "!/nested.jar!/3.dat", this.handler);
+ JarURLConnection connection = (JarURLConnection) url.openConnection();
+ try (JarFile jarFile = JarFileWrapper.unwrap(connection.getJarFile())) {
+ assertThat(jarFile.getRootJarFile().getFile()).isEqualTo(testJar);
+ }
+ }
+
+ private void assertStandardAndCustomHandlerUrlsAreEqual(String context, String spec) throws MalformedURLException {
+ URL standardUrl = new URL(new URL("jar:" + context), spec);
+ URL customHandlerUrl = new URL(new URL("jar", null, -1, context, this.handler), spec);
+ assertThat(customHandlerUrl).hasToString(standardUrl.toString());
+ assertThat(customHandlerUrl.getFile()).isEqualTo(standardUrl.getFile());
+ assertThat(customHandlerUrl.getPath()).isEqualTo(standardUrl.getPath());
+ assertThat(customHandlerUrl.getQuery()).isEqualTo(standardUrl.getQuery());
+ assertThat(customHandlerUrl.getRef()).isEqualTo(standardUrl.getRef());
+ }
+
+ private URL createUrl(String file) throws MalformedURLException {
+ return new URL("jar", null, -1, file, this.handler);
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/JarFileTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/JarFileTests.java
new file mode 100644
index 0000000000..b37a99183a
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/JarFileTests.java
@@ -0,0 +1,736 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jar;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FilePermission;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.attribute.FileTime;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.jar.JarEntry;
+import java.util.jar.JarInputStream;
+import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
+import java.util.stream.Stream;
+import java.util.zip.CRC32;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.io.TempDir;
+
+import org.springframework.boot.loader.TestJarCreator;
+import org.springframework.boot.loader.data.RandomAccessDataFile;
+import org.springframework.util.FileCopyUtils;
+import org.springframework.util.StopWatch;
+import org.springframework.util.StreamUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.Assertions.assertThatIOException;
+import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
+import static org.mockito.BDDMockito.then;
+import static org.mockito.Mockito.spy;
+
+/**
+ * Tests for {@link JarFile}.
+ *
+ * @author Phillip Webb
+ * @author Martin Lau
+ * @author Andy Wilkinson
+ * @author Madhura Bhave
+ */
+@ExtendWith(JarUrlProtocolHandler.class)
+class JarFileTests {
+
+ private static final String PROTOCOL_HANDLER = "java.protocol.handler.pkgs";
+
+ private static final String HANDLERS_PACKAGE = "org.springframework.boot.loader";
+
+ @TempDir
+ File tempDir;
+
+ private File rootJarFile;
+
+ private JarFile jarFile;
+
+ @BeforeEach
+ void setup() throws Exception {
+ this.rootJarFile = new File(this.tempDir, "root.jar");
+ TestJarCreator.createTestJar(this.rootJarFile);
+ this.jarFile = new JarFile(this.rootJarFile);
+ }
+
+ @AfterEach
+ void tearDown() throws Exception {
+ this.jarFile.close();
+ }
+
+ @Test
+ void jdkJarFile() throws Exception {
+ // Sanity checks to see how the default jar file operates
+ java.util.jar.JarFile jarFile = new java.util.jar.JarFile(this.rootJarFile);
+ assertThat(jarFile.getComment()).isEqualTo("outer");
+ Enumeration entries = jarFile.entries();
+ assertThat(entries.nextElement().getName()).isEqualTo("META-INF/");
+ assertThat(entries.nextElement().getName()).isEqualTo("META-INF/MANIFEST.MF");
+ assertThat(entries.nextElement().getName()).isEqualTo("1.dat");
+ assertThat(entries.nextElement().getName()).isEqualTo("2.dat");
+ assertThat(entries.nextElement().getName()).isEqualTo("d/");
+ assertThat(entries.nextElement().getName()).isEqualTo("d/9.dat");
+ assertThat(entries.nextElement().getName()).isEqualTo("special/");
+ assertThat(entries.nextElement().getName()).isEqualTo("special/\u00EB.dat");
+ assertThat(entries.nextElement().getName()).isEqualTo("nested.jar");
+ assertThat(entries.nextElement().getName()).isEqualTo("another-nested.jar");
+ assertThat(entries.nextElement().getName()).isEqualTo("space nested.jar");
+ assertThat(entries.nextElement().getName()).isEqualTo("multi-release.jar");
+ assertThat(entries.hasMoreElements()).isFalse();
+ URL jarUrl = new URL("jar:" + this.rootJarFile.toURI() + "!/");
+ URLClassLoader urlClassLoader = new URLClassLoader(new URL[] { jarUrl });
+ assertThat(urlClassLoader.getResource("special/\u00EB.dat")).isNotNull();
+ assertThat(urlClassLoader.getResource("d/9.dat")).isNotNull();
+ urlClassLoader.close();
+ jarFile.close();
+ }
+
+ @Test
+ void createFromFile() throws Exception {
+ JarFile jarFile = new JarFile(this.rootJarFile);
+ assertThat(jarFile.getName()).isNotNull();
+ jarFile.close();
+ }
+
+ @Test
+ void getManifest() throws Exception {
+ assertThat(this.jarFile.getManifest().getMainAttributes().getValue("Built-By")).isEqualTo("j1");
+ }
+
+ @Test
+ void getManifestEntry() throws Exception {
+ ZipEntry entry = this.jarFile.getJarEntry("META-INF/MANIFEST.MF");
+ Manifest manifest = new Manifest(this.jarFile.getInputStream(entry));
+ assertThat(manifest.getMainAttributes().getValue("Built-By")).isEqualTo("j1");
+ }
+
+ @Test
+ void getEntries() {
+ Enumeration entries = this.jarFile.entries();
+ assertThat(entries.nextElement().getName()).isEqualTo("META-INF/");
+ assertThat(entries.nextElement().getName()).isEqualTo("META-INF/MANIFEST.MF");
+ assertThat(entries.nextElement().getName()).isEqualTo("1.dat");
+ assertThat(entries.nextElement().getName()).isEqualTo("2.dat");
+ assertThat(entries.nextElement().getName()).isEqualTo("d/");
+ assertThat(entries.nextElement().getName()).isEqualTo("d/9.dat");
+ assertThat(entries.nextElement().getName()).isEqualTo("special/");
+ assertThat(entries.nextElement().getName()).isEqualTo("special/\u00EB.dat");
+ assertThat(entries.nextElement().getName()).isEqualTo("nested.jar");
+ assertThat(entries.nextElement().getName()).isEqualTo("another-nested.jar");
+ assertThat(entries.nextElement().getName()).isEqualTo("space nested.jar");
+ assertThat(entries.nextElement().getName()).isEqualTo("multi-release.jar");
+ assertThat(entries.hasMoreElements()).isFalse();
+ }
+
+ @Test
+ void getSpecialResourceViaClassLoader() throws Exception {
+ URLClassLoader urlClassLoader = new URLClassLoader(new URL[] { this.jarFile.getUrl() });
+ assertThat(urlClassLoader.getResource("special/\u00EB.dat")).isNotNull();
+ urlClassLoader.close();
+ }
+
+ @Test
+ void getJarEntry() {
+ java.util.jar.JarEntry entry = this.jarFile.getJarEntry("1.dat");
+ assertThat(entry).isNotNull();
+ assertThat(entry.getName()).isEqualTo("1.dat");
+ }
+
+ @Test
+ void getJarEntryWhenClosed() throws Exception {
+ this.jarFile.close();
+ assertThatZipFileClosedIsThrownBy(() -> this.jarFile.getJarEntry("1.dat"));
+ }
+
+ @Test
+ void getInputStream() throws Exception {
+ InputStream inputStream = this.jarFile.getInputStream(this.jarFile.getEntry("1.dat"));
+ assertThat(inputStream.available()).isOne();
+ assertThat(inputStream.read()).isOne();
+ assertThat(inputStream.available()).isZero();
+ assertThat(inputStream.read()).isEqualTo(-1);
+ }
+
+ @Test
+ void getInputStreamWhenClosed() throws Exception {
+ ZipEntry entry = this.jarFile.getEntry("1.dat");
+ this.jarFile.close();
+ assertThatZipFileClosedIsThrownBy(() -> this.jarFile.getInputStream(entry));
+ }
+
+ @Test
+ void getComment() {
+ assertThat(this.jarFile.getComment()).isEqualTo("outer");
+ }
+
+ @Test
+ void getCommentWhenClosed() throws Exception {
+ this.jarFile.close();
+ assertThatZipFileClosedIsThrownBy(() -> this.jarFile.getComment());
+ }
+
+ @Test
+ void getName() {
+ assertThat(this.jarFile.getName()).isEqualTo(this.rootJarFile.getPath());
+ }
+
+ @Test
+ void size() throws Exception {
+ try (ZipFile zip = new ZipFile(this.rootJarFile)) {
+ assertThat(this.jarFile).hasSize(zip.size());
+ }
+ }
+
+ @Test
+ void sizeWhenClosed() throws Exception {
+ this.jarFile.close();
+ assertThatZipFileClosedIsThrownBy(() -> this.jarFile.size());
+ }
+
+ @Test
+ void getEntryTime() throws Exception {
+ java.util.jar.JarFile jdkJarFile = new java.util.jar.JarFile(this.rootJarFile);
+ assertThat(this.jarFile.getEntry("META-INF/MANIFEST.MF").getTime())
+ .isEqualTo(jdkJarFile.getEntry("META-INF/MANIFEST.MF").getTime());
+ jdkJarFile.close();
+ }
+
+ @Test
+ void close() throws Exception {
+ RandomAccessDataFile randomAccessDataFile = spy(new RandomAccessDataFile(this.rootJarFile));
+ JarFile jarFile = new JarFile(randomAccessDataFile);
+ jarFile.close();
+ then(randomAccessDataFile).should().close();
+ }
+
+ @Test
+ void getUrl() throws Exception {
+ URL url = this.jarFile.getUrl();
+ assertThat(url).hasToString("jar:" + this.rootJarFile.toURI() + "!/");
+ JarURLConnection jarURLConnection = (JarURLConnection) url.openConnection();
+ assertThat(JarFileWrapper.unwrap(jarURLConnection.getJarFile())).isSameAs(this.jarFile);
+ assertThat(jarURLConnection.getJarEntry()).isNull();
+ assertThat(jarURLConnection.getContentLength()).isGreaterThan(1);
+ assertThat(JarFileWrapper.unwrap((java.util.jar.JarFile) jarURLConnection.getContent())).isSameAs(this.jarFile);
+ assertThat(jarURLConnection.getContentType()).isEqualTo("x-java/jar");
+ assertThat(jarURLConnection.getJarFileURL().toURI()).isEqualTo(this.rootJarFile.toURI());
+ }
+
+ @Test
+ void createEntryUrl() throws Exception {
+ URL url = new URL(this.jarFile.getUrl(), "1.dat");
+ assertThat(url).hasToString("jar:" + this.rootJarFile.toURI() + "!/1.dat");
+ JarURLConnection jarURLConnection = (JarURLConnection) url.openConnection();
+ assertThat(JarFileWrapper.unwrap(jarURLConnection.getJarFile())).isSameAs(this.jarFile);
+ assertThat(jarURLConnection.getJarEntry()).isSameAs(this.jarFile.getJarEntry("1.dat"));
+ assertThat(jarURLConnection.getContentLength()).isOne();
+ assertThat(jarURLConnection.getContent()).isInstanceOf(InputStream.class);
+ assertThat(jarURLConnection.getContentType()).isEqualTo("content/unknown");
+ assertThat(jarURLConnection.getPermission()).isInstanceOf(FilePermission.class);
+ FilePermission permission = (FilePermission) jarURLConnection.getPermission();
+ assertThat(permission.getActions()).isEqualTo("read");
+ assertThat(permission.getName()).isEqualTo(this.rootJarFile.getPath());
+ }
+
+ @Test
+ void getMissingEntryUrl() throws Exception {
+ URL url = new URL(this.jarFile.getUrl(), "missing.dat");
+ assertThat(url).hasToString("jar:" + this.rootJarFile.toURI() + "!/missing.dat");
+ assertThatExceptionOfType(FileNotFoundException.class)
+ .isThrownBy(((JarURLConnection) url.openConnection())::getJarEntry);
+ }
+
+ @Test
+ void getUrlStream() throws Exception {
+ URL url = this.jarFile.getUrl();
+ url.openConnection();
+ assertThatIOException().isThrownBy(url::openStream);
+ }
+
+ @Test
+ void getEntryUrlStream() throws Exception {
+ URL url = new URL(this.jarFile.getUrl(), "1.dat");
+ url.openConnection();
+ try (InputStream stream = url.openStream()) {
+ assertThat(stream.read()).isOne();
+ assertThat(stream.read()).isEqualTo(-1);
+ }
+ }
+
+ @Test
+ void getNestedJarFile() throws Exception {
+ try (JarFile nestedJarFile = this.jarFile.getNestedJarFile(this.jarFile.getEntry("nested.jar"))) {
+ assertThat(nestedJarFile.getComment()).isEqualTo("nested");
+ Enumeration entries = nestedJarFile.entries();
+ assertThat(entries.nextElement().getName()).isEqualTo("META-INF/");
+ assertThat(entries.nextElement().getName()).isEqualTo("META-INF/MANIFEST.MF");
+ assertThat(entries.nextElement().getName()).isEqualTo("3.dat");
+ assertThat(entries.nextElement().getName()).isEqualTo("4.dat");
+ assertThat(entries.nextElement().getName()).isEqualTo("\u00E4.dat");
+ assertThat(entries.hasMoreElements()).isFalse();
+
+ InputStream inputStream = nestedJarFile.getInputStream(nestedJarFile.getEntry("3.dat"));
+ assertThat(inputStream.read()).isEqualTo(3);
+ assertThat(inputStream.read()).isEqualTo(-1);
+
+ URL url = nestedJarFile.getUrl();
+ assertThat(url).hasToString("jar:" + this.rootJarFile.toURI() + "!/nested.jar!/");
+ JarURLConnection conn = (JarURLConnection) url.openConnection();
+ assertThat(JarFileWrapper.unwrap(conn.getJarFile())).isSameAs(nestedJarFile);
+ assertThat(conn.getJarFileURL()).hasToString("jar:" + this.rootJarFile.toURI() + "!/nested.jar");
+ assertThat(conn.getInputStream()).isNotNull();
+ JarInputStream jarInputStream = new JarInputStream(conn.getInputStream());
+ assertThat(jarInputStream.getNextJarEntry().getName()).isEqualTo("3.dat");
+ assertThat(jarInputStream.getNextJarEntry().getName()).isEqualTo("4.dat");
+ assertThat(jarInputStream.getNextJarEntry().getName()).isEqualTo("\u00E4.dat");
+ jarInputStream.close();
+ assertThat(conn.getPermission()).isInstanceOf(FilePermission.class);
+ FilePermission permission = (FilePermission) conn.getPermission();
+ assertThat(permission.getActions()).isEqualTo("read");
+ assertThat(permission.getName()).isEqualTo(this.rootJarFile.getPath());
+ }
+ }
+
+ @Test
+ void getNestedJarDirectory() throws Exception {
+ try (JarFile nestedJarFile = this.jarFile.getNestedJarFile(this.jarFile.getEntry("d/"))) {
+ Enumeration entries = nestedJarFile.entries();
+ assertThat(entries.nextElement().getName()).isEqualTo("9.dat");
+ assertThat(entries.hasMoreElements()).isFalse();
+
+ try (InputStream inputStream = nestedJarFile.getInputStream(nestedJarFile.getEntry("9.dat"))) {
+ assertThat(inputStream.read()).isEqualTo(9);
+ assertThat(inputStream.read()).isEqualTo(-1);
+ }
+
+ URL url = nestedJarFile.getUrl();
+ assertThat(url).hasToString("jar:" + this.rootJarFile.toURI() + "!/d!/");
+ JarURLConnection connection = (JarURLConnection) url.openConnection();
+ assertThat(JarFileWrapper.unwrap(connection.getJarFile())).isSameAs(nestedJarFile);
+ }
+ }
+
+ @Test
+ void getNestedJarEntryUrl() throws Exception {
+ try (JarFile nestedJarFile = this.jarFile.getNestedJarFile(this.jarFile.getEntry("nested.jar"))) {
+ URL url = nestedJarFile.getJarEntry("3.dat").getUrl();
+ assertThat(url).hasToString("jar:" + this.rootJarFile.toURI() + "!/nested.jar!/3.dat");
+ try (InputStream inputStream = url.openStream()) {
+ assertThat(inputStream).isNotNull();
+ assertThat(inputStream.read()).isEqualTo(3);
+ }
+ }
+ }
+
+ @Test
+ void createUrlFromString() throws Exception {
+ String spec = "jar:" + this.rootJarFile.toURI() + "!/nested.jar!/3.dat";
+ URL url = new URL(spec);
+ assertThat(url).hasToString(spec);
+ JarURLConnection connection = (JarURLConnection) url.openConnection();
+ try (InputStream inputStream = connection.getInputStream()) {
+ assertThat(inputStream).isNotNull();
+ assertThat(inputStream.read()).isEqualTo(3);
+ assertThat(connection.getURL()).hasToString(spec);
+ assertThat(connection.getJarFileURL()).hasToString("jar:" + this.rootJarFile.toURI() + "!/nested.jar");
+ assertThat(connection.getEntryName()).isEqualTo("3.dat");
+ connection.getJarFile().close();
+ }
+ }
+
+ @Test
+ void createNonNestedUrlFromString() throws Exception {
+ nonNestedJarFileFromString("jar:" + this.rootJarFile.toURI() + "!/2.dat");
+ }
+
+ @Test
+ void createNonNestedUrlFromPathString() throws Exception {
+ nonNestedJarFileFromString("jar:" + this.rootJarFile.toPath().toUri() + "!/2.dat");
+ }
+
+ private void nonNestedJarFileFromString(String spec) throws Exception {
+ JarFile.registerUrlProtocolHandler();
+ URL url = new URL(spec);
+ assertThat(url).hasToString(spec);
+ JarURLConnection connection = (JarURLConnection) url.openConnection();
+ try (InputStream inputStream = connection.getInputStream()) {
+ assertThat(inputStream).isNotNull();
+ assertThat(inputStream.read()).isEqualTo(2);
+ assertThat(connection.getURL()).hasToString(spec);
+ assertThat(connection.getJarFileURL().toURI()).isEqualTo(this.rootJarFile.toURI());
+ assertThat(connection.getEntryName()).isEqualTo("2.dat");
+ }
+ connection.getJarFile().close();
+ }
+
+ @Test
+ void getDirectoryInputStream() throws Exception {
+ InputStream inputStream = this.jarFile.getInputStream(this.jarFile.getEntry("d/"));
+ assertThat(inputStream).isNotNull();
+ assertThat(inputStream.read()).isEqualTo(-1);
+ }
+
+ @Test
+ void getDirectoryInputStreamWithoutSlash() throws Exception {
+ InputStream inputStream = this.jarFile.getInputStream(this.jarFile.getEntry("d"));
+ assertThat(inputStream).isNotNull();
+ assertThat(inputStream.read()).isEqualTo(-1);
+ }
+
+ @Test
+ void sensibleToString() throws Exception {
+ assertThat(this.jarFile).hasToString(this.rootJarFile.getPath());
+ try (JarFile nested = this.jarFile.getNestedJarFile(this.jarFile.getEntry("nested.jar"))) {
+ assertThat(nested).hasToString(this.rootJarFile.getPath() + "!/nested.jar");
+ }
+ }
+
+ @Test
+ void verifySignedJar() throws Exception {
+ File signedJarFile = getSignedJarFile();
+ assertThat(signedJarFile).exists();
+ try (java.util.jar.JarFile expected = new java.util.jar.JarFile(signedJarFile)) {
+ try (JarFile actual = new JarFile(signedJarFile)) {
+ StopWatch stopWatch = new StopWatch();
+ Enumeration actualEntries = actual.entries();
+ while (actualEntries.hasMoreElements()) {
+ JarEntry actualEntry = actualEntries.nextElement();
+ java.util.jar.JarEntry expectedEntry = expected.getJarEntry(actualEntry.getName());
+ StreamUtils.drain(expected.getInputStream(expectedEntry));
+ if (!actualEntry.getName().equals("META-INF/MANIFEST.MF")) {
+ assertThat(actualEntry.getCertificates()).as(actualEntry.getName())
+ .isEqualTo(expectedEntry.getCertificates());
+ assertThat(actualEntry.getCodeSigners()).as(actualEntry.getName())
+ .isEqualTo(expectedEntry.getCodeSigners());
+ }
+ }
+ assertThat(stopWatch.getTotalTimeSeconds()).isLessThan(3.0);
+ }
+ }
+ }
+
+ private File getSignedJarFile() {
+ String[] entries = System.getProperty("java.class.path").split(System.getProperty("path.separator"));
+ for (String entry : entries) {
+ if (entry.contains("bcprov")) {
+ return new File(entry);
+ }
+ }
+ return null;
+ }
+
+ @Test
+ void jarFileWithScriptAtTheStart() throws Exception {
+ File file = new File(this.tempDir, "test.jar");
+ InputStream sourceJarContent = new FileInputStream(this.rootJarFile);
+ FileOutputStream outputStream = new FileOutputStream(file);
+ StreamUtils.copy("#/bin/bash", Charset.defaultCharset(), outputStream);
+ FileCopyUtils.copy(sourceJarContent, outputStream);
+ this.rootJarFile = file;
+ this.jarFile.close();
+ this.jarFile = new JarFile(file);
+ // Call some other tests to verify
+ getEntries();
+ getNestedJarFile();
+ }
+
+ @Test
+ void cannotLoadMissingJar() throws Exception {
+ // relates to gh-1070
+ try (JarFile nestedJarFile = this.jarFile.getNestedJarFile(this.jarFile.getEntry("nested.jar"))) {
+ URL nestedUrl = nestedJarFile.getUrl();
+ URL url = new URL(nestedUrl, nestedJarFile.getUrl() + "missing.jar!/3.dat");
+ assertThatExceptionOfType(FileNotFoundException.class).isThrownBy(url.openConnection()::getInputStream);
+ }
+ }
+
+ @Test
+ void registerUrlProtocolHandlerWithNoExistingRegistration() {
+ String original = System.getProperty(PROTOCOL_HANDLER);
+ try {
+ System.clearProperty(PROTOCOL_HANDLER);
+ JarFile.registerUrlProtocolHandler();
+ String protocolHandler = System.getProperty(PROTOCOL_HANDLER);
+ assertThat(protocolHandler).isEqualTo(HANDLERS_PACKAGE);
+ }
+ finally {
+ if (original == null) {
+ System.clearProperty(PROTOCOL_HANDLER);
+ }
+ else {
+ System.setProperty(PROTOCOL_HANDLER, original);
+ }
+ }
+ }
+
+ @Test
+ void registerUrlProtocolHandlerAddsToExistingRegistration() {
+ String original = System.getProperty(PROTOCOL_HANDLER);
+ try {
+ System.setProperty(PROTOCOL_HANDLER, "com.example");
+ JarFile.registerUrlProtocolHandler();
+ String protocolHandler = System.getProperty(PROTOCOL_HANDLER);
+ assertThat(protocolHandler).isEqualTo("com.example|" + HANDLERS_PACKAGE);
+ }
+ finally {
+ if (original == null) {
+ System.clearProperty(PROTOCOL_HANDLER);
+ }
+ else {
+ System.setProperty(PROTOCOL_HANDLER, original);
+ }
+ }
+ }
+
+ @Test
+ void jarFileCanBeDeletedOnceItHasBeenClosed() throws Exception {
+ File jar = new File(this.tempDir, "test.jar");
+ TestJarCreator.createTestJar(jar);
+ JarFile jf = new JarFile(jar);
+ jf.close();
+ assertThat(jar.delete()).isTrue();
+ }
+
+ @Test
+ void createUrlFromStringWithContextWhenNotFound() throws Exception {
+ // gh-12483
+ JarURLConnection.setUseFastExceptions(true);
+ try {
+ try (JarFile nested = this.jarFile.getNestedJarFile(this.jarFile.getEntry("nested.jar"))) {
+ URL context = nested.getUrl();
+ new URL(context, "jar:" + this.rootJarFile.toURI() + "!/nested.jar!/3.dat").openConnection()
+ .getInputStream()
+ .close();
+ assertThatExceptionOfType(FileNotFoundException.class)
+ .isThrownBy(new URL(context, "jar:" + this.rootJarFile.toURI() + "!/no.dat")
+ .openConnection()::getInputStream);
+ }
+ }
+ finally {
+ JarURLConnection.setUseFastExceptions(false);
+ }
+ }
+
+ @Test
+ void multiReleaseEntry() throws Exception {
+ try (JarFile multiRelease = this.jarFile.getNestedJarFile(this.jarFile.getEntry("multi-release.jar"))) {
+ ZipEntry entry = multiRelease.getEntry("multi-release.dat");
+ assertThat(entry.getName()).isEqualTo("multi-release.dat");
+ InputStream inputStream = multiRelease.getInputStream(entry);
+ assertThat(inputStream.available()).isOne();
+ assertThat(inputStream.read()).isEqualTo(Runtime.version().feature());
+ }
+ }
+
+ @Test
+ void zip64JarThatExceedsZipEntryLimitCanBeRead() throws Exception {
+ File zip64Jar = new File(this.tempDir, "zip64.jar");
+ FileCopyUtils.copy(zip64Jar(), zip64Jar);
+ try (JarFile zip64JarFile = new JarFile(zip64Jar)) {
+ List entries = Collections.list(zip64JarFile.entries());
+ assertThat(entries).hasSize(65537);
+ for (int i = 0; i < entries.size(); i++) {
+ JarEntry entry = entries.get(i);
+ InputStream entryInput = zip64JarFile.getInputStream(entry);
+ assertThat(entryInput).hasContent("Entry " + (i + 1));
+ }
+ }
+ }
+
+ @Test
+ void zip64JarThatExceedsZipSizeLimitCanBeRead() throws Exception {
+ Assumptions.assumeTrue(this.tempDir.getFreeSpace() > 6 * 1024 * 1024 * 1024, "Insufficient disk space");
+ File zip64Jar = new File(this.tempDir, "zip64.jar");
+ File entry = new File(this.tempDir, "entry.dat");
+ CRC32 crc32 = new CRC32();
+ try (FileOutputStream entryOut = new FileOutputStream(entry)) {
+ byte[] data = new byte[1024 * 1024];
+ new Random().nextBytes(data);
+ for (int i = 0; i < 1024; i++) {
+ entryOut.write(data);
+ crc32.update(data);
+ }
+ }
+ try (JarOutputStream jarOutput = new JarOutputStream(new FileOutputStream(zip64Jar))) {
+ for (int i = 0; i < 6; i++) {
+ JarEntry storedEntry = new JarEntry("huge-" + i);
+ storedEntry.setSize(entry.length());
+ storedEntry.setCompressedSize(entry.length());
+ storedEntry.setCrc(crc32.getValue());
+ storedEntry.setMethod(ZipEntry.STORED);
+ jarOutput.putNextEntry(storedEntry);
+ try (FileInputStream entryIn = new FileInputStream(entry)) {
+ StreamUtils.copy(entryIn, jarOutput);
+ }
+ jarOutput.closeEntry();
+ }
+ }
+ try (JarFile zip64JarFile = new JarFile(zip64Jar)) {
+ assertThat(Collections.list(zip64JarFile.entries())).hasSize(6);
+ }
+ }
+
+ @Test
+ void nestedZip64JarCanBeRead() throws Exception {
+ File outer = new File(this.tempDir, "outer.jar");
+ try (JarOutputStream jarOutput = new JarOutputStream(new FileOutputStream(outer))) {
+ JarEntry nestedEntry = new JarEntry("nested-zip64.jar");
+ byte[] contents = zip64Jar();
+ nestedEntry.setSize(contents.length);
+ nestedEntry.setCompressedSize(contents.length);
+ CRC32 crc32 = new CRC32();
+ crc32.update(contents);
+ nestedEntry.setCrc(crc32.getValue());
+ nestedEntry.setMethod(ZipEntry.STORED);
+ jarOutput.putNextEntry(nestedEntry);
+ jarOutput.write(contents);
+ jarOutput.closeEntry();
+ }
+ try (JarFile outerJarFile = new JarFile(outer)) {
+ try (JarFile nestedZip64JarFile = outerJarFile
+ .getNestedJarFile(outerJarFile.getJarEntry("nested-zip64.jar"))) {
+ List entries = Collections.list(nestedZip64JarFile.entries());
+ assertThat(entries).hasSize(65537);
+ for (int i = 0; i < entries.size(); i++) {
+ JarEntry entry = entries.get(i);
+ InputStream entryInput = nestedZip64JarFile.getInputStream(entry);
+ assertThat(entryInput).hasContent("Entry " + (i + 1));
+ }
+ }
+ }
+ }
+
+ private byte[] zip64Jar() throws IOException {
+ ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+ JarOutputStream jarOutput = new JarOutputStream(bytes);
+ for (int i = 0; i < 65537; i++) {
+ jarOutput.putNextEntry(new JarEntry(i + ".dat"));
+ jarOutput.write(("Entry " + (i + 1)).getBytes(StandardCharsets.UTF_8));
+ jarOutput.closeEntry();
+ }
+ jarOutput.close();
+ return bytes.toByteArray();
+ }
+
+ @Test
+ void jarFileEntryWithEpochTimeOfZeroShouldNotFail() throws Exception {
+ File file = createJarFileWithEpochTimeOfZero();
+ try (JarFile jar = new JarFile(file)) {
+ Enumeration entries = jar.entries();
+ JarEntry entry = entries.nextElement();
+ assertThat(entry.getLastModifiedTime().toInstant()).isEqualTo(Instant.EPOCH);
+ assertThat(entry.getName()).isEqualTo("1.dat");
+ }
+ }
+
+ private File createJarFileWithEpochTimeOfZero() throws Exception {
+ File jarFile = new File(this.tempDir, "temp.jar");
+ FileOutputStream fileOutputStream = new FileOutputStream(jarFile);
+ String comment = "outer";
+ try (JarOutputStream jarOutputStream = new JarOutputStream(fileOutputStream)) {
+ jarOutputStream.setComment(comment);
+ JarEntry entry = new JarEntry("1.dat");
+ entry.setLastModifiedTime(FileTime.from(Instant.EPOCH));
+ jarOutputStream.putNextEntry(entry);
+ jarOutputStream.write(new byte[] { (byte) 1 });
+ jarOutputStream.closeEntry();
+ }
+
+ byte[] data = Files.readAllBytes(jarFile.toPath());
+ int headerPosition = data.length - ZipFile.ENDHDR - comment.getBytes().length;
+ int centralHeaderPosition = (int) Bytes.littleEndianValue(data, headerPosition + ZipFile.ENDOFF, 1);
+ int localHeaderPosition = (int) Bytes.littleEndianValue(data, centralHeaderPosition + ZipFile.CENOFF, 1);
+ writeTimeBlock(data, centralHeaderPosition + ZipFile.CENTIM, 0);
+ writeTimeBlock(data, localHeaderPosition + ZipFile.LOCTIM, 0);
+
+ File jar = new File(this.tempDir, "zerotimed.jar");
+ Files.write(jar.toPath(), data);
+ return jar;
+ }
+
+ private static void writeTimeBlock(byte[] data, int pos, int value) {
+ data[pos] = (byte) (value & 0xff);
+ data[pos + 1] = (byte) ((value >> 8) & 0xff);
+ data[pos + 2] = (byte) ((value >> 16) & 0xff);
+ data[pos + 3] = (byte) ((value >> 24) & 0xff);
+ }
+
+ @Test
+ void iterator() {
+ Iterator iterator = this.jarFile.iterator();
+ List names = new ArrayList<>();
+ while (iterator.hasNext()) {
+ names.add(iterator.next().getName());
+ }
+ assertThat(names).hasSize(12).contains("1.dat");
+ }
+
+ @Test
+ void iteratorWhenClosed() throws IOException {
+ this.jarFile.close();
+ assertThatZipFileClosedIsThrownBy(() -> this.jarFile.iterator());
+ }
+
+ @Test
+ void iteratorWhenClosedLater() throws IOException {
+ Iterator iterator = this.jarFile.iterator();
+ iterator.next();
+ this.jarFile.close();
+ assertThatZipFileClosedIsThrownBy(() -> iterator.hasNext());
+ }
+
+ @Test
+ void stream() {
+ Stream stream = this.jarFile.stream().map(JarEntry::getName);
+ assertThat(stream).hasSize(12).contains("1.dat");
+
+ }
+
+ private void assertThatZipFileClosedIsThrownBy(ThrowingCallable throwingCallable) {
+ assertThatIllegalStateException().isThrownBy(throwingCallable).withMessage("zip file closed");
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/JarFileWrapperTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/JarFileWrapperTests.java
new file mode 100644
index 0000000000..8ae25b72e1
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/JarFileWrapperTests.java
@@ -0,0 +1,281 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jar;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.security.Permission;
+import java.util.EnumSet;
+import java.util.Enumeration;
+import java.util.Set;
+import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
+import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import org.springframework.boot.loader.jar.JarFileWrapperTests.SpyJarFile.Call;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+/**
+ * Tests for {@link JarFileWrapper}.
+ *
+ * @author Phillip Webb
+ */
+class JarFileWrapperTests {
+
+ private SpyJarFile parent;
+
+ private JarFileWrapper wrapper;
+
+ @BeforeEach
+ void setup(@TempDir File temp) throws Exception {
+ this.parent = new SpyJarFile(createTempJar(temp));
+ this.wrapper = new JarFileWrapper(this.parent);
+ }
+
+ @AfterEach
+ void cleanup() throws Exception {
+ this.parent.close();
+ }
+
+ private File createTempJar(File temp) throws IOException {
+ File file = new File(temp, "temp.jar");
+ new JarOutputStream(new FileOutputStream(file)).close();
+ return file;
+ }
+
+ @Test
+ void getUrlDelegatesToParent() throws MalformedURLException {
+ this.wrapper.getUrl();
+ this.parent.verify(Call.GET_URL);
+ }
+
+ @Test
+ void getTypeDelegatesToParent() {
+ this.wrapper.getType();
+ this.parent.verify(Call.GET_TYPE);
+ }
+
+ @Test
+ void getPermissionDelegatesToParent() {
+ this.wrapper.getPermission();
+ this.parent.verify(Call.GET_PERMISSION);
+ }
+
+ @Test
+ void getManifestDelegatesToParent() throws IOException {
+ this.wrapper.getManifest();
+ this.parent.verify(Call.GET_MANIFEST);
+ }
+
+ @Test
+ void entriesDelegatesToParent() {
+ this.wrapper.entries();
+ this.parent.verify(Call.ENTRIES);
+ }
+
+ @Test
+ void getJarEntryDelegatesToParent() {
+ this.wrapper.getJarEntry("test");
+ this.parent.verify(Call.GET_JAR_ENTRY);
+ }
+
+ @Test
+ void getEntryDelegatesToParent() {
+ this.wrapper.getEntry("test");
+ this.parent.verify(Call.GET_ENTRY);
+ }
+
+ @Test
+ void getInputStreamDelegatesToParent() throws IOException {
+ this.wrapper.getInputStream();
+ this.parent.verify(Call.GET_INPUT_STREAM);
+ }
+
+ @Test
+ void getEntryInputStreamDelegatesToParent() throws IOException {
+ ZipEntry entry = new ZipEntry("test");
+ this.wrapper.getInputStream(entry);
+ this.parent.verify(Call.GET_ENTRY_INPUT_STREAM);
+ }
+
+ @Test
+ void getCommentDelegatesToParent() {
+ this.wrapper.getComment();
+ this.parent.verify(Call.GET_COMMENT);
+ }
+
+ @Test
+ void sizeDelegatesToParent() {
+ this.wrapper.size();
+ this.parent.verify(Call.SIZE);
+ }
+
+ @Test
+ void toStringDelegatesToParent() {
+ assertThat(this.wrapper.toString()).endsWith("temp.jar");
+ }
+
+ @Test // gh-22991
+ void wrapperMustNotImplementClose() {
+ // If the wrapper overrides close then on Java 11 a FinalizableResource
+ // instance will be used to perform cleanup. This can result in a lot
+ // of additional memory being used since cleanup only occurs when the
+ // finalizer thread runs. See gh-22991
+ assertThatExceptionOfType(NoSuchMethodException.class)
+ .isThrownBy(() -> JarFileWrapper.class.getDeclaredMethod("close"));
+ }
+
+ @Test
+ void streamDelegatesToParent() {
+ this.wrapper.stream();
+ this.parent.verify(Call.STREAM);
+ }
+
+ /**
+ * {@link JarFile} that we can spy (even on Java 11+)
+ */
+ static class SpyJarFile extends JarFile {
+
+ private final Set calls = EnumSet.noneOf(Call.class);
+
+ SpyJarFile(File file) throws IOException {
+ super(file);
+ }
+
+ @Override
+ Permission getPermission() {
+ mark(Call.GET_PERMISSION);
+ return super.getPermission();
+ }
+
+ @Override
+ public Manifest getManifest() throws IOException {
+ mark(Call.GET_MANIFEST);
+ return super.getManifest();
+ }
+
+ @Override
+ public Enumeration entries() {
+ mark(Call.ENTRIES);
+ return super.entries();
+ }
+
+ @Override
+ public Stream stream() {
+ mark(Call.STREAM);
+ return super.stream();
+ }
+
+ @Override
+ public JarEntry getJarEntry(String name) {
+ mark(Call.GET_JAR_ENTRY);
+ return super.getJarEntry(name);
+ }
+
+ @Override
+ public ZipEntry getEntry(String name) {
+ mark(Call.GET_ENTRY);
+ return super.getEntry(name);
+ }
+
+ @Override
+ InputStream getInputStream() throws IOException {
+ mark(Call.GET_INPUT_STREAM);
+ return super.getInputStream();
+ }
+
+ @Override
+ InputStream getInputStream(String name) throws IOException {
+ mark(Call.GET_ENTRY_INPUT_STREAM);
+ return super.getInputStream(name);
+ }
+
+ @Override
+ public String getComment() {
+ mark(Call.GET_COMMENT);
+ return super.getComment();
+ }
+
+ @Override
+ public int size() {
+ mark(Call.SIZE);
+ return super.size();
+ }
+
+ @Override
+ public URL getUrl() throws MalformedURLException {
+ mark(Call.GET_URL);
+ return super.getUrl();
+ }
+
+ @Override
+ JarFileType getType() {
+ mark(Call.GET_TYPE);
+ return super.getType();
+ }
+
+ private void mark(Call call) {
+ this.calls.add(call);
+ }
+
+ void verify(Call call) {
+ assertThat(call).matches(this.calls::contains);
+ }
+
+ enum Call {
+
+ GET_URL,
+
+ GET_TYPE,
+
+ GET_PERMISSION,
+
+ GET_MANIFEST,
+
+ ENTRIES,
+
+ GET_JAR_ENTRY,
+
+ GET_ENTRY,
+
+ GET_INPUT_STREAM,
+
+ GET_ENTRY_INPUT_STREAM,
+
+ GET_COMMENT,
+
+ SIZE,
+
+ STREAM
+
+ }
+
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/JarURLConnectionTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/JarURLConnectionTests.java
new file mode 100644
index 0000000000..d962a72fc5
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/JarURLConnectionTests.java
@@ -0,0 +1,246 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jar;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.List;
+import java.util.jar.JarEntry;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import org.springframework.boot.loader.TestJarCreator;
+import org.springframework.boot.loader.jar.JarURLConnection.JarEntryName;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+/**
+ * Tests for {@link JarURLConnection}.
+ *
+ * @author Andy Wilkinson
+ * @author Phillip Webb
+ * @author Rostyslav Dudka
+ */
+class JarURLConnectionTests {
+
+ private File rootJarFile;
+
+ private JarFile jarFile;
+
+ @BeforeEach
+ void setup(@TempDir File tempDir) throws Exception {
+ this.rootJarFile = new File(tempDir, "root.jar");
+ TestJarCreator.createTestJar(this.rootJarFile);
+ this.jarFile = new JarFile(this.rootJarFile);
+ }
+
+ @AfterEach
+ void tearDown() throws Exception {
+ this.jarFile.close();
+ }
+
+ @Test
+ void connectionToRootUsingAbsoluteUrl() throws Exception {
+ URL url = new URL("jar:" + this.rootJarFile.toURI().toURL() + "!/");
+ Object content = JarURLConnection.get(url, this.jarFile).getContent();
+ assertThat(JarFileWrapper.unwrap((java.util.jar.JarFile) content)).isSameAs(this.jarFile);
+ }
+
+ @Test
+ void connectionToRootUsingRelativeUrl() throws Exception {
+ URL url = new URL("jar:file:" + getRelativePath() + "!/");
+ Object content = JarURLConnection.get(url, this.jarFile).getContent();
+ assertThat(JarFileWrapper.unwrap((java.util.jar.JarFile) content)).isSameAs(this.jarFile);
+ }
+
+ @Test
+ void connectionToEntryUsingAbsoluteUrl() throws Exception {
+ URL url = new URL("jar:" + this.rootJarFile.toURI().toURL() + "!/1.dat");
+ try (InputStream input = JarURLConnection.get(url, this.jarFile).getInputStream()) {
+ assertThat(input).hasBinaryContent(new byte[] { 1 });
+ }
+ }
+
+ @Test
+ void connectionToEntryUsingRelativeUrl() throws Exception {
+ URL url = new URL("jar:file:" + getRelativePath() + "!/1.dat");
+ try (InputStream input = JarURLConnection.get(url, this.jarFile).getInputStream()) {
+ assertThat(input).hasBinaryContent(new byte[] { 1 });
+ }
+ }
+
+ @Test
+ void connectionToEntryUsingAbsoluteUrlWithFileColonSlashSlashPrefix() throws Exception {
+ URL url = new URL("jar:" + this.rootJarFile.toURI().toURL() + "!/1.dat");
+ try (InputStream input = JarURLConnection.get(url, this.jarFile).getInputStream()) {
+ assertThat(input).hasBinaryContent(new byte[] { 1 });
+ }
+ }
+
+ @Test
+ void connectionToEntryUsingAbsoluteUrlForNestedEntry() throws Exception {
+ URL url = new URL("jar:" + this.rootJarFile.toURI().toURL() + "!/nested.jar!/3.dat");
+ JarURLConnection connection = JarURLConnection.get(url, this.jarFile);
+ try (InputStream input = connection.getInputStream()) {
+ assertThat(input).hasBinaryContent(new byte[] { 3 });
+ }
+ connection.getJarFile().close();
+ }
+
+ @Test
+ void connectionToEntryUsingRelativeUrlForNestedEntry() throws Exception {
+ URL url = new URL("jar:file:" + getRelativePath() + "!/nested.jar!/3.dat");
+ JarURLConnection connection = JarURLConnection.get(url, this.jarFile);
+ try (InputStream input = connection.getInputStream()) {
+ assertThat(input).hasBinaryContent(new byte[] { 3 });
+ }
+ connection.getJarFile().close();
+ }
+
+ @Test
+ void connectionToEntryUsingAbsoluteUrlForEntryFromNestedJarFile() throws Exception {
+ URL url = new URL("jar:" + this.rootJarFile.toURI().toURL() + "!/nested.jar!/3.dat");
+ try (JarFile nested = this.jarFile.getNestedJarFile(this.jarFile.getEntry("nested.jar"))) {
+ try (InputStream input = JarURLConnection.get(url, nested).getInputStream()) {
+ assertThat(input).hasBinaryContent(new byte[] { 3 });
+ }
+ }
+ }
+
+ @Test
+ void connectionToEntryUsingRelativeUrlForEntryFromNestedJarFile() throws Exception {
+ URL url = new URL("jar:file:" + getRelativePath() + "!/nested.jar!/3.dat");
+ try (JarFile nested = this.jarFile.getNestedJarFile(this.jarFile.getEntry("nested.jar"))) {
+ try (InputStream input = JarURLConnection.get(url, nested).getInputStream()) {
+ assertThat(input).hasBinaryContent(new byte[] { 3 });
+ }
+ }
+ }
+
+ @Test
+ void connectionToEntryInNestedJarFromUrlThatUsesExistingUrlAsContext() throws Exception {
+ URL url = new URL(new URL("jar", null, -1, this.rootJarFile.toURI().toURL() + "!/nested.jar!/", new Handler()),
+ "/3.dat");
+ try (JarFile nested = this.jarFile.getNestedJarFile(this.jarFile.getEntry("nested.jar"))) {
+ try (InputStream input = JarURLConnection.get(url, nested).getInputStream()) {
+ assertThat(input).hasBinaryContent(new byte[] { 3 });
+ }
+ }
+ }
+
+ @Test
+ void connectionToEntryWithSpaceNestedEntry() throws Exception {
+ URL url = new URL("jar:file:" + getRelativePath() + "!/space nested.jar!/3.dat");
+ JarURLConnection connection = JarURLConnection.get(url, this.jarFile);
+ try (InputStream input = connection.getInputStream()) {
+ assertThat(input).hasBinaryContent(new byte[] { 3 });
+ }
+ connection.getJarFile().close();
+ }
+
+ @Test
+ void connectionToEntryWithEncodedSpaceNestedEntry() throws Exception {
+ URL url = new URL("jar:file:" + getRelativePath() + "!/space%20nested.jar!/3.dat");
+ JarURLConnection connection = JarURLConnection.get(url, this.jarFile);
+ try (InputStream input = connection.getInputStream()) {
+ assertThat(input).hasBinaryContent(new byte[] { 3 });
+ }
+ connection.getJarFile().close();
+ }
+
+ @Test
+ void connectionToEntryUsingWrongAbsoluteUrlForEntryFromNestedJarFile() throws Exception {
+ URL url = new URL("jar:" + this.rootJarFile.toURI().toURL() + "!/w.jar!/3.dat");
+ try (JarFile nested = this.jarFile.getNestedJarFile(this.jarFile.getEntry("nested.jar"))) {
+ assertThatExceptionOfType(FileNotFoundException.class)
+ .isThrownBy(JarURLConnection.get(url, nested)::getInputStream);
+ }
+ }
+
+ @Test
+ void getContentLengthReturnsLengthOfUnderlyingEntry() throws Exception {
+ URL url = new URL("jar:" + this.rootJarFile.toURI().toURL() + "!/nested.jar!/3.dat");
+ try (JarFile nested = this.jarFile.getNestedJarFile(this.jarFile.getEntry("nested.jar"))) {
+ JarURLConnection connection = JarURLConnection.get(url, nested);
+ assertThat(connection.getContentLength()).isOne();
+ }
+ }
+
+ @Test
+ void getContentLengthLongReturnsLengthOfUnderlyingEntry() throws Exception {
+ URL url = new URL("jar:" + this.rootJarFile.toURI().toURL() + "!/nested.jar!/3.dat");
+ try (JarFile nested = this.jarFile.getNestedJarFile(this.jarFile.getEntry("nested.jar"))) {
+ JarURLConnection connection = JarURLConnection.get(url, nested);
+ assertThat(connection.getContentLengthLong()).isOne();
+ }
+ }
+
+ @Test
+ void getLastModifiedReturnsLastModifiedTimeOfJarEntry() throws Exception {
+ URL url = new URL("jar:" + this.rootJarFile.toURI().toURL() + "!/1.dat");
+ JarURLConnection connection = JarURLConnection.get(url, this.jarFile);
+ assertThat(connection.getLastModified()).isEqualTo(connection.getJarEntry().getTime());
+ }
+
+ @Test
+ void entriesCanBeStreamedFromJarFileOfConnection() throws Exception {
+ URL url = new URL("jar:" + this.rootJarFile.toURI().toURL() + "!/");
+ JarURLConnection connection = JarURLConnection.get(url, this.jarFile);
+ List entryNames = connection.getJarFile().stream().map(JarEntry::getName).toList();
+ assertThat(entryNames).hasSize(12);
+ }
+
+ @Test
+ void jarEntryBasicName() {
+ assertThat(new JarEntryName(new StringSequence("a/b/C.class"))).hasToString("a/b/C.class");
+ }
+
+ @Test
+ void jarEntryNameWithSingleByteEncodedCharacters() {
+ assertThat(new JarEntryName(new StringSequence("%61/%62/%43.class"))).hasToString("a/b/C.class");
+ }
+
+ @Test
+ void jarEntryNameWithDoubleByteEncodedCharacters() {
+ assertThat(new JarEntryName(new StringSequence("%c3%a1/b/C.class"))).hasToString("\u00e1/b/C.class");
+ }
+
+ @Test
+ void jarEntryNameWithMixtureOfEncodedAndUnencodedDoubleByteCharacters() {
+ assertThat(new JarEntryName(new StringSequence("%c3%a1/b/\u00c7.class"))).hasToString("\u00e1/b/\u00c7.class");
+ }
+
+ @Test
+ void openConnectionCanBeClosedWithoutClosingSourceJar() throws Exception {
+ URL url = new URL("jar:" + this.rootJarFile.toURI().toURL() + "!/");
+ JarURLConnection connection = JarURLConnection.get(url, this.jarFile);
+ java.util.jar.JarFile connectionJarFile = connection.getJarFile();
+ connectionJarFile.close();
+ assertThat(this.jarFile.isClosed()).isFalse();
+ }
+
+ private String getRelativePath() {
+ return this.rootJarFile.getPath().replace('\\', '/');
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/JarUrlProtocolHandler.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/JarUrlProtocolHandler.java
new file mode 100644
index 0000000000..d9e5eb2814
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/JarUrlProtocolHandler.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jar;
+
+import java.io.File;
+import java.lang.ref.SoftReference;
+import java.util.Map;
+
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.Extension;
+import org.junit.jupiter.api.extension.ExtensionContext;
+
+import org.springframework.test.util.ReflectionTestUtils;
+
+/**
+ * JUnit 5 {@link Extension} for tests that interact with Spring Boot's {@link Handler}
+ * for {@code jar:} URLs. Ensures that the handler is registered prior to test execution
+ * and cleans up the handler's root file cache afterwards.
+ *
+ * @author Andy Wilkinson
+ */
+class JarUrlProtocolHandler implements BeforeEachCallback, AfterEachCallback {
+
+ @Override
+ public void beforeEach(ExtensionContext context) throws Exception {
+ JarFile.registerUrlProtocolHandler();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public void afterEach(ExtensionContext context) throws Exception {
+ Map rootFileCache = ((SoftReference>) ReflectionTestUtils
+ .getField(Handler.class, "rootFileCache")).get();
+ if (rootFileCache != null) {
+ for (JarFile rootJarFile : rootFileCache.values()) {
+ rootJarFile.close();
+ }
+ rootFileCache.clear();
+ }
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/StringSequenceTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/StringSequenceTests.java
new file mode 100644
index 0000000000..ee7170f08c
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jar/StringSequenceTests.java
@@ -0,0 +1,220 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jar;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.Assertions.assertThatNullPointerException;
+
+/**
+ * Tests for {@link StringSequence}.
+ *
+ * @author Phillip Webb
+ */
+class StringSequenceTests {
+
+ @Test
+ void createWhenSourceIsNullShouldThrowException() {
+ assertThatNullPointerException().isThrownBy(() -> new StringSequence(null))
+ .withMessage("Source must not be null");
+ }
+
+ @Test
+ void createWithIndexWhenSourceIsNullShouldThrowException() {
+ assertThatNullPointerException().isThrownBy(() -> new StringSequence(null, 0, 0))
+ .withMessage("Source must not be null");
+ }
+
+ @Test
+ void createWhenStartIsLessThanZeroShouldThrowException() {
+ assertThatExceptionOfType(StringIndexOutOfBoundsException.class)
+ .isThrownBy(() -> new StringSequence("x", -1, 0));
+ }
+
+ @Test
+ void createWhenEndIsGreaterThanLengthShouldThrowException() {
+ assertThatExceptionOfType(StringIndexOutOfBoundsException.class)
+ .isThrownBy(() -> new StringSequence("x", 0, 2));
+ }
+
+ @Test
+ void createFromString() {
+ assertThat(new StringSequence("test")).hasToString("test");
+ }
+
+ @Test
+ void subSequenceWithJustStartShouldReturnSubSequence() {
+ assertThat(new StringSequence("smiles").subSequence(1)).hasToString("miles");
+ }
+
+ @Test
+ void subSequenceShouldReturnSubSequence() {
+ assertThat(new StringSequence("hamburger").subSequence(4, 8)).hasToString("urge");
+ assertThat(new StringSequence("smiles").subSequence(1, 5)).hasToString("mile");
+ }
+
+ @Test
+ void subSequenceWhenCalledMultipleTimesShouldReturnSubSequence() {
+ assertThat(new StringSequence("hamburger").subSequence(4, 8).subSequence(1, 3)).hasToString("rg");
+ }
+
+ @Test
+ void subSequenceWhenEndPastExistingEndShouldThrowException() {
+ StringSequence sequence = new StringSequence("abcde").subSequence(1, 4);
+ assertThat(sequence).hasToString("bcd");
+ assertThat(sequence.subSequence(2, 3)).hasToString("d");
+ assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> sequence.subSequence(3, 4));
+ }
+
+ @Test
+ void subSequenceWhenStartPastExistingEndShouldThrowException() {
+ StringSequence sequence = new StringSequence("abcde").subSequence(1, 4);
+ assertThat(sequence).hasToString("bcd");
+ assertThat(sequence.subSequence(2, 3)).hasToString("d");
+ assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> sequence.subSequence(4, 3));
+ }
+
+ @Test
+ void isEmptyWhenEmptyShouldReturnTrue() {
+ assertThat(new StringSequence("").isEmpty()).isTrue();
+ }
+
+ @Test
+ void isEmptyWhenNotEmptyShouldReturnFalse() {
+ assertThat(new StringSequence("x").isEmpty()).isFalse();
+ }
+
+ @Test
+ void lengthShouldReturnLength() {
+ StringSequence sequence = new StringSequence("hamburger");
+ assertThat(sequence).hasSize(9);
+ assertThat(sequence.subSequence(4, 8)).hasSize(4);
+ }
+
+ @Test
+ void charAtShouldReturnChar() {
+ StringSequence sequence = new StringSequence("hamburger");
+ assertThat(sequence.charAt(0)).isEqualTo('h');
+ assertThat(sequence.charAt(1)).isEqualTo('a');
+ assertThat(sequence.subSequence(4, 8).charAt(0)).isEqualTo('u');
+ assertThat(sequence.subSequence(4, 8).charAt(1)).isEqualTo('r');
+ }
+
+ @Test
+ void indexOfCharShouldReturnIndexOf() {
+ StringSequence sequence = new StringSequence("aabbaacc");
+ assertThat(sequence.indexOf('a')).isZero();
+ assertThat(sequence.indexOf('b')).isEqualTo(2);
+ assertThat(sequence.subSequence(2).indexOf('a')).isEqualTo(2);
+ }
+
+ @Test
+ void indexOfStringShouldReturnIndexOf() {
+ StringSequence sequence = new StringSequence("aabbaacc");
+ assertThat(sequence.indexOf('a')).isZero();
+ assertThat(sequence.indexOf('b')).isEqualTo(2);
+ assertThat(sequence.subSequence(2).indexOf('a')).isEqualTo(2);
+ }
+
+ @Test
+ void indexOfStringFromIndexShouldReturnIndexOf() {
+ StringSequence sequence = new StringSequence("aabbaacc");
+ assertThat(sequence.indexOf("a", 2)).isEqualTo(4);
+ assertThat(sequence.indexOf("b", 3)).isEqualTo(3);
+ assertThat(sequence.subSequence(2).indexOf("a", 3)).isEqualTo(3);
+ }
+
+ @Test
+ void hashCodeShouldBeSameAsString() {
+ assertThat(new StringSequence("hamburger")).hasSameHashCodeAs("hamburger");
+ assertThat(new StringSequence("hamburger").subSequence(4, 8)).hasSameHashCodeAs("urge");
+ }
+
+ @Test
+ void equalsWhenSameContentShouldMatch() {
+ StringSequence a = new StringSequence("hamburger").subSequence(4, 8);
+ StringSequence b = new StringSequence("urge");
+ StringSequence c = new StringSequence("urgh");
+ assertThat(a).isEqualTo(b).isNotEqualTo(c);
+ }
+
+ @Test
+ void notEqualsWhenSequencesOfDifferentLength() {
+ StringSequence a = new StringSequence("abcd");
+ StringSequence b = new StringSequence("ef");
+ assertThat(a).isNotEqualTo(b);
+ }
+
+ @Test
+ void startsWithWhenExactMatch() {
+ assertThat(new StringSequence("abc").startsWith("abc")).isTrue();
+ }
+
+ @Test
+ void startsWithWhenLongerAndStartsWith() {
+ assertThat(new StringSequence("abcd").startsWith("abc")).isTrue();
+ }
+
+ @Test
+ void startsWithWhenLongerAndDoesNotStartWith() {
+ assertThat(new StringSequence("abcd").startsWith("abx")).isFalse();
+ }
+
+ @Test
+ void startsWithWhenShorterAndDoesNotStartWith() {
+ assertThat(new StringSequence("ab").startsWith("abc")).isFalse();
+ assertThat(new StringSequence("ab").startsWith("c")).isFalse();
+ }
+
+ @Test
+ void startsWithOffsetWhenExactMatch() {
+ assertThat(new StringSequence("xabc").startsWith("abc", 1)).isTrue();
+ }
+
+ @Test
+ void startsWithOffsetWhenLongerAndStartsWith() {
+ assertThat(new StringSequence("xabcd").startsWith("abc", 1)).isTrue();
+ }
+
+ @Test
+ void startsWithOffsetWhenLongerAndDoesNotStartWith() {
+ assertThat(new StringSequence("xabcd").startsWith("abx", 1)).isFalse();
+ }
+
+ @Test
+ void startsWithOffsetWhenShorterAndDoesNotStartWith() {
+ assertThat(new StringSequence("xab").startsWith("abc", 1)).isFalse();
+ assertThat(new StringSequence("xab").startsWith("c", 1)).isFalse();
+ }
+
+ @Test
+ void startsWithOnSubstringTailWhenMatch() {
+ StringSequence subSequence = new StringSequence("xabc").subSequence(1);
+ assertThat(subSequence.startsWith("abc")).isTrue();
+ assertThat(subSequence.startsWith("abcd")).isFalse();
+ }
+
+ @Test
+ void startsWithOnSubstringMiddleWhenMatch() {
+ StringSequence subSequence = new StringSequence("xabc").subSequence(1, 3);
+ assertThat(subSequence.startsWith("ab")).isTrue();
+ assertThat(subSequence.startsWith("abc")).isFalse();
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jarmode/LauncherJarModeTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jarmode/LauncherJarModeTests.java
new file mode 100644
index 0000000000..dec587e18b
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/jarmode/LauncherJarModeTests.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.jarmode;
+
+import java.util.Collections;
+import java.util.Iterator;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import org.springframework.boot.loader.Launcher;
+import org.springframework.boot.loader.archive.Archive;
+import org.springframework.boot.testsupport.system.CapturedOutput;
+import org.springframework.boot.testsupport.system.OutputCaptureExtension;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link Launcher} with jar mode support.
+ *
+ * @author Phillip Webb
+ */
+@ExtendWith(OutputCaptureExtension.class)
+class LauncherJarModeTests {
+
+ @BeforeEach
+ void setup() {
+ System.setProperty(JarModeLauncher.DISABLE_SYSTEM_EXIT, "true");
+ }
+
+ @AfterEach
+ void cleanup() {
+ System.clearProperty("jarmode");
+ System.clearProperty(JarModeLauncher.DISABLE_SYSTEM_EXIT);
+ }
+
+ @Test
+ void launchWhenJarModePropertyIsSetLaunchesJarMode(CapturedOutput out) throws Exception {
+ System.setProperty("jarmode", "test");
+ new TestLauncher().launch(new String[] { "boot" });
+ assertThat(out).contains("running in test jar mode [boot]");
+ }
+
+ @Test
+ void launchWhenJarModePropertyIsNotAcceptedThrowsException(CapturedOutput out) throws Exception {
+ System.setProperty("jarmode", "idontexist");
+ new TestLauncher().launch(new String[] { "boot" });
+ assertThat(out).contains("Unsupported jarmode 'idontexist'");
+ }
+
+ private static class TestLauncher extends Launcher {
+
+ @Override
+ protected String getMainClass() throws Exception {
+ throw new IllegalStateException("Should not be called");
+ }
+
+ @Override
+ protected Iterator getClassPathArchivesIterator() throws Exception {
+ return Collections.emptyIterator();
+ }
+
+ @Override
+ protected void launch(String[] args) throws Exception {
+ super.launch(args);
+ }
+
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/util/SystemPropertyUtilsTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/util/SystemPropertyUtilsTests.java
new file mode 100644
index 0000000000..802a762e79
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/java/org/springframework/boot/loader/util/SystemPropertyUtilsTests.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.util;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link SystemPropertyUtils}.
+ *
+ * @author Dave Syer
+ */
+class SystemPropertyUtilsTests {
+
+ @BeforeEach
+ void init() {
+ System.setProperty("foo", "bar");
+ }
+
+ @AfterEach
+ void close() {
+ System.clearProperty("foo");
+ }
+
+ @Test
+ void testVanillaPlaceholder() {
+ assertThat(SystemPropertyUtils.resolvePlaceholders("${foo}")).isEqualTo("bar");
+ }
+
+ @Test
+ void testDefaultValue() {
+ assertThat(SystemPropertyUtils.resolvePlaceholders("${bar:foo}")).isEqualTo("foo");
+ }
+
+ @Test
+ void testNestedPlaceholder() {
+ assertThat(SystemPropertyUtils.resolvePlaceholders("${bar:${spam:foo}}")).isEqualTo("foo");
+ }
+
+ @Test
+ void testEnvVar() {
+ assertThat(SystemPropertyUtils.getProperty("lang")).isEqualTo(System.getenv("LANG"));
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/BOOT-INF/classes/application.properties b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/BOOT-INF/classes/application.properties
new file mode 100644
index 0000000000..85a390f4d4
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/BOOT-INF/classes/application.properties
@@ -0,0 +1 @@
+loader.main: demo.Application
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/BOOT-INF/classes/bar.properties b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/BOOT-INF/classes/bar.properties
new file mode 100644
index 0000000000..6b37480f8b
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/BOOT-INF/classes/bar.properties
@@ -0,0 +1 @@
+loader.main: my.BootInfBarApplication
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/BOOT-INF/classes/foo.properties b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/BOOT-INF/classes/foo.properties
new file mode 100644
index 0000000000..36bd211df4
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/BOOT-INF/classes/foo.properties
@@ -0,0 +1,3 @@
+foo: Application
+loader.main: my.${foo}
+loader.path: etc
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/BOOT-INF/classes/loader.properties b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/BOOT-INF/classes/loader.properties
new file mode 100644
index 0000000000..85a390f4d4
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/BOOT-INF/classes/loader.properties
@@ -0,0 +1 @@
+loader.main: demo.Application
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/META-INF/spring.factories b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/META-INF/spring.factories
new file mode 100644
index 0000000000..c45c87d76f
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/META-INF/spring.factories
@@ -0,0 +1,3 @@
+# Jar Modes
+org.springframework.boot.loader.jarmode.JarMode=\
+org.springframework.boot.loader.jarmode.TestJarMode
\ No newline at end of file
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/bar.properties b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/bar.properties
new file mode 100644
index 0000000000..8301c2649f
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/bar.properties
@@ -0,0 +1 @@
+loader.main: my.BarApplication
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/explodedsample/ExampleClass.txt b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/explodedsample/ExampleClass.txt
new file mode 100644
index 0000000000..c53100f90f
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/explodedsample/ExampleClass.txt
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012-2020 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
+ *
+ * https://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 explodedsample;
+
+/**
+ * Example class used to test class loading.
+ *
+ * @author Phillip Webb
+ */
+public class ExampleClass {
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/home/loader.properties b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/home/loader.properties
new file mode 100644
index 0000000000..7a134969b7
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/home/loader.properties
@@ -0,0 +1 @@
+loader.main: demo.HomeApplication
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/jars/app.jar b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/jars/app.jar
new file mode 100644
index 0000000000..fb02c02701
Binary files /dev/null and b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/jars/app.jar differ
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/more-jars/app.jar b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/more-jars/app.jar
new file mode 100644
index 0000000000..3945fd020d
Binary files /dev/null and b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/more-jars/app.jar differ
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/nested-jars/app.jar b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/nested-jars/app.jar
new file mode 100644
index 0000000000..5600ed279e
Binary files /dev/null and b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/nested-jars/app.jar differ
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/nested-jars/nested-jar-app.jar b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/nested-jars/nested-jar-app.jar
new file mode 100644
index 0000000000..4c2254f635
Binary files /dev/null and b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/nested-jars/nested-jar-app.jar differ
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/org/springframework/boot/loader/classpath-index-file.idx b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/org/springframework/boot/loader/classpath-index-file.idx
new file mode 100644
index 0000000000..b84b99a6b4
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/org/springframework/boot/loader/classpath-index-file.idx
@@ -0,0 +1,5 @@
+- "BOOT-INF/layers/one/lib/a.jar"
+- "BOOT-INF/layers/one/lib/b.jar"
+- "BOOT-INF/layers/one/lib/c.jar"
+- "BOOT-INF/layers/two/lib/d.jar"
+- "BOOT-INF/layers/two/lib/e.jar"
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/placeholders/META-INF/MANIFEST.MF b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/placeholders/META-INF/MANIFEST.MF
new file mode 100644
index 0000000000..d95a13c528
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/placeholders/META-INF/MANIFEST.MF
@@ -0,0 +1,2 @@
+Manifest-Version: 1.0
+Start-Class: ${foo.main}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/placeholders/loader.properties b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/placeholders/loader.properties
new file mode 100644
index 0000000000..32f7d00f2d
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/placeholders/loader.properties
@@ -0,0 +1 @@
+foo.main: demo.FooApplication
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/root/META-INF/MANIFEST.MF b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/root/META-INF/MANIFEST.MF
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/root/META-INF/MANIFEST.MF
@@ -0,0 +1 @@
+
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/root/META-INF/spring/application.xml b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/root/META-INF/spring/application.xml
new file mode 100644
index 0000000000..cf04aa4fbe
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-classic/src/test/resources/root/META-INF/spring/application.xml
@@ -0,0 +1,6 @@
+
+
+
+
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/build.gradle b/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/build.gradle
index 755f1cc7bc..f7968f659d 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/build.gradle
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/build.gradle
@@ -13,6 +13,10 @@ configurations {
extendsFrom dependencyManagement
transitive = false
}
+ loaderClassic {
+ extendsFrom dependencyManagement
+ transitive = false
+ }
jarmode {
extendsFrom dependencyManagement
transitive = false
@@ -37,6 +41,7 @@ dependencies {
compileOnly("ch.qos.logback:logback-classic")
loader(project(":spring-boot-project:spring-boot-tools:spring-boot-loader"))
+ loaderClassic(project(":spring-boot-project:spring-boot-tools:spring-boot-loader-classic"))
jarmode(project(":spring-boot-project:spring-boot-tools:spring-boot-jarmode-layertools"))
@@ -61,6 +66,21 @@ task reproducibleLoaderJar(type: Jar) {
destinationDirectory = file("${generatedResources}/META-INF/loader")
}
+task reproducibleLoaderClassicJar(type: Jar) {
+ dependsOn configurations.loaderClassic
+ from {
+ zipTree(configurations.loaderClassic.incoming.files.singleFile).matching {
+ exclude "META-INF/LICENSE.txt"
+ exclude "META-INF/NOTICE.txt"
+ exclude "META-INF/spring-boot.properties"
+ }
+ }
+ reproducibleFileOrder = true
+ preserveFileTimestamps = false
+ archiveFileName = "spring-boot-loader-classic.jar"
+ destinationDirectory = file("${generatedResources}/META-INF/loader")
+}
+
task layerToolsJar(type: Sync) {
dependsOn configurations.jarmode
from {
@@ -72,12 +92,12 @@ task layerToolsJar(type: Sync) {
sourceSets {
main {
- output.dir(generatedResources, builtBy: [layerToolsJar, reproducibleLoaderJar])
+ output.dir(generatedResources, builtBy: [layerToolsJar, reproducibleLoaderJar, reproducibleLoaderClassicJar])
}
}
compileJava {
if ((!project.hasProperty("toolchainVersion")) && JavaVersion.current() == JavaVersion.VERSION_1_8) {
- options.compilerArgs += ['-Xlint:-sunapi', '-XDenableSunApiLintControl']
- }
+ options.compilerArgs += ['-Xlint:-sunapi', '-XDenableSunApiLintControl']
+ }
}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/AbstractJarWriter.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/AbstractJarWriter.java
index ffbdf5ec73..7e807b1f9d 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/AbstractJarWriter.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/AbstractJarWriter.java
@@ -51,8 +51,6 @@ import org.apache.commons.compress.archivers.zip.UnixStat;
*/
public abstract class AbstractJarWriter implements LoaderClassesWriter {
- private static final String NESTED_LOADER_JAR = "META-INF/loader/spring-boot-loader.jar";
-
private static final int BUFFER_SIZE = 32 * 1024;
private static final int UNIX_FILE_MODE = UnixStat.FILE_FLAG | UnixStat.DEFAULT_FILE_PERM;
@@ -199,13 +197,15 @@ public abstract class AbstractJarWriter implements LoaderClassesWriter {
return library.getLastModified();
}
- /**
- * Write the required spring-boot-loader classes to the JAR.
- * @throws IOException if the classes cannot be written
- */
@Override
public void writeLoaderClasses() throws IOException {
- writeLoaderClasses(NESTED_LOADER_JAR);
+ writeLoaderClasses(LoaderImplementation.DEFAULT);
+ }
+
+ @Override
+ public void writeLoaderClasses(LoaderImplementation loaderImplementation) throws IOException {
+ writeLoaderClasses((loaderImplementation != null) ? loaderImplementation.getJarResourceName()
+ : LoaderImplementation.DEFAULT.getJarResourceName());
}
/**
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/Layouts.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/Layouts.java
index 82c73ef859..e6f99282a7 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/Layouts.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/Layouts.java
@@ -23,7 +23,7 @@ import java.util.Locale;
import java.util.Map;
/**
- * Common {@link Layout}s.
+ * Common {@link Layout layouts}.
*
* @author Phillip Webb
* @author Dave Syer
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/LoaderClassesWriter.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/LoaderClassesWriter.java
index 187ff0b902..864992279d 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/LoaderClassesWriter.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/LoaderClassesWriter.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2023 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.
@@ -34,6 +34,14 @@ public interface LoaderClassesWriter {
*/
void writeLoaderClasses() throws IOException;
+ /**
+ * Write the default required spring-boot-loader classes to the JAR.
+ * @param loaderImplementation the specific implementation to write
+ * @throws IOException if the classes cannot be written
+ * @since 3.2.0
+ */
+ void writeLoaderClasses(LoaderImplementation loaderImplementation) throws IOException;
+
/**
* Write custom required spring-boot-loader classes to the JAR.
* @param loaderJarResourceName the name of the resource containing the loader classes
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/LoaderImplementation.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/LoaderImplementation.java
new file mode 100644
index 0000000000..6414a3cfbb
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/LoaderImplementation.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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;
+
+/**
+ * Supported loader implementations.
+ *
+ * @author Phillip Webb
+ * @since 3.2.0
+ */
+public enum LoaderImplementation {
+
+ /**
+ * The default recommended loader implementation.
+ */
+ DEFAULT("META-INF/loader/spring-boot-loader.jar"),
+
+ /**
+ * The classic loader implementation as used with Spring Boot 3.1 and earlier.
+ */
+ CLASSIC("META-INF/loader/spring-boot-loader-classic.jar");
+
+ private final String jarResourceName;
+
+ LoaderImplementation(String jarResourceName) {
+ this.jarResourceName = jarResourceName;
+ }
+
+ /**
+ * Return the name of the nested resource that can be loaded from the tools jar.
+ * @return the jar resource name
+ */
+ public String getJarResourceName() {
+ return this.jarResourceName;
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/Packager.java b/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/Packager.java
index 815e0ee4a9..af4dff2330 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/Packager.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/Packager.java
@@ -88,6 +88,8 @@ public abstract class Packager {
private Layout layout;
+ private LoaderImplementation loaderImplementation;
+
private LayoutFactory layoutFactory;
private Layers layers;
@@ -135,6 +137,14 @@ public abstract class Packager {
this.layout = layout;
}
+ /**
+ * Sets the loader implementation to use.
+ * @param loaderImplementation the loaderImplementation to set
+ */
+ public void setLoaderImplementation(LoaderImplementation loaderImplementation) {
+ this.loaderImplementation = loaderImplementation;
+ }
+
/**
* Sets the layout factory for the jar. The factory can be used when no specific
* layout is specified.
@@ -215,7 +225,7 @@ public abstract class Packager {
customLoaderLayout.writeLoadedClasses(writer);
}
else if (layout.isExecutable()) {
- writer.writeLoaderClasses();
+ writer.writeLoaderClasses(this.loaderImplementation);
}
}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/ClassPathIndexFile.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/ClassPathIndexFile.java
index c08407941b..5ad01e5071 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/ClassPathIndexFile.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/ClassPathIndexFile.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/ExecutableArchiveLauncher.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/ExecutableArchiveLauncher.java
index 91b84b1140..d2ceaf61c5 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/ExecutableArchiveLauncher.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/ExecutableArchiveLauncher.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/JarLauncher.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/JarLauncher.java
index 2c86b3d41f..5061573e24 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/JarLauncher.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/JarLauncher.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2021 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/LaunchedURLClassLoader.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/LaunchedURLClassLoader.java
index 8c7cf98ae1..7e3e2fa223 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/LaunchedURLClassLoader.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/LaunchedURLClassLoader.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/Launcher.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/Launcher.java
index f83f685d24..2f4cac9444 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/Launcher.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/Launcher.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/MainMethodRunner.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/MainMethodRunner.java
index 9b7a551a8b..12355a2bef 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/MainMethodRunner.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/MainMethodRunner.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2020 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/WarLauncher.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/WarLauncher.java
index 81e0a74414..482832c1f7 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/WarLauncher.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/WarLauncher.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2021 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/Archive.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/Archive.java
index a99c1c2c22..c1f2bbb2f7 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/Archive.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/Archive.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/ExplodedArchive.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/ExplodedArchive.java
index 0873407852..f8cd52dc16 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/ExplodedArchive.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/ExplodedArchive.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/JarFileArchive.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/JarFileArchive.java
index b30c8bb37a..91e7bc53a4 100755
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/JarFileArchive.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/JarFileArchive.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/package-info.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/package-info.java
index ebaca84bb9..27ce99b006 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/package-info.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/archive/package-info.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2020 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/data/RandomAccessData.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/data/RandomAccessData.java
index ec1aa5e4a1..e96d5ea81a 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/data/RandomAccessData.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/data/RandomAccessData.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/data/package-info.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/data/package-info.java
index 8f456bd685..34bf2ead43 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/data/package-info.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/data/package-info.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2021 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/AbstractJarFile.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/AbstractJarFile.java
index 88726e3737..6a98ef6821 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/AbstractJarFile.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/AbstractJarFile.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2020 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/AsciiBytes.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/AsciiBytes.java
index 4b6e2678b3..cfe121b689 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/AsciiBytes.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/AsciiBytes.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/Bytes.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/Bytes.java
index 7f53bac629..d46a22555d 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/Bytes.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/Bytes.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/CentralDirectoryEndRecord.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/CentralDirectoryEndRecord.java
index b971b590ab..61db0b73f4 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/CentralDirectoryEndRecord.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/CentralDirectoryEndRecord.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/CentralDirectoryParser.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/CentralDirectoryParser.java
index 71a7678535..eff96a56e2 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/CentralDirectoryParser.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/CentralDirectoryParser.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2021 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/CentralDirectoryVisitor.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/CentralDirectoryVisitor.java
index d160cbf847..22e04b329c 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/CentralDirectoryVisitor.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/CentralDirectoryVisitor.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2021 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/FileHeader.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/FileHeader.java
index 4b8de5008c..7e4134fe56 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/FileHeader.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/FileHeader.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/Handler.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/Handler.java
index 67bf8048f0..932dea6548 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/Handler.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/Handler.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarEntry.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarEntry.java
index 5b8f3bedb2..8f54dc3070 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarEntry.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarEntry.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarEntryCertification.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarEntryCertification.java
index cbf66412e2..ffd629e094 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarEntryCertification.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarEntryCertification.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2020 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarEntryFilter.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarEntryFilter.java
index 98ed4b905e..6804f0ba37 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarEntryFilter.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarEntryFilter.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarFile.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarFile.java
index 502c450fa7..6e548048db 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarFile.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarFile.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarFileWrapper.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarFileWrapper.java
index 0a3bf030a5..b65358947a 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarFileWrapper.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarFileWrapper.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarURLConnection.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarURLConnection.java
index c9286b3e8b..859ae88ab0 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarURLConnection.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/JarURLConnection.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/StringSequence.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/StringSequence.java
index 9e6af077ed..12850a4ebe 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/StringSequence.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/StringSequence.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/ZipInflaterInputStream.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/ZipInflaterInputStream.java
index 87587bed3f..67624460cc 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/ZipInflaterInputStream.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/ZipInflaterInputStream.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/package-info.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/package-info.java
index e232261ff4..638afe45f4 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/package-info.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/package-info.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/JarMode.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/JarMode.java
index c711e206f5..162e4a6a73 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/JarMode.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/JarMode.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2020 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/JarModeLauncher.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/JarModeLauncher.java
index 4424889341..44fcb7902e 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/JarModeLauncher.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/JarModeLauncher.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2020 the original author or authors.
+ * Copyright 2012-2023 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.
@@ -22,7 +22,7 @@ import org.springframework.core.io.support.SpringFactoriesLoader;
import org.springframework.util.ClassUtils;
/**
- * Delegate class used to launch the uber jar in a specific mode.
+ * Delegate class used to launch the fat jar in a specific mode.
*
* @author Phillip Webb
* @since 2.3.0
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/TestJarMode.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/TestJarMode.java
index 6a6e83ff23..2e17175690 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/TestJarMode.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/TestJarMode.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2020 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/package-info.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/package-info.java
index 315cb5696b..2f3b5a74e8 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/package-info.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jarmode/package-info.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2020 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/package-info.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/package-info.java
index c2114c2d83..4b32f644f5 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/package-info.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/package-info.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/util/SystemPropertyUtils.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/util/SystemPropertyUtils.java
index b6f0e3a3a7..df00705e9e 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/util/SystemPropertyUtils.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/util/SystemPropertyUtils.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/util/package-info.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/util/package-info.java
index af0aa2d1a7..d3d7eef2d9 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/util/package-info.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/util/package-info.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/AbstractExecutableArchiveLauncherTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/AbstractExecutableArchiveLauncherTests.java
index 48d7340ee3..60e3cb2765 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/AbstractExecutableArchiveLauncherTests.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/AbstractExecutableArchiveLauncherTests.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2021 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/JarLauncherTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/JarLauncherTests.java
index fa71303430..afa32a7c4f 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/JarLauncherTests.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/JarLauncherTests.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/TestJarCreator.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/TestJarCreator.java
index 100e2c757e..c5c5fd3b95 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/TestJarCreator.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/TestJarCreator.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2021 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/WarLauncherTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/WarLauncherTests.java
index aef78cfa53..fbab8d36ed 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/WarLauncherTests.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/WarLauncherTests.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2021 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/jarmode/LauncherJarModeTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/jarmode/LauncherJarModeTests.java
index 93179bad6f..dec587e18b 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/jarmode/LauncherJarModeTests.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/jarmode/LauncherJarModeTests.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2020 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/util/SystemPropertyUtilsTests.java b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/util/SystemPropertyUtilsTests.java
index 0697b77b7b..802a762e79 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/util/SystemPropertyUtilsTests.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/util/SystemPropertyUtilsTests.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2023 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.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/intTest/java/org/springframework/boot/maven/JarIntegrationTests.java b/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/intTest/java/org/springframework/boot/maven/JarIntegrationTests.java
index 1d37949cfa..c903da23a2 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/intTest/java/org/springframework/boot/maven/JarIntegrationTests.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/intTest/java/org/springframework/boot/maven/JarIntegrationTests.java
@@ -75,6 +75,26 @@ class JarIntegrationTests extends AbstractArchiveIntegrationTests {
});
}
+ @TestTemplate
+ void whenJarWithClassicLoaderIsRepackagedInPlaceOnlyRepackagedJarIsInstalled(MavenBuild mavenBuild) {
+ mavenBuild.project("jar-with-classic-loader").goals("install").execute((project) -> {
+ File original = new File(project, "target/jar-with-classic-loader-0.0.1.BUILD-SNAPSHOT.jar.original");
+ assertThat(original).isFile();
+ File repackaged = new File(project, "target/jar-with-classic-loader-0.0.1.BUILD-SNAPSHOT.jar");
+ assertThat(launchScript(repackaged)).isEmpty();
+ assertThat(jar(repackaged)).manifest((manifest) -> {
+ manifest.hasMainClass("org.springframework.boot.loader.launch.JarLauncher");
+ manifest.hasStartClass("some.random.Main");
+ manifest.hasAttribute("Not-Used", "Foo");
+ }).hasEntryWithName("org/springframework/boot/loader/launch/JarLauncher.class");
+ assertThat(buildLog(project))
+ .contains("Replacing main artifact " + repackaged + " with repackaged archive,")
+ .contains("The original artifact has been renamed to " + original)
+ .contains("Installing " + repackaged + " to")
+ .doesNotContain("Installing " + original + " to");
+ });
+ }
+
@TestTemplate
void whenAttachIsDisabledOnlyTheOriginalJarIsInstalled(MavenBuild mavenBuild) {
mavenBuild.project("jar-attach-disabled").goals("install").execute((project) -> {
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/intTest/projects/jar-with-classic-loader/pom.xml b/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/intTest/projects/jar-with-classic-loader/pom.xml
new file mode 100644
index 0000000000..64d9d04f99
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/intTest/projects/jar-with-classic-loader/pom.xml
@@ -0,0 +1,58 @@
+
+
+ 4.0.0
+ org.springframework.boot.maven.it
+ jar-with-classic-loader
+ 0.0.1.BUILD-SNAPSHOT
+
+ UTF-8
+ @java.version@
+ @java.version@
+
+
+
+
+ @project.groupId@
+ @project.artifactId@
+ @project.version@
+
+
+
+ repackage
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-jar-plugin
+ @maven-jar-plugin.version@
+
+
+
+ some.random.Main
+
+
+ Foo
+
+
+ CLASSIC
+
+
+
+
+
+
+ org.springframework
+ spring-context
+ @spring-framework.version@
+
+
+ jakarta.servlet
+ jakarta.servlet-api
+ @jakarta-servlet.version@
+ provided
+
+
+
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/intTest/projects/jar-with-classic-loader/src/main/java/org/test/SampleApplication.java b/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/intTest/projects/jar-with-classic-loader/src/main/java/org/test/SampleApplication.java
new file mode 100644
index 0000000000..5e51546d4e
--- /dev/null
+++ b/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/intTest/projects/jar-with-classic-loader/src/main/java/org/test/SampleApplication.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.test;
+
+public class SampleApplication {
+
+ public static void main(String[] args) {
+ }
+
+}
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/AbstractPackagerMojo.java b/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/AbstractPackagerMojo.java
index b6dfdc04bb..28d55d213a 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/AbstractPackagerMojo.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/AbstractPackagerMojo.java
@@ -47,6 +47,7 @@ import org.springframework.boot.loader.tools.Layouts.Jar;
import org.springframework.boot.loader.tools.Layouts.None;
import org.springframework.boot.loader.tools.Layouts.War;
import org.springframework.boot.loader.tools.Libraries;
+import org.springframework.boot.loader.tools.LoaderImplementation;
import org.springframework.boot.loader.tools.Packager;
import org.springframework.boot.loader.tools.layer.CustomLayers;
@@ -128,6 +129,15 @@ public abstract class AbstractPackagerMojo extends AbstractDependencyFilterMojo
return null;
}
+ /**
+ * Return the loader implementation that should be used.
+ * @return the loader implementation or {@code null}
+ * @since 3.2.0
+ */
+ protected LoaderImplementation getLoaderImplementation() {
+ return null;
+ }
+
/**
* Return the layout factory that will be used to determine the {@link LayoutType} if
* no explicit layout is set.
@@ -145,6 +155,7 @@ public abstract class AbstractPackagerMojo extends AbstractDependencyFilterMojo
*/
protected P getConfiguredPackager(Supplier
supplier) {
P packager = supplier.get();
+ packager.setLoaderImplementation(getLoaderImplementation());
packager.setLayoutFactory(getLayoutFactory());
packager.addMainClassTimeoutWarningListener(new LoggingMainClassTimeoutWarningListener(this::getLog));
packager.setMainClass(this.mainClass);
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/BuildImageMojo.java b/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/BuildImageMojo.java
index 84589c0189..79b62bf530 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/BuildImageMojo.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/BuildImageMojo.java
@@ -48,6 +48,7 @@ import org.springframework.boot.loader.tools.EntryWriter;
import org.springframework.boot.loader.tools.ImagePackager;
import org.springframework.boot.loader.tools.LayoutFactory;
import org.springframework.boot.loader.tools.Libraries;
+import org.springframework.boot.loader.tools.LoaderImplementation;
import org.springframework.util.StringUtils;
/**
@@ -187,6 +188,13 @@ public abstract class BuildImageMojo extends AbstractPackagerMojo {
@Parameter
private LayoutType layout;
+ /**
+ * The loader implementation that should be used.
+ * @since 3.2.0
+ */
+ @Parameter
+ private LoaderImplementation loaderImplementation;
+
/**
* The layout factory that will be used to create the executable archive if no
* explicit layout is set. Alternative layouts implementations can be provided by 3rd
@@ -206,6 +214,11 @@ public abstract class BuildImageMojo extends AbstractPackagerMojo {
return this.layout;
}
+ @Override
+ protected LoaderImplementation getLoaderImplementation() {
+ return this.loaderImplementation;
+ }
+
/**
* Return the layout factory that will be used to determine the
* {@link AbstractPackagerMojo.LayoutType} if no explicit layout is set.
diff --git a/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/RepackageMojo.java b/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/RepackageMojo.java
index 5ca2ecac5a..13a16c2a14 100644
--- a/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/RepackageMojo.java
+++ b/spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/RepackageMojo.java
@@ -36,6 +36,7 @@ import org.springframework.boot.loader.tools.DefaultLaunchScript;
import org.springframework.boot.loader.tools.LaunchScript;
import org.springframework.boot.loader.tools.LayoutFactory;
import org.springframework.boot.loader.tools.Libraries;
+import org.springframework.boot.loader.tools.LoaderImplementation;
import org.springframework.boot.loader.tools.Repackager;
/**
@@ -161,6 +162,13 @@ public class RepackageMojo extends AbstractPackagerMojo {
@Parameter(property = "spring-boot.repackage.layout")
private LayoutType layout;
+ /**
+ * The loader implementation that should be used.
+ * @since 3.2.0
+ */
+ @Parameter
+ private LoaderImplementation loaderImplementation;
+
/**
* The layout factory that will be used to create the executable archive if no
* explicit layout is set. Alternative layouts implementations can be provided by 3rd
@@ -180,6 +188,11 @@ public class RepackageMojo extends AbstractPackagerMojo {
return this.layout;
}
+ @Override
+ protected LoaderImplementation getLoaderImplementation() {
+ return this.loaderImplementation;
+ }
+
/**
* Return the layout factory that will be used to determine the
* {@link AbstractPackagerMojo.LayoutType} if no explicit layout is set.
diff --git a/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/build.gradle b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/build.gradle
new file mode 100644
index 0000000000..d05a3d6c9e
--- /dev/null
+++ b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/build.gradle
@@ -0,0 +1,44 @@
+plugins {
+ id "java"
+ id "org.springframework.boot.conventions"
+ id "org.springframework.boot.integration-test"
+}
+
+description = "Spring Boot Classic Loader Integration Tests"
+
+configurations {
+ app
+}
+
+dependencies {
+ app project(path: ":spring-boot-project:spring-boot-dependencies", configuration: "mavenRepository")
+ app project(path: ":spring-boot-project:spring-boot-tools:spring-boot-gradle-plugin", configuration: "mavenRepository")
+ app project(path: ":spring-boot-project:spring-boot-starters:spring-boot-starter-web", configuration: "mavenRepository")
+
+ intTestImplementation(enforcedPlatform(project(":spring-boot-project:spring-boot-parent")))
+ intTestImplementation(project(":spring-boot-project:spring-boot-tools:spring-boot-test-support"))
+ intTestImplementation(project(":spring-boot-project:spring-boot-starters:spring-boot-starter-test"))
+ intTestImplementation("org.testcontainers:junit-jupiter")
+ intTestImplementation("org.testcontainers:testcontainers")
+}
+
+task syncMavenRepository(type: Sync) {
+ from configurations.app
+ into "${buildDir}/int-test-maven-repository"
+}
+
+task syncAppSource(type: org.springframework.boot.build.SyncAppSource) {
+ sourceDirectory = file("spring-boot-loader-classic-tests-app")
+ destinationDirectory = file("${buildDir}/spring-boot-loader-classic-tests-app")
+}
+
+task buildApp(type: GradleBuild) {
+ dependsOn syncAppSource, syncMavenRepository
+ dir = "${buildDir}/spring-boot-loader-classic-tests-app"
+ startParameter.buildCacheEnabled = false
+ tasks = ["build"]
+}
+
+intTest {
+ dependsOn buildApp
+}
\ No newline at end of file
diff --git a/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/spring-boot-loader-classic-tests-app/build.gradle b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/spring-boot-loader-classic-tests-app/build.gradle
new file mode 100644
index 0000000000..16f7a57ebe
--- /dev/null
+++ b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/spring-boot-loader-classic-tests-app/build.gradle
@@ -0,0 +1,22 @@
+plugins {
+ id "java"
+ id "org.springframework.boot"
+}
+
+apply plugin: "io.spring.dependency-management"
+
+repositories {
+ maven { url "file:${rootDir}/../int-test-maven-repository"}
+ mavenCentral()
+ maven { url "https://repo.spring.io/snapshot" }
+ maven { url "https://repo.spring.io/milestone" }
+}
+
+dependencies {
+ implementation("org.springframework.boot:spring-boot-starter-web")
+ implementation("org.webjars:jquery:3.5.0")
+}
+
+bootJar {
+ loaderImplementation = org.springframework.boot.loader.tools.LoaderImplementation.CLASSIC
+}
\ No newline at end of file
diff --git a/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/spring-boot-loader-classic-tests-app/settings.gradle b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/spring-boot-loader-classic-tests-app/settings.gradle
new file mode 100644
index 0000000000..06d9554ad0
--- /dev/null
+++ b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/spring-boot-loader-classic-tests-app/settings.gradle
@@ -0,0 +1,15 @@
+pluginManagement {
+ repositories {
+ maven { url "file:${rootDir}/../int-test-maven-repository"}
+ mavenCentral()
+ maven { url "https://repo.spring.io/snapshot" }
+ maven { url "https://repo.spring.io/milestone" }
+ }
+ resolutionStrategy {
+ eachPlugin {
+ if (requested.id.id == "org.springframework.boot") {
+ useModule "org.springframework.boot:spring-boot-gradle-plugin:${requested.version}"
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/spring-boot-loader-classic-tests-app/src/main/java/org/springframework/boot/loaderapp/LoaderTestApplication.java b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/spring-boot-loader-classic-tests-app/src/main/java/org/springframework/boot/loaderapp/LoaderTestApplication.java
new file mode 100644
index 0000000000..0c9d429350
--- /dev/null
+++ b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/spring-boot-loader-classic-tests-app/src/main/java/org/springframework/boot/loaderapp/LoaderTestApplication.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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.loaderapp;
+
+import java.io.File;
+import java.net.JarURLConnection;
+import java.net.URL;
+import java.util.Arrays;
+
+import jakarta.servlet.ServletContext;
+
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.util.FileCopyUtils;
+
+@SpringBootApplication
+public class LoaderTestApplication {
+
+ @Bean
+ public CommandLineRunner commandLineRunner(ServletContext servletContext) {
+ return (args) -> {
+ File temp = new File(System.getProperty("java.io.tmpdir"));
+ URL resourceUrl = servletContext.getResource("webjars/jquery/3.5.0/jquery.js");
+ JarURLConnection connection = (JarURLConnection) resourceUrl.openConnection();
+ String jarName = connection.getJarFile().getName();
+ System.out.println(">>>>> jar file " + jarName);
+ if(jarName.contains(temp.getAbsolutePath())) {
+ System.out.println(">>>>> jar written to temp");
+ }
+ byte[] resourceContent = FileCopyUtils.copyToByteArray(resourceUrl.openStream());
+ URL directUrl = new URL(resourceUrl.toExternalForm());
+ byte[] directContent = FileCopyUtils.copyToByteArray(directUrl.openStream());
+ String message = (!Arrays.equals(resourceContent, directContent)) ? "NO MATCH"
+ : directContent.length + " BYTES";
+ System.out.println(">>>>> " + message + " from " + resourceUrl);
+ };
+ }
+
+ public static void main(String[] args) {
+ SpringApplication.run(LoaderTestApplication.class, args).close();
+ }
+
+}
diff --git a/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/java/org/springframework/boot/loader/LoaderIntegrationTests.java b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/java/org/springframework/boot/loader/LoaderIntegrationTests.java
new file mode 100644
index 0000000000..b11478b61c
--- /dev/null
+++ b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/java/org/springframework/boot/loader/LoaderIntegrationTests.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2012-2023 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
+ *
+ * https://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;
+
+import java.io.File;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.output.ToStringConsumer;
+import org.testcontainers.containers.startupcheck.OneShotStartupCheckStrategy;
+import org.testcontainers.images.builder.ImageFromDockerfile;
+import org.testcontainers.utility.DockerImageName;
+import org.testcontainers.utility.MountableFile;
+
+import org.springframework.boot.system.JavaVersion;
+import org.springframework.boot.testsupport.testcontainers.DisabledIfDockerUnavailable;
+import org.springframework.util.Assert;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests loader that supports uber jars.
+ *
+ * @author Phillip Webb
+ * @author Moritz Halbritter
+ */
+@DisabledIfDockerUnavailable
+class LoaderIntegrationTests {
+
+ private final ToStringConsumer output = new ToStringConsumer();
+
+ @ParameterizedTest
+ @MethodSource("javaRuntimes")
+ void readUrlsWithoutWarning(JavaRuntime javaRuntime) {
+ try (GenericContainer container = createContainer(javaRuntime)) {
+ container.start();
+ System.out.println(this.output.toUtf8String());
+ assertThat(this.output.toUtf8String()).contains(">>>>> 287649 BYTES from")
+ .doesNotContain("WARNING:")
+ .doesNotContain("illegal")
+ .doesNotContain("jar written to temp");
+ }
+ }
+
+ private GenericContainer createContainer(JavaRuntime javaRuntime) {
+ return javaRuntime.getContainer()
+ .withLogConsumer(this.output)
+ .withCopyFileToContainer(MountableFile.forHostPath(findApplication().toPath()), "/app.jar")
+ .withStartupCheckStrategy(new OneShotStartupCheckStrategy().withTimeout(Duration.ofMinutes(5)))
+ .withCommand("java", "-jar", "app.jar");
+ }
+
+ private File findApplication() {
+ String name = String.format("build/%1$s/build/libs/%1$s.jar", "spring-boot-loader-classic-tests-app");
+ File jar = new File(name);
+ Assert.state(jar.isFile(), () -> "Could not find " + name + ". Have you built it?");
+ return jar;
+ }
+
+ static Stream javaRuntimes() {
+ List javaRuntimes = new ArrayList<>();
+ javaRuntimes.add(JavaRuntime.openJdk(JavaVersion.SEVENTEEN));
+ javaRuntimes.add(JavaRuntime.openJdk(JavaVersion.TWENTY_ONE));
+ javaRuntimes.add(JavaRuntime.oracleJdk17());
+ return javaRuntimes.stream().filter(JavaRuntime::isCompatible);
+ }
+
+ static final class JavaRuntime {
+
+ private final String name;
+
+ private final JavaVersion version;
+
+ private final Supplier> container;
+
+ private JavaRuntime(String name, JavaVersion version, Supplier> container) {
+ this.name = name;
+ this.version = version;
+ this.container = container;
+ }
+
+ private boolean isCompatible() {
+ return this.version.isEqualOrNewerThan(JavaVersion.getJavaVersion());
+ }
+
+ GenericContainer getContainer() {
+ return this.container.get();
+ }
+
+ @Override
+ public String toString() {
+ return this.name;
+ }
+
+ static JavaRuntime openJdk(JavaVersion version) {
+ String imageVersion = version.toString();
+ DockerImageName image = DockerImageName.parse("bellsoft/liberica-openjdk-debian:" + imageVersion);
+ return new JavaRuntime("OpenJDK " + imageVersion, version, () -> new GenericContainer<>(image));
+ }
+
+ static JavaRuntime oracleJdk17() {
+ String arch = System.getProperty("os.arch");
+ String dockerFile = ("aarch64".equals(arch)) ? "Dockerfile-aarch64" : "Dockerfile";
+ ImageFromDockerfile image = new ImageFromDockerfile("spring-boot-loader/oracle-jdk-17")
+ .withFileFromFile("Dockerfile", new File("src/intTest/resources/conf/oracle-jdk-17/" + dockerFile));
+ return new JavaRuntime("Oracle JDK 17", JavaVersion.SEVENTEEN, () -> new GenericContainer<>(image));
+ }
+
+ }
+
+}
diff --git a/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/resources/conf/oracle-jdk-17/Dockerfile b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/resources/conf/oracle-jdk-17/Dockerfile
new file mode 100644
index 0000000000..2a50709dc5
--- /dev/null
+++ b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/resources/conf/oracle-jdk-17/Dockerfile
@@ -0,0 +1,8 @@
+FROM ubuntu:jammy-20230624
+RUN apt-get update && \
+ apt-get install -y software-properties-common curl && \
+ mkdir -p /opt/oraclejdk && \
+ cd /opt/oraclejdk && \
+ curl -L https://download.oracle.com/java/17/latest/jdk-17_linux-x64_bin.tar.gz | tar zx --strip-components=1
+ENV JAVA_HOME /opt/oraclejdk
+ENV PATH $JAVA_HOME/bin:$PATH
diff --git a/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/resources/conf/oracle-jdk-17/Dockerfile-aarch64 b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/resources/conf/oracle-jdk-17/Dockerfile-aarch64
new file mode 100644
index 0000000000..3f8614c7a2
--- /dev/null
+++ b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/resources/conf/oracle-jdk-17/Dockerfile-aarch64
@@ -0,0 +1,8 @@
+FROM ubuntu:jammy-20230624
+RUN apt-get update && \
+ apt-get install -y software-properties-common curl && \
+ mkdir -p /opt/oraclejdk && \
+ cd /opt/oraclejdk && \
+ curl -L https://download.oracle.com/java/17/archive/jdk-17.0.8_linux-aarch64_bin.tar.gz | tar zx --strip-components=1
+ENV JAVA_HOME /opt/oraclejdk
+ENV PATH $JAVA_HOME/bin:$PATH
diff --git a/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/resources/conf/oracle-jdk-17/README.adoc b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/resources/conf/oracle-jdk-17/README.adoc
new file mode 100644
index 0000000000..28704af225
--- /dev/null
+++ b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/resources/conf/oracle-jdk-17/README.adoc
@@ -0,0 +1,5 @@
+This folder contains a Dockerfile that will create an Oracle JDK instance for use in integration tests.
+The resulting Docker image should not be published.
+
+Oracle JDK is subject to the https://www.oracle.com/downloads/licenses/no-fee-license.html["Oracle No-Fee Terms and Conditions" License (NFTC)] license.
+We are specifically using the unmodified JDK for the purposes of developing and testing.
diff --git a/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/resources/logback.xml b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/resources/logback.xml
new file mode 100644
index 0000000000..b8a41480d7
--- /dev/null
+++ b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-classic-tests/src/intTest/resources/logback.xml
@@ -0,0 +1,4 @@
+
+
+
+
diff --git a/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-tests/src/intTest/java/org/springframework/boot/loader/LoaderIntegrationTests.java b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-tests/src/intTest/java/org/springframework/boot/loader/LoaderIntegrationTests.java
index 9acac3f61d..a2d6db7c7f 100644
--- a/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-tests/src/intTest/java/org/springframework/boot/loader/LoaderIntegrationTests.java
+++ b/spring-boot-tests/spring-boot-integration-tests/spring-boot-loader-tests/src/intTest/java/org/springframework/boot/loader/LoaderIntegrationTests.java
@@ -39,7 +39,7 @@ import org.springframework.util.Assert;
import static org.assertj.core.api.Assertions.assertThat;
/**
- * Integration tests loader that supports uber jars.
+ * Integration tests loader that supports fat jars.
*
* @author Phillip Webb
* @author Moritz Halbritter
@@ -80,8 +80,9 @@ class LoaderIntegrationTests {
static Stream javaRuntimes() {
List javaRuntimes = new ArrayList<>();
javaRuntimes.add(JavaRuntime.openJdk(JavaVersion.SEVENTEEN));
- javaRuntimes.add(JavaRuntime.openJdk(JavaVersion.TWENTY_ONE));
+ javaRuntimes.add(JavaRuntime.openJdk(JavaVersion.TWENTY));
javaRuntimes.add(JavaRuntime.oracleJdk17());
+ javaRuntimes.add(JavaRuntime.openJdkEarlyAccess(JavaVersion.TWENTY_ONE));
return javaRuntimes.stream().filter(JavaRuntime::isCompatible);
}
@@ -112,6 +113,13 @@ class LoaderIntegrationTests {
return this.name;
}
+ static JavaRuntime openJdkEarlyAccess(JavaVersion version) {
+ String imageVersion = version.toString();
+ DockerImageName image = DockerImageName.parse("openjdk:%s-ea-jdk".formatted(imageVersion));
+ return new JavaRuntime("OpenJDK Early Access " + imageVersion, version,
+ () -> new GenericContainer<>(image));
+ }
+
static JavaRuntime openJdk(JavaVersion version) {
String imageVersion = version.toString();
DockerImageName image = DockerImageName.parse("bellsoft/liberica-openjdk-debian:" + imageVersion);
diff --git a/spring-boot-tests/spring-boot-smoke-tests/spring-boot-smoke-test-ant/build.gradle b/spring-boot-tests/spring-boot-smoke-tests/spring-boot-smoke-test-ant/build.gradle
index 7ff1740185..7f90497a4f 100644
--- a/spring-boot-tests/spring-boot-smoke-tests/spring-boot-smoke-test-ant/build.gradle
+++ b/spring-boot-tests/spring-boot-smoke-tests/spring-boot-smoke-test-ant/build.gradle
@@ -30,7 +30,7 @@ dependencies {
antDependencies "org.apache.ant:ant-launcher:1.10.7"
antDependencies "org.apache.ant:ant:1.10.7"
- testRepository(project(path: ":spring-boot-project:spring-boot-tools:spring-boot-loader", configuration: "mavenRepository"))
+ testRepository(project(path: ":spring-boot-project:spring-boot-tools:spring-boot-loader-classic", configuration: "mavenRepository"))
testRepository(project(path: ":spring-boot-project:spring-boot-starters:spring-boot-starter", configuration: "mavenRepository"))
testImplementation(project(path: ":spring-boot-project:spring-boot-tools:spring-boot-loader-tools"))
diff --git a/spring-boot-tests/spring-boot-smoke-tests/spring-boot-smoke-test-ant/build.xml b/spring-boot-tests/spring-boot-smoke-tests/spring-boot-smoke-test-ant/build.xml
index 091e4aa116..a03067231c 100644
--- a/spring-boot-tests/spring-boot-smoke-tests/spring-boot-smoke-test-ant/build.xml
+++ b/spring-boot-tests/spring-boot-smoke-tests/spring-boot-smoke-test-ant/build.xml
@@ -65,7 +65,7 @@
-
+
diff --git a/spring-boot-tests/spring-boot-smoke-tests/spring-boot-smoke-test-ant/ivy.xml b/spring-boot-tests/spring-boot-smoke-tests/spring-boot-smoke-test-ant/ivy.xml
index 192d5281fc..2ecb5cc31a 100644
--- a/spring-boot-tests/spring-boot-smoke-tests/spring-boot-smoke-test-ant/ivy.xml
+++ b/spring-boot-tests/spring-boot-smoke-tests/spring-boot-smoke-test-ant/ivy.xml
@@ -7,6 +7,6 @@
-
+