Spring Boot @ConditionalOnWebApplication Example

1. Introduction

The @ConditionalOnWebApplication annotation is used to conditionally apply configurations only when the application is a web application. This is useful when you have configurations that should only be activated in a web context, such as controllers, view resolvers, or web-specific beans. Let's explore this annotation through a practical example.

Key Points:

1. @ConditionalOnWebApplication is used to conditionally enable beans only when the application is running in a web environment.

2. It helps in creating auto-configuration that's specific to web applications without impacting standalone applications.

3. The annotation can specify whether the condition should apply to a servlet-based web application or a reactive web application.

4. It's typically used in @Configuration classes inside auto-configure modules.

5. This conditional is evaluated in the auto-configuration phase of Spring Boot's startup process.

2. Implementation Steps

1. Define a bean that should only be loaded in a web application context.

2. Create a configuration class and use the @ConditionalOnWebApplication annotation on the bean.

3. Develop a Spring Boot application with web capabilities to demonstrate the configuration.

4. Run the application and observe that the bean is only created in a web application context.

3. Implementation Example

// Step 1: Create a web-specific bean, for instance, a controller or a configuration for web MVC
@RestController
class HelloController {
    @GetMapping("/")
    public String hello() {
        return "Hello, Web World!";
    }
}

// Step 2: Create a configuration class that declares the web-specific beans
@Configuration
public class WebAppConfig {

    // This bean will only be created if the application is a web application
    @Bean
    @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
    public HelloController helloController() {
        return new HelloController();
    }
}

// Step 3: Build the main application class with web capabilities
@SpringBootApplication
public class WebApplicationExample {

    public static void main(String[] args) {
        SpringApplication.run(WebApplicationExample.class, args);
    }
}

Output:

// When accessing the root URL of the web application, the output will be:
Hello, Web World!

Explanation:

1. HelloController: A simple REST controller that is part of the web layer and should only be available in a web application context.

2. @ConditionalOnWebApplication: This annotation ensures that the helloController bean is only created if the application is running as a web application, specifically a servlet-based one.

3. type = ConditionalOnWebApplication.Type.SERVLET: Specifies that the condition should only apply to servlet-based web applications.

4. WebAppConfig: A configuration class that declares a bean with the @ConditionalOnWebApplication annotation.

5. @Configuration: Marks the class as a source of bean definitions.

6. @SpringBootApplication: Used to mark the main application class, which triggers auto-configuration, component scanning, and, in this case, starts up a web application context.

7. SpringApplication.run(): Boots the Spring Boot application, which in this case will start up with web capabilities due to the presence of embedded servlet container dependencies (like Tomcat).