ENGLISH | 中文

• 🤩Highlight
  • 📈Spring Startup Analysis Report
  • 🚀Optimization of Spring Startup
• 🧭How to Use
  • 📈Spring Startup Data Collection
    • Installation
    • Configuration
    • Application Startup
    • Custom extension
  • 🚀Optimization of Spring Startup
    • Types of Bean for Async
    • Usage

Spring Startup Analyzer generates an interactive Spring application startup report that lets you understand what contributes to the application startup time and helps to optimize it.

analyzer report demo

Spring Bean Initialization Details support for initialization time/beanName search, Spring Bean Initialization Timeline, Method Invocation Count and Time Statistics(support for custom methods), Unused Jars(to help optimize fat jars), and Application Startup Thread Wall Clock Profile, helping developers quickly analyze and locate application startup bottlenecks. Support for linux/mac/windows. UI referenced UI referenced spring-boot-startup-report.

• Spring Bean Initialization Details

• Spring Bean Initialization Timeline

• Method Invocation Count and Time Statistics

• Unused Jars

• Application Startup Thread Wall Clock Profile

Provide a Spring Bean asynchronous initialization jar package, which asynchronously executes the init and @PostConstruct methods for beans with longer initialization time to improve application startup speed.

Provides two installation methods: manual installation and one-click script installation.

1. Manual Installation

1. Click realease to download the latest version tar.gz package

2. Create a new folder and extract the files

For Linux/Mac systems, you may consider utilizing the following commands:

mkdir -p ${HOME}/spring-startup-analyzer
cd download_path
tar -zxvf spring-startup-analyzer.tar.gz -C your_install_path/spring-startup-analyzer

2. Shell script installation(Only for Linux/Mac)

curl -sS https://raw.githubusercontent.com/linyimin0812/spring-startup-analyzer/main/bin/install.sh | sh

Default install directory: $HOME/spring-startup-analyzer

This project provides several configuration options, which are not mandatory and can be used with default settings.

Two ways to configure:

1. Directly configure in the configuration file: your_install_path/spring-startup-analyzer/config/spring-startup-analyzer.properties
2. Configure through startup parameters, for example, set the application startup health check timeout to 30 minutes: -Dspring-startup-analyzer.app.health.check.timeout=30

The criteria for determining a successful application startup are as follows:

1. Bytecode enhancement on the SpringApplication.run method, considering the application startup complete upon method exit (only applicable to Spring Boot applications).
2. Polling the URL for health check requests, considering the startup complete upon receiving a 200 response (applicable to all Spring applications).
3. If neither of the above two methods succeeds, considering the application startup complete after exceeding the application startup health check timeout.

For non-Spring Boot applications, it is necessary to configure the health check URL using spring-startup-analyzer.app.health.check.endpoints.

This project is started as an agent, so you can add the parameter -javaagent:your_install_path/spring-startup-analyzer/lib/spring-profiler-agent.jar to the startup command.

• To start the application using the Java command line, you would add parameters in the command line, for example:

java -javaagent:/Users/runner/spring-startup-analyzer/lib/spring-profiler-agent.jar \
    -Dproject.name=mac-demo \
    -Dspring-startup-analyzer.admin.http.server.port=8066 \
    -jar /Users/runner/spring-startup-analyzer/spring-boot-demo.jar

• If you want to launch in IDEA, you need to add the following in the VM options:

Path of logs：$HOME/spring-startup-analyzer/logs

• startup.log: log of startup
• transform.log: log of re-transform class

After the application has finished starting, the message ======= spring-startup-analyzer finished, click http://localhost:xxxx to visit details. ====== will be printed in the console and startup.log file. You can use this output to determine if the profiling has completed successfully

Translation: If you want to customize the profiling capabilities, you need to include the spring-profiler-starter pom as the parent pom for your extension project. Then, you can use the interfaces exposed by the project for extension purposes. For more details, you can refer to the implementation ofspring-profiler-extension

<parent>
    <groupId>io.github.linyimin0812</groupId>
    <artifactId>spring-profiler-starter</artifactId>
    <version>latest_version</version>
</parent>

public interface EventListener extends Startable {

    /**
     * Invocation during application startup
     */
    void start();

    /**
     * Invocation after application startup completion
     */
    void stop();
    
    /**
     * class need to be enhance
     * @param className

     * @return true: enhance, false: not enhance
     */
    boolean filter(String className);

    /**
     * Methods to be enhanced (This method relies on the filter(className) condition. It will only be executed if filter(className) returns true.)
     * @param methodName
     * @param methodTypes
     * @return true: enhance, false: not enhance
     */
    default boolean filter(String methodName, String[] methodTypes) {
        return true;
    }

    /**
     * Event response processing logic
     * @param event fire  event
     */
    void onEvent(Event event);

    /**
     * events to listen
     * @return events need to be listened
     */
    List<Event.Type> listen();

}

The start() and stop() methods represent the lifecycle of the system, called respectively at the beginning and completion of application startup. The filter() method specifies the classes/methods that need to be enhanced. The listen() method specifies the events to listen for, including method enter and method return events. The onEvent() method is called when the listened events occur.

For example, the following is an extension that counts the number of invocations of the java.net.URLClassLoader.findResource(String) method during the application startup process:

@MetaInfServices
public class FindResourceCounter implements EventListener {

    private final AtomicLong COUNT = new AtomicLong(0);

    @Override
    public boolean filter(String className) {
        return "java.net.URLClassLoader".equals(className);
    }

    @Override
    public boolean filter(String methodName, String[] methodTypes) {
       if (!"findResource".equals(methodName)) {
           return false;
       }

       return methodTypes != null && methodTypes.length == 1 && "java.lang.String".equals(methodTypes[0]);
    }

    @Override
    public void onEvent(Event event) {
        if (event instanceof AtEnterEvent) {
            // enter findResource method
        } else if (event instanceof AtExitEvent) {
            // findResource return
        }

        //  counts the number of invocations
        COUNT.incrementAndGet();

    }

    @Override
    public List<Event.Type> listen() {
        return Arrays.asList(Event.Type.AT_ENTER, Event.Type.AT_EXIT);
    }

    @Override
    public void start() {
        System.out.println("============== my extension start =============");
    }

    @Override
    public void stop() {
        System.out.println("============== my extension end =============");
        System.out.println("findResource count: " + COUNT.get());
    }
}

It is important to note that the implementation of the EventListener interface should be annotated with @MetaInfServices. This is because the extension interface is loaded through the Service Provider Interface (SPI). When you use the @MetaInfServices annotation, the implementation class will be automatically written to the META-INF/services/io.github.linyimin0812.profiler.api.EventListener file during the code compilation process. If you don't use the @MetaInfServices annotation, you need to manually write the fully qualified name of the implementation class into the META-INF/services/io.github.linyimin0812.profiler.api.EventListener file`. Otherwise, the extension implementation will not be loaded.

The spring-profiler-starter pom already defines a packaging plugin that will by default copy the generated JAR file to the $HOME/spring-startup-analyzer/extension directory.

mvn clean package

Once you have installed this project by following the steps in the Installation section, you can execute the packaging command mentioned above. After the packaging is complete, you can start the application as described in the Application Startup section to load the extension JAR file.

From the Application startup data collectionsection, you can obtain the Beans that have long initialization time. Since the Spring startup process is single-threaded, to optimize the application startup time, you can consider making the initialization methods of these time-consuming Beans asynchronous.

NOTE:

• It is advisable to prioritize optimizing the code of Beans to fundamentally address the issue of long initialization time
• For Beans with long initialization time in second-party or third-party packages (where code optimization is not possible), consider asynchronous initialization of those Beans.
• For Beans that are not dependent on other Beans, you can confidently proceed with asynchronous initialization，You can determine if a Bean is dependent on other Beans by examining the Root Bean in Loading time of Beans session
• Careful analysis is required for Beans that are dependent on other Beans. They should not be called by other Beans during the application startup process, as it may lead to issues

Supports initialization of beans through @Bean, @PostConstruct, and @ImportResource. demo: spring-boot-async-bean-demo

1. Bean annotated with @Bean(initMethod = "init")

@Bean(initMethod = "init")
public TestBean testBean() {
    return new TestBean();
}

2. Bean annotated with @PostConstruct

@Component
public class TestComponent {
    @PostConstruct
    public void init() throws InterruptedException {
        Thread.sleep(20 * 1000);
    }
}

1. Import Dependency

<dependency>
    <groupId>io.github.linyimin0812</groupId>
    <artifactId>spring-async-bean-starter</artifactId>
    <version>${latest_version}</version>
</dependency>

2. Configuration

# Asynchronous beans may be at the end of the Spring bean initialization order, which may result in suboptimal effects of asynchronous optimization. Open the configuration to prioritize loading asynchronous beans.
spring-startup-analyzer.boost.spring.async.bean-priority-load-enable=true
# name of bean to async init
spring-startup-analyzer.boost.spring.async.bean-names=testBean,testComponent
# init bean thread pool core size
spring-startup-analyzer.boost.spring.async.init-bean-thread-pool-core-size=8
# init bean thread pool max size
spring-startup-analyzer.boost.spring.async.init-bean-thread-pool-max-size=8

3. Check if the bean is initialized asynchronously

View the log in the $HOME/spring-startup-analyzer/logs/startup.log file. For asynchronously initialized methods, a log entry will be written in the following format:

async-init-bean, beanName: ${beanName}, async init method: ${initMethodName}