or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

build-integration.mdimage-packaging.mdindex.mdjar-writing.mdlaunch-scripts.mdlayer-support.mdlayout-management.mdlibrary-management.mdmain-class-detection.mdrepackaging.md
tile.json

tessl/maven-org-springframework-boot--spring-boot-loader-tools

Tools for generating executable JAR/WAR files with embedded containers for Spring Boot applications

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.springframework.boot/spring-boot-loader-tools@3.5.x

To install, run

npx @tessl/cli install tessl/maven-org-springframework-boot--spring-boot-loader-tools@3.5.0

index.mddocs/

Spring Boot Loader Tools

A comprehensive Java library that provides essential tools and utilities for packaging Spring Boot applications into executable JAR and WAR files. The library includes classes for JAR writing, entry management, layout configuration, library handling, and loader implementation that enable the creation of self-contained, executable archives with embedded containers.

Package Information

  • Package Name: org.springframework.boot:spring-boot-loader-tools
  • Language: Java
  • Package Type: Maven
  • Installation: 
    <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-loader-tools</artifactId>
  <version>3.5.3</version>
</dependency>

Gradle:

implementation 'org.springframework.boot:spring-boot-loader-tools:3.5.3'

Core Imports

import org.springframework.boot.loader.tools.Repackager;
import org.springframework.boot.loader.tools.Libraries;
import org.springframework.boot.loader.tools.Library;
import org.springframework.boot.loader.tools.LibraryScope;

For specific functionality:

import org.springframework.boot.loader.tools.MainClassFinder;
import org.springframework.boot.loader.tools.Layout;
import org.springframework.boot.loader.tools.Layouts;
import org.springframework.boot.loader.tools.JarWriter;
import org.springframework.boot.loader.tools.ImagePackager;
import org.springframework.boot.loader.tools.BuildPropertiesWriter;
import java.nio.file.attribute.FileTime;
import java.time.Instant;

Basic Usage

import org.springframework.boot.loader.tools.Repackager;
import org.springframework.boot.loader.tools.Libraries;
import org.springframework.boot.loader.tools.Library;
import org.springframework.boot.loader.tools.LibraryScope;
import java.io.File;
import java.io.IOException;

// Basic repackaging of a JAR file
File sourceJar = new File("myapp.jar");
Repackager repackager = new Repackager(sourceJar);

// Define libraries to include
Libraries libraries = new Libraries() {
    @Override
    public void doWithLibraries(LibraryCallback callback) throws IOException {
        // Add runtime dependencies
        callback.library(new Library(new File("lib/spring-core.jar"), LibraryScope.COMPILE));
        callback.library(new Library(new File("lib/logback-classic.jar"), LibraryScope.RUNTIME));
    }
};

// Repackage into executable JAR
repackager.repackage(libraries);

Architecture

The Spring Boot Loader Tools library is built around several key architectural components:

  • Repackager: Main entry point that orchestrates the repackaging process
  • Layout System: Defines where classes and libraries are placed in the archive (JAR, WAR, expanded)
  • Library Management: Handles dependency libraries with scope and coordinate tracking
  • JAR Writers: Low-level classes for writing JAR file entries and managing archive structure
  • Layer Support: Enables Docker image optimization through strategic content layering
  • Loader Implementation: Provides the runtime loader classes that enable executable JARs

This design supports Spring Boot's "fat JAR" packaging model, allowing applications to run with java -jar while maintaining all necessary dependencies and configuration within a single executable file.

Capabilities

JAR/WAR Repackaging

Core functionality for transforming regular JAR/WAR files into executable Spring Boot archives. Handles main class detection, library inclusion, manifest generation, and loader class integration.

public class Repackager {
    public Repackager(File source);
    public void repackage(Libraries libraries) throws IOException;
    public void repackage(File destination, Libraries libraries) throws IOException;
    public void repackage(File destination, Libraries libraries, LaunchScript launchScript) throws IOException;
    public void repackage(File destination, Libraries libraries, LaunchScript launchScript, FileTime lastModifiedTime) throws IOException;
    public void setBackupSource(boolean backupSource);
}

Repackaging

Main Class Detection

Automatic discovery of classes with public static main methods using breadth-first search. Supports both directory and JAR file analysis with annotation-based filtering.

public abstract class MainClassFinder {
    public static String findMainClass(File rootDirectory) throws IOException;
    public static String findSingleMainClass(File rootDirectory) throws IOException;
    public static String findSingleMainClass(File rootDirectory, String annotationName) throws IOException;
    public static String findMainClass(JarFile jarFile, String classesLocation) throws IOException;
    public static String findSingleMainClass(JarFile jarFile, String classesLocation) throws IOException;
    public static String findSingleMainClass(JarFile jarFile, String classesLocation, String annotationName) throws IOException;
}

