Why Is .headless Defaulted To True?

Question Setup

There are a few moving parts to this question, so I will try to do my best to replicate the issue in its simplest form.

I am attempting to add a TrayIcon to a SystemTray. This is typically a very simple objective on operating systems ("platforms") that support the call (this will play an integral part in a few moments).

I am programming for and on a Windows machine, presently (this is not a question about interoperability).

Here's the logic behind the code I've got that works:

public class SomeClass {

    public static void main(String[] args) {

        if(SystemTray.isSupported()) {
            // DO SOMETHING TO ADD AN ICON
        }
    }
}

With all of its inclusions, this works. However, what I am really after, is the ability to inject the SystemTray instance with it's icon already "ready to go".

That code looks something a little more like this:

public class SomeClass extends NecessarySpringExtension {
    private @Setter(onMethod=@_@Resource(name="SystemTrayControl"))) SystemTrayControl systemTrayControl;
    // The above uses Lombok, as well.

    public static void main(String[] args) {
        // DO SOME RELATED STUFF like setting the configurations for
        // for the application
    }
}

The resource returns an instance (@Bean) of the SystemTrayControl class which, itself, makes a call to SystemTray; however, now, SystemTray is no longer supported (see some explanation in the The Question section, below).

Some Change Detail

Here's a snippet of some of that code (obviously, I've got my head submerged in the issue. Let me know if the context needs expanding. My belief is the following should be enough code to give you a sense of the structure):

SystemTrayControl Class:

@PostConstruct
    public void showIcon() {

        if (SystemTray.isSupported()) {
            val tray = SystemTray.getSystemTray(); ....

Resource Class:

@Configuration
public class BeansForNeeds {

    @Bean
    public SystemTrayControl systemTrayControl() {
        return new SystemTrayControl():
    } ....

For the sake of more context: if I remove the condition seen in the SystemTrayControl class , I get a HeadlessException (which I've done a bit of reading on).

The Question

The issue stems from that fact that when utilizing a SpringApplicationBuilder in your program, the .headless property defaults to true. The javadoc states:

Sets if the application is headless and should not instantiate AWT. Defaults to true to prevent java icons appearing

If I manually set the property to false, then the application runs well; however, I am always a bit "shaky" overwriting default behavior, particular if the language of "prevents" x, y, or z makes into the mix.

So, the question is:

Why is the property defaulted to true? What are the side effects of allowing the behavior prohibited by .headless? What's it got against AWT?