
- Spring Boot - Home
- Spring Boot - Introduction
- Spring Boot - Quick Start
- Spring Boot - Bootstrapping
- Spring Tool Suite
- Spring Boot - Tomcat Deployment
- Spring Boot - Build Systems
- Spring Boot - Code Structure
- Spring Beans & Dependency Injection
- Spring Boot - Runners
- Spring Boot - Starters
- Spring Boot - Application Properties
- Spring Boot - Configuration
- Spring Boot - Annotations
- Spring Boot - Logging
- Building RESTful Web Services
- Spring Boot - Exception Handling
- Spring Boot - Interceptor
- Spring Boot - Servlet Filter
- Spring Boot - Tomcat Port Number
- Spring Boot - Rest Template
- Spring Boot - File Handling
- Spring Boot - Service Components
- Spring Boot - Thymeleaf
- Consuming RESTful Web Services
- Spring Boot - CORS Support
- Spring Boot - Internationalization
- Spring Boot - Scheduling
- Spring Boot - Enabling HTTPS
- Spring Boot - Eureka Server
- Service Registration with Eureka
- Gateway Proxy Server and Routing
- Spring Cloud Configuration Server
- Spring Cloud Configuration Client
- Spring Boot - Actuator
- Spring Boot - Admin Server
- Spring Boot - Admin Client
- Spring Boot - Enabling Swagger2
- Spring Boot - Using SpringDoc OpenAPI
- Spring Boot - Creating Docker Image
- Tracing Micro Service Logs
- Spring Boot - Flyway Database
- Spring Boot - Sending Email
- Spring Boot - Hystrix
- Spring Boot - Web Socket
- Spring Boot - Batch Service
- Spring Boot - Apache Kafka
- Spring Boot - Twilio
- Spring Boot - Unit Test Cases
- Rest Controller Unit Test
- Spring Boot - Database Handling
- Securing Web Applications
- Spring Boot - OAuth2 with JWT
- Spring Boot - Google Cloud Platform
- Spring Boot - Google OAuth2 Sign-In
Spring Boot Configuration/Autoconfiguration
This chapter will discuss in detail about Spring Boot configuration and auto-configuration.
Spring Boot Configuration
Although a Spring/Spring Boot application can be configured in an XML document, it is generally recommended to configure Spring Boot applications with a single file with @Configuration annotation.
Different kinds of annotation
@Component Annotation
In Spring Boot, the @Component annotation declares a class as a Spring component. This signals to Spring that the class should be managed by the Spring container, meaning it will be automatically created, initialized, and potentially injected into other components.
Example
import org.springframework.stereotype.Component; @Component public class Utility { ... }
@Configuration Annotation
In Spring Boot, the @Configuration annotation is used to indicate that a class is a source of bean definitions. It's a core annotation from the Spring Framework, not specific to Spring Boot. Classes marked with @Configuration can define beans using the @Bean annotation on methods within the class. These beans are then managed by the Spring container. @Configuration promotes a Java-based configuration approach instead of relying solely on XML configuration files.
Example
@Configuration public class AppConfig { @Bean public MyService myService() { return new MyServiceImpl(); } }
@SpringBootApplication Annotation
This is a meta-annotation that combines @EnableAutoConfiguration, @ComponentScan, and @Configuration. It's often the only annotation you need to bootstrap a Spring Boot application.
Example
import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.ComponentScan; @SpringBootApplication public class MyApplication { public static void main(String[] args) { SpringApplication.run(MyApplication.class, args); } }
@ComponentScan Annotation
In Spring Boot, the @ComponentScan annotation is used to instruct Spring to scan the specified packages and their sub-packages for components (classes annotated with @Component, @Service, @Repository, @Controller, etc.) and register them as beans in the Spring application context. By default, if you don't explicitly use @ComponentScan, Spring Boot automatically scans the package where your main application class resides and its sub-packages. If your components are in a different package structure, you can use basePackages attribute of @ComponentScan to specify the packages to scan. You can specify multiple packages using an array in basePackages, e.g.,
basePackages = {"com.example.package1", "com.example.package2"}
Example
import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.ComponentScan; @SpringBootApplication @ComponentScan(basePackages = {"com.example.mypackage"}) public class MyApplication { public static void main(String[] args) { SpringApplication.run(MyApplication.class, args); } }
What is Spring Boot Autoconfiguration?
Spring Boot Autoconfiguration is a feature that automatically configures your Spring application based on the dependencies present on the classpath and various properties settings. This eliminates the need for a lot of manual configuration, making Spring Boot applications easier to set up and maintain.
@SpringBootApplication or @EnableAutoConfiguration Annotation
These annotations trigger the autoconfiguration process. Typically, you annotate your main application class with @SpringBootApplication, which includes @EnableAutoConfiguration. Additional packages can be configured using the @AutoConfigurationPackage annotation.
Scanning the Classpath − Spring Boot scans the classpath for libraries and frameworks.
-
Conditional Configuration − Based on the detected dependencies, Spring Boot applies relevant configurations. This is done using @Conditional annotations, such as:
@ConditionalOnClass− Applies configuration if a specific class is present on the classpath.
@ConditionalOnMissingBean− Applies configuration if a specific bean is not already defined.
@ConditionalOnProperty− Applies configuration based on property values.
-
Bean Creation and Configuration − Spring Boot creates and configures beans based on the applied autoconfigurations.
Example:
If you add the spring-boot-starter-web dependency to your project, Spring Boot automatically configures a Tomcat web server and other necessary components for a web application.
If you add the spring-boot-starter-data-jpa dependency, Spring Boot automatically configures a data source, entity manager, and other components required for JPA-based data access.
Benefits of Spring Boot Autoconfiguration
Following are some of the major benefits of using Spring Boot Autoconfiguration.
Reduced Boilerplate Code− Autoconfiguration eliminates the need for manual configuration of common Spring components.
Faster Development− You can quickly create Spring Boot applications without having to write extensive configuration code.
Improved Productivity− Autoconfiguration allows you to focus on the core business logic of your application.
-
Customization− You can customize the autoconfiguration behavior by following means:
Excluding specific autoconfiguration classes using the exclude attribute of @EnableAutoConfiguration.
Defining your own beans to override the auto-configured ones.
Using property files or environment variables to modify the default configurations.