Main Class Detection

Archive Layout Management

Strategy-based system for determining how classes and libraries are organized within different archive types. Supports JAR, WAR, and expanded directory layouts with customization options.

public interface Layout {
    String getLauncherClassName();
    String getLibraryLocation(String libraryName, LibraryScope scope);
    String getClassesLocation();
    boolean isExecutable();
}

public final class Layouts {
    public static Layout forFile(File file);
    public static class Jar implements RepackagingLayout { }
    public static class War implements Layout { }
}

Layout Management

Library Management

Comprehensive system for handling dependency libraries including scope classification, coordinate tracking, and inclusion/exclusion logic. Integrates with build tools and dependency resolution.

public class Library {
    public Library(File file, LibraryScope scope);
    public String getName();
    public LibraryScope getScope();
    public LibraryCoordinates getCoordinates();
}

public interface Libraries {
    void doWithLibraries(LibraryCallback callback) throws IOException;
}

Library Management

JAR Writing and Entry Management

Low-level utilities for writing JAR files with proper directory structure, duplicate handling, manifest generation, and nested library support.

public class JarWriter implements AutoCloseable {
    public JarWriter(File file) throws FileNotFoundException, IOException;
    public JarWriter(File file, LaunchScript launchScript) throws FileNotFoundException, IOException;
    public JarWriter(File file, LaunchScript launchScript, FileTime lastModifiedTime) throws FileNotFoundException, IOException;
    public void close() throws IOException;
}

public abstract class AbstractJarWriter implements LoaderClassesWriter {
    public void writeManifest(Manifest manifest) throws IOException;
    public void writeEntry(String entryName, InputStream inputStream) throws IOException;
    public void writeNestedLibrary(String location, Library library) throws IOException;
}

JAR Writing

Layer Support for Docker Optimization

Advanced layering system for optimizing Docker image builds by strategically separating application code, dependencies, and Spring Boot loader components into distinct layers.

public class Layer {
    public Layer(String name);
}

public interface Layers extends Iterable<Layer> {
    Layer getLayer(String applicationResource);
    Layer getLayer(Library library);
}

public abstract class StandardLayers implements Layers {
    public static final Layer DEPENDENCIES;
    public static final Layer SPRING_BOOT_LOADER;
    public static final Layer SNAPSHOT_DEPENDENCIES;
    public static final Layer APPLICATION;
}

Layer Support

Launch Script Generation

Tools for creating launch scripts that make JAR files directly executable on Unix-like systems, supporting customizable script templates and property substitution.

public interface LaunchScript {
    byte[] toByteArray();
}

public class DefaultLaunchScript implements LaunchScript {
    public DefaultLaunchScript(File file, Map<?, ?> properties) throws IOException;
}

Launch Scripts

Build Integration

Utilities for integrating with build tools and generating build metadata for Spring Boot Actuator endpoints, including project details and build information.

public final class BuildPropertiesWriter {
    public BuildPropertiesWriter(File outputFile);
    public void writeBuildProperties(ProjectDetails projectDetails) throws IOException;
    
    public static final class ProjectDetails {
        public ProjectDetails(String group, String artifact, String version, String name, Instant time, Map<String, String> additionalProperties);
        public String getGroup();
        public String getArtifact();
        public String getName();
        public String getVersion();
        public Instant getTime();
        public Map<String, String> getAdditionalProperties();
    }
    
    public static class NullAdditionalPropertyValueException extends IllegalArgumentException {
        public NullAdditionalPropertyValueException(String name);
    }
}

Build Integration

OCI Image Packaging

Specialized packager for exporting fully packaged archives to OCI (Open Container Initiative) images. Designed for Docker integration and container deployment workflows.

public class ImagePackager extends Packager {
    public ImagePackager(File source, File backupFile);
    public void packageImage(Libraries libraries, BiConsumer<ZipEntry, EntryWriter> exporter) throws IOException;
}

Image Packaging

Core Types

public interface LibraryScope {
    LibraryScope COMPILE = /* ... */;
    LibraryScope RUNTIME = /* ... */;
    LibraryScope PROVIDED = /* ... */;
    LibraryScope CUSTOM = /* ... */;
}

public interface LibraryCoordinates {
    String getGroupId();
    String getArtifactId();
    String getVersion();
    static LibraryCoordinates of(String groupId, String artifactId, String version);
}

public interface LibraryCallback {
    void library(Library library) throws IOException;
}

public enum LoaderImplementation {
    DEFAULT, CLASSIC;
    String getJarResourceName();
}

public interface EntryWriter {
    void write(OutputStream outputStream) throws IOException;
    default int size() { return -1; }
}