fix: respect spring.devtools.livereload.enabled property (#22624)

When developers set spring.devtools.livereload.enabled=false,
the application should not attempt to establish a WebSocket
connection to the Spring Boot livereload server.

This commit fixes the issue by checking the enabled property
at the source (SpringDevToolsPortHandler) and propagating the
result through the entire chain:

- SpringDevToolsPortHandler: Only assigns port if livereload enabled
- IndexHtmlRequestHandler: Only includes liveReloadPort in config if set
- vaadin-dev-tools.ts: Only creates WebSocket connection if port exists

Fixes #22623

Author: Artur-

flow-server/src/main/java/com/vaadin/flow/server/communication/IndexHtmlRequestHandler.java

@@ -396,7 +396,7 @@ private void addDevTools(Document indexDocument,
         Optional<Backend> maybeBackend = liveReload
                 .map(BrowserLiveReload::getBackend);
 
-        int liveReloadPort = Constants.SPRING_BOOT_DEFAULT_LIVE_RELOAD_PORT;
+        Integer liveReloadPort = null;
         VaadinContext context = service.getContext();
         if (context instanceof VaadinServletContext vaadinServletContext) {
             String customPort = (String) vaadinServletContext.getContext()
@@ -412,7 +412,9 @@ private void addDevTools(Document indexDocument,
                 BootstrapHandlerHelper.getPushURL(session, request));
         maybeBackend.ifPresent(
                 backend -> devToolsConf.put("backend", backend.toString()));
-        devToolsConf.put("liveReloadPort", liveReloadPort);
+        if (liveReloadPort != null) {
+            devToolsConf.put("liveReloadPort", liveReloadPort);
+        }
         if (isAllowedDevToolsHost(config, request)) {
             devToolsConf.put("token", DevToolsToken.getToken());
         }

vaadin-dev-server/src/main/frontend/vaadin-dev-tools.ts

@@ -82,7 +82,7 @@ type DevToolsConf = {
   enable: boolean;
   url: string;
   backend?: string;
-  liveReloadPort: number;
+  liveReloadPort?: number;
   token?: string;
 };
 
@@ -722,7 +722,7 @@ export class VaadinDevTools extends LitElement {
     frontendConnection.onMessage = (message: any) => this.handleFrontendMessage(message);
     this.frontendConnection = frontendConnection;
 
-    if (this.conf.backend === VaadinDevTools.SPRING_BOOT_DEVTOOLS) {
+    if (this.conf.backend === VaadinDevTools.SPRING_BOOT_DEVTOOLS && this.conf.liveReloadPort) {
       this.javaConnection = new LiveReloadConnection(this.getSpringBootWebSocketUrl(window.location));
       this.javaConnection.onHandshake = () => {
         if (!VaadinDevTools.isActive) {

vaadin-spring/src/main/java/com/vaadin/flow/spring/SpringDevToolsPortHandler.java

@@ -20,21 +20,31 @@
 import org.springframework.core.env.ConfigurableEnvironment;
 
 import com.vaadin.flow.internal.NetworkUtil;
+import com.vaadin.flow.server.Constants;
 
 /**
  * Sets Spring Boot dev tools to run on a free random port if the default port
- * (35729) is in use.
+ * is in use.
  */
 public class SpringDevToolsPortHandler implements EnvironmentPostProcessor {
 
     private static final String SPRING_DEVTOOLS_LIVERELOAD_PORT = "spring.devtools.livereload.port";
-    private static final int DEFAULT_PORT = 35729;
+    private static final String SPRING_DEVTOOLS_LIVERELOAD_ENABLED = "spring.devtools.livereload.enabled";
 
     @Override
     public void postProcessEnvironment(ConfigurableEnvironment environment,
             SpringApplication application) {
+        // Only set the port if livereload is enabled (defaults to true when
+        // DevTools is present)
+        boolean liveReloadEnabled = environment.getProperty(
+                SPRING_DEVTOOLS_LIVERELOAD_ENABLED, Boolean.class, true);
+
+        if (!liveReloadEnabled) {
+            return;
+        }
+
         if (environment.getProperty(SPRING_DEVTOOLS_LIVERELOAD_PORT) == null) {
-            int reloadPort = DEFAULT_PORT;
+            int reloadPort = Constants.SPRING_BOOT_DEFAULT_LIVE_RELOAD_PORT;
             if (!NetworkUtil.isFreePort(reloadPort)) {
                 reloadPort = NetworkUtil.getFreePort();
             }

vaadin-spring/src/test/java/com/vaadin/flow/spring/SpringDevToolsPortHandlerTest.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2000-2025 Vaadin Ltd.
+ *
+ * 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
+ *
+ * http://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 com.vaadin.flow.spring;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.springframework.boot.SpringApplication;
+import org.springframework.core.env.ConfigurableEnvironment;
+
+public class SpringDevToolsPortHandlerTest {
+
+    private SpringDevToolsPortHandler handler;
+    private ConfigurableEnvironment environment;
+    private SpringApplication application;
+
+    @Before
+    public void setUp() {
+        handler = new SpringDevToolsPortHandler();
+        environment = Mockito.mock(ConfigurableEnvironment.class);
+        application = Mockito.mock(SpringApplication.class);
+    }
+
+    @Test
+    public void liveReloadEnabled_portIsAssigned() {
+        // Arrange: livereload enabled (default), no port set
+        Mockito.when(environment.getProperty(
+                "spring.devtools.livereload.enabled", Boolean.class, true))
+                .thenReturn(true);
+        Mockito.when(environment.getProperty("spring.devtools.livereload.port"))
+                .thenReturn(null);
+
+        // Act
+        handler.postProcessEnvironment(environment, application);
+
+        // Assert: port should be set via System.setProperty
+        String portProperty = System
+                .getProperty("spring.devtools.livereload.port");
+        Assert.assertNotNull("Port should be set when livereload is enabled",
+                portProperty);
+
+        // Verify it's a valid port number
+        int port = Integer.parseInt(portProperty);
+        Assert.assertTrue("Port should be positive", port > 0);
+        Assert.assertTrue("Port should be in valid range", port <= 65535);
+
+        // Clean up
+        System.clearProperty("spring.devtools.livereload.port");
+    }
+
+    @Test
+    public void liveReloadDisabled_portIsNotAssigned() {
+        // Arrange: livereload explicitly disabled, no port set
+        Mockito.when(environment.getProperty(
+                "spring.devtools.livereload.enabled", Boolean.class, true))
+                .thenReturn(false);
+        Mockito.when(environment.getProperty("spring.devtools.livereload.port"))
+                .thenReturn(null);
+
+        // Clear any previously set system property
+        System.clearProperty("spring.devtools.livereload.port");
+
+        // Act
+        handler.postProcessEnvironment(environment, application);
+
+        // Assert: port should NOT be set
+        String portProperty = System
+                .getProperty("spring.devtools.livereload.port");
+        Assert.assertNull("Port should not be set when livereload is disabled",
+                portProperty);
+    }
+}