Introduction

If Spring Boot tests are printing noisy shutdown-hook output at JVM exit, the usual cause is that the application was started in a way that registered a JVM shutdown hook and left cleanup to process termination. The clean fix is not to hide the logs first. It is to avoid relying on the shutdown hook during tests and close the application context explicitly.

Why The Output Appears

Spring Boot can register a shutdown hook so the application context closes when the JVM exits. That is useful in a real application process, but in tests it often creates extra log lines when Gradle tears down the test JVM.

A common manual startup pattern looks like this:

1import org.springframework.boot.SpringApplication;
2import org.springframework.context.ConfigurableApplicationContext;
3
4public class Demo {
5    public static void main(String[] args) {
6        ConfigurableApplicationContext context = SpringApplication.run(Demo.class, args);
7    }
8}

If the test starts an application this way and never closes the context, the shutdown hook does the cleanup later, and that cleanup can write to the test logs.

Disable The Shutdown Hook For Test Startup

If you are creating the application manually in a test, disable the hook and close the context yourself.

1import org.junit.jupiter.api.AfterEach;
2import org.junit.jupiter.api.Test;
3import org.springframework.boot.SpringApplication;
4import org.springframework.context.ConfigurableApplicationContext;
5
6class BootTest {
7    private ConfigurableApplicationContext context;
8
9    @Test
10    void startsApplicationWithoutJvmShutdownHookNoise() {
11        SpringApplication app = new SpringApplication(TestApplication.class);
12        app.setRegisterShutdownHook(false);
13
14        context = app.run();
15    }
16
17    @AfterEach
18    void tearDown() {
19        if (context != null) {
20            context.close();
21        }
22    }
23}

This is usually the most direct fix. The context is shut down under test control, so there is no delayed shutdown-hook activity when Gradle exits the JVM.

The same idea works with SpringApplicationBuilder.

1import org.springframework.boot.builder.SpringApplicationBuilder;
2import org.springframework.context.ConfigurableApplicationContext;
3
4ConfigurableApplicationContext context =
5    new SpringApplicationBuilder(TestApplication.class)
6        .registerShutdownHook(false)
7        .run();

Prefer Test Framework Lifecycle Over JVM Exit

If you are already using @SpringBootTest, Spring's test support usually manages application context lifecycle for you. In that setup, extra shutdown-hook output often points to code that starts additional contexts manually or spawns background resources that are not closed during the test.

A better test design is:

• let the test framework create the context
• avoid calling SpringApplication.run(...) inside test methods
• close any extra resources explicitly in test teardown

The less your test depends on JVM shutdown, the cleaner and more predictable Gradle output becomes.

Logging Is A Separate Concern

If the shutdown itself is correct but the logs are too verbose, adjust logging levels rather than redirecting System.out blindly.

For example, in src/test/resources/application.properties:

logging.level.org.springframework=ERROR
logging.level.org.springframework.boot=ERROR

This can reduce noise, but it should not be the first fix if a shutdown hook is firing only because the test never closed a context properly.

Gradle test logging can also be narrowed.

1test {
2    testLogging {
3        events "failed", "skipped"
4        showStandardStreams = false
5    }
6}

That hides standard output streams, but again, it is better to fix the lifecycle first.

Common Pitfalls

A common mistake is trying to suppress the log output without addressing why the shutdown hook is running in the test JVM. If the application context is being left open, the shutdown hook is only a symptom.

Another mistake is calling SpringApplication.run(...) directly inside tests that already use Spring test support. That creates overlapping lifecycle management and often leaves extra contexts around.

Developers also sometimes redirect System.out and System.err globally, which can hide legitimate test diagnostics along with the unwanted output.

Finally, do not disable the shutdown hook in production code just because the test logs are noisy. This is usually a test-lifecycle problem, not an application-runtime problem.

Summary

• Shutdown-hook output in Gradle tests usually means cleanup is happening at JVM exit.
• In manually started test applications, call setRegisterShutdownHook(false) and close the context explicitly.
• Prefer Spring test lifecycle management over manual SpringApplication.run(...) in tests.
• Use logging configuration to reduce noise only after lifecycle is correct.
• Avoid global stdout redirection unless there is no cleaner option.
• Fix the cause of the hook activity instead of only hiding its output.