Spring Boot

Coming soon! #

What were the main challenges of building applications before Spring Boot? #

Dependency Management: Developers had to manually manage dependencies in pom.xml, including versions of frameworks like Spring, Spring MVC, logging libraries, JSON binding frameworks, and testing libraries such as JUnit and Mockito.
Web Configuration: A web.xml file was needed to configure things like the DispatcherServlet for Spring MVC.
Spring Configuration: Developers had to manually define configurations like:
- Component scanning
- View resolvers for web applications
- Data sources for database applications
Non-Functional Requirements: Logging, error handling, monitoring, and metrics needed to be manually implemented for every project.

What challenges did Spring MVC face before Spring Boot? #

Extensive Configuration: Building applications required significant setup in:
- pom.xml: Dependency management.
- web.xml: Deployment descriptors.
- applicationContext.xml: Bean definitions and context configuration.
Time-Consuming Setup: Even for simple applications, extensive manual configuration was needed.

How does Spring Boot solve the challenges of Spring MVC and Spring Framework? #

Starter Projects: Pre-defined starter dependencies like spring-boot-starter-web simplify dependency management.
Auto-Configuration: Automatically sets up Spring, Spring MVC, and other tools based on the classpath.
Embedded Servers: Includes servers like Tomcat and Jetty, making deployment easier.
Profiles and Properties: Supports environment-specific configurations.
Additional Features:
- Actuator: For monitoring and management.
- Default Logging: Simplifies debugging and error handling.
- Default Error Pages: Pre-configured error handling.

What is Spring Boot? #

Spring Boot is a framework built on top of the Spring Framework that simplifies the process of developing Spring-based applications. It eliminates much of the boilerplate configuration needed for traditional Spring applications, allowing developers to focus on business logic rather than infrastructure setup.

Key Characteristics:

Provides a quick start for Spring projects.
Offers opinionated defaults to streamline setup while allowing customization.
Supports modern architectural trends like microservices by enabling rapid development.

What are the important Goals of Spring Boot? #

The primary goals of Spring Boot are:

1. Rapid Development:

Simplify the creation of Spring-based applications.
Developers can start building a fully functional application within minutes.

2. Opinionated Defaults:

Spring Boot assumes sensible defaults based on the libraries added to the classpath (e.g., configuring DispatcherServlet automatically for Spring MVC).
While opinionated, it allows overriding these defaults for customization.

3. No Code Generation:

Unlike some frameworks that rely on generated code, Spring Boot avoids code generation entirely, ensuring simplicity and flexibility.

4. Non-Functional Features:

Offers out-of-the-box support for monitoring, error handling, and metrics.
Makes deployment and management easier, especially for production-ready systems.

5. Microservice Readiness:

Designed for microservices architecture, enabling developers to create independent, lightweight services quickly.

What are the important Features of Spring Boot? #

Spring Boot offers several features that make it a powerful and developer-friendly framework:

1. Auto-Configuration:

Spring Boot automatically configures your application based on the dependencies in the classpath.
Example:
- Adding spring-boot-starter-web automatically configures:
  - A DispatcherServlet.
  - A ViewResolver.
  - Message converters for JSON or XML.

2. Starter Projects:

Spring Boot Starters provide a set of pre-configured dependencies for different application types.
Examples:
- spring-boot-starter-web: For web applications.
- spring-boot-starter-data-jpa: For database access using JPA.
These starters simplify dependency management and ensure compatibility between libraries.

3. Embedded Servers:

Spring Boot allows you to package an embedded web server (like Tomcat, Jetty, or Undertow) with your application.
Benefits:
- No need to install or manage an external application server.
- Applications can be run as standalone JAR files using java -jar.

4. Spring Boot Actuator:

Provides production-ready features like:
- Health checks.
- Application metrics.
- Monitoring endpoints.

Example:

curl http://localhost:8080/actuator/health

5. Simplified Deployment:

Applications can be packaged as executable JARs or WARs.
No external application server is required when using embedded servers.

6. Developer Tools (DevTools):

Offers features like automatic reloads for faster development.
Includes a live-reload mechanism to reflect changes instantly.

7. Configuration Flexibility:

Supports multiple configuration options:
- Properties Files: application.properties.
- YAML Files: application.yml.
- Environment Variables: Useful for cloud-based deployments.

8. Microservice-Friendly:

Integrates seamlessly with Spring Cloud for building cloud-native applications.
Simplifies tasks like service discovery, load balancing, and configuration management.

Compare Spring Boot vs Spring #

Aspect	Spring	Spring Boot
Core Functionality	Provides core features like dependency injection, IoC container, and bean management.	Builds on Spring and simplifies application configuration and setup through auto-configuration.
Configuration	Requires manual configuration for components like `DispatcherServlet`, `DataSource`, and others.	Automatically configures components based on classpath dependencies and default settings.
Focus	Helps developers write loosely coupled, testable code.	Aims to reduce boilerplate and speed up development with opinionated defaults.
Integration	Offers great integration with other frameworks (e.g., Hibernate, JPA, JMS).	Further simplifies integration by auto-configuring these frameworks.
Boilerplate Code	Developers need to write significant configuration (XML or Java) to set up a project.	Minimizes boilerplate by providing Starter Projects and auto-configuration.
Dependency Injection	Core feature with flexibility in configuration.	Inherits Spring’s DI capabilities but simplifies their setup.
Ease of Use	Requires more manual work to get started.	Provides a quick start for Spring applications through pre-configured Starter Projects.
Ideal Use Case	For developers who want fine-grained control over configuration.	For developers looking to build microservices or Spring applications quickly.

Compare Spring Boot vs Spring MVC #

Aspect	Spring MVC	Spring Boot
Core Functionality	A web framework based on the Model-View-Controller (MVC) design pattern.	A framework to configure and bootstrap Spring-based applications (including Spring MVC).
Focus	Provides tools for building web applications with features like `DispatcherServlet`, `ViewResolver`, etc.	Simplifies the setup of Spring MVC applications with features like auto-configuration.
Configuration	Requires manual setup of components like `DispatcherServlet`, `ViewResolver`, and more.	Automatically configures these components based on the classpath dependencies.
Starter Projects	Not applicable; focuses solely on web application development.	Provides Starter Projects like `spring-boot-starter-web` to streamline web app development.
Embedded Server	Not applicable; requires deployment to an external server (e.g., Tomcat, Jetty).	Includes an embedded server (Tomcat, Jetty, or Undertow) for easy deployment.
Ease of Use	More manual setup and configuration required for web applications.	Greatly simplifies Spring MVC projects with opinionated defaults and auto-configuration.
REST Support	Excellent support for developing REST APIs.	Builds on Spring MVC’s REST support but simplifies setup for RESTful applications.
Ideal Use Case	When you want to develop web applications with full control over the MVC setup.	When you want to develop web applications quickly with minimal configuration.

What is the importance of `@SpringBootApplication`? #

The @SpringBootApplication annotation is a key feature in Spring Boot that serves as the entry point for any Spring Boot application. It combines several critical functionalities into a single annotation, making it simpler and more convenient to bootstrap a Spring application.

Key Features of @SpringBootApplication:

Configuration Setup:
- @SpringBootApplication includes the functionality of the @Configuration annotation.
- It tells Spring Boot that this class is a Spring configuration class, which will be used to define beans and set up the application context.
Equivalent to:
```
@Configuration
```
Example:
```
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}
```
Enables Auto-Configuration:
- It implicitly includes @EnableAutoConfiguration, which activates Spring Boot’s auto-configuration feature.
- Based on the dependencies in your classpath, Spring Boot automatically configures components like:
  - DispatcherServlet for web applications.
  - DataSource for database connections.
  - EntityManagerFactory for JPA.
Equivalent to:
```
@EnableAutoConfiguration
```
How It Works:
- If spring-boot-starter-web is added, Spring Boot configures:
  - DispatcherServlet, ViewResolver, and MessageConverter.
- If spring-boot-starter-data-jpa is added, it configures:
  - DataSource, EntityManagerFactory, and TransactionManager.
Component Scanning:
- It includes the functionality of the @ComponentScan annotation.
- Automatically scans the package of the class annotated with @SpringBootApplication and its sub-packages for Spring components like:
  - @Component
  - @Service
  - @Repository
  - @Controller
Equivalent to:
```
@ComponentScan
```
Example: If your application is in the com.example.demo package, all components in com.example.demo and its sub-packages will be scanned automatically.

Why is @SpringBootApplication Important?

Simplifies Configuration:
- Combines three key annotations (@Configuration, @EnableAutoConfiguration, and @ComponentScan) into one.
- Reduces boilerplate code and setup effort.
Enables Auto-Configuration:
- Automatically configures your application based on the dependencies in your classpath.
- Saves developers from manually configuring commonly used components.
Enables Component Scanning:
- Automatically detects Spring components within the base package and sub-packages.
Defines the Application Entry Point:
- Works seamlessly with the SpringApplication.run() method to bootstrap the application.

What is Auto Configuration? #

Auto Configuration is a core feature of Spring Boot that simplifies the setup of Spring-based applications. It automatically configures your application based on the dependencies in the classpath and other conditions, saving you from writing boilerplate configuration code.

How Auto Configuration Works:

Classpath Scanning:
- Spring Boot checks the classpath for available libraries (e.g., spring-web, spring-data-jpa) and configures related components automatically.
- For example:
  - If spring-web is present, it configures DispatcherServlet, ViewResolver, etc.
  - If spring-data-jpa is present, it configures DataSource, EntityManagerFactory, etc.
Conditions for Auto Configuration:
- Auto configuration is based on predefined conditions using annotations like:
  - @ConditionalOnClass: Configures components if specific classes are present in the classpath.
  - @ConditionalOnMissingBean: Configures components only if they are not already defined.

Example of Auto Configuration Condition:

@Configuration
@ConditionalOnClass(name = "javax.servlet.Servlet")
public class DispatcherServletAutoConfiguration {
    @Bean
    public DispatcherServlet dispatcherServlet() {
        return new DispatcherServlet();
    }
}

Benefits:

Saves time by eliminating the need for manual configuration.
Provides sensible defaults while allowing customization.
Simplifies the development process, especially for new Spring projects.

How can we find more information about Auto Configuration? #

To understand or debug auto configuration, you can use the following methods:

1. Inspect the Spring Boot Auto Configure JAR:

The spring-boot-autoconfigure dependency contains all auto configuration classes.
You can inspect these classes to see which conditions trigger auto configuration.

How to Find It:

Open your project dependencies and locate spring-boot-autoconfigure.
Explore the packages like org.springframework.boot.autoconfigure.web or org.springframework.boot.autoconfigure.jdbc.

Example Auto Configuration Class:

DispatcherServletAutoConfiguration: Configures the DispatcherServlet if it's present in the classpath.

2. Enable Debug Logging:

By enabling debug logging, you can view the Auto Configuration Report.
This report shows:
- Positive Matches: Auto configurations that were applied.
- Negative Matches: Auto configurations that were skipped (and why).

How to Enable Debug Logging:

Add the following to application.properties:
```
debug=true
```
Start your application and check the logs for the auto configuration report.

Log Output Example:

Positive matches:
- DispatcherServletAutoConfiguration matched

Negative matches:
- DataSourceAutoConfiguration did not match (DataSource class not found)

3. Use Spring Boot Actuator:

The Spring Boot Actuator provides a /actuator/conditions endpoint that shows details about auto configuration.

Steps to Use Actuator:

Add the Actuator dependency:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Enable the conditions endpoint in application.properties:
```
management.endpoints.web.exposure.include=conditions
```

Access the endpoint:

http://localhost:8080/actuator/conditions

The output includes positive and negative matches for all auto configurations.

Example Output:

{
  "positiveMatches": {
    "DispatcherServletAutoConfiguration": ["Matched due to @ConditionalOnClass"],
    "DataSourceAutoConfiguration": ["Matched due to existing DataSource bean"]
  },
  "negativeMatches": {
    "MongoAutoConfiguration": ["Did not match due to missing MongoDB classes"]
  }
}

What is an embedded server? Why is it important? #

An embedded server is a web server (like Tomcat, Jetty, or Undertow) that is included as part of your Spring Boot application. Instead of requiring a pre-installed server on the deployment environment, the server is bundled into the application as a JAR or WAR file.

Why is it important?

Simplifies Deployment:
- Eliminates the need to install and configure a separate server (e.g., Tomcat or Jetty) on the deployment environment.
- Reduces prerequisites for deploying applications. You only need Java installed.
Microservices-Ready:
- Ideal for microservices, where you have many small applications that need to be deployed independently.
- Each microservice runs with its own embedded server, making deployments isolated and self-contained.
Faster Provisioning:
- In cloud environments, you can quickly spin up new instances since the server is included in the application.
- No additional steps are required to configure the server.
Consistency Across Environments:
- Ensures that the same server version and configuration are used across development, testing, and production environments.
Ease of Execution:
- Running the application is as simple as executing a single command:
```
java -jar my-application.jar
```

What is the default embedded server with Spring Boot? #

The default embedded server in Spring Boot is Tomcat.

Why Tomcat is the Default:

The spring-boot-starter-web starter dependency, commonly used for web applications, includes a dependency on Spring Boot Starter Tomcat.
This makes Tomcat the default server unless explicitly changed.

Example Dependency:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

What are the other embedded servers supported by Spring Boot? #

In addition to Tomcat, Spring Boot supports the following embedded servers:

Jetty:

Lightweight and highly customizable.
Often used for projects that need efficient handling of concurrent connections (e.g., real-time systems).

How to Use Jetty:

Exclude Tomcat and include Jetty:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

Undertow:

Known for its high performance and lightweight footprint.
Great for applications requiring low resource usage.

How to Use Undertow:

Exclude Tomcat and include Undertow:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-undertow</artifactId>
</dependency>

What are Starter Projects? #

Starter Projects in Spring Boot are convenient dependency descriptors that simplify adding dependencies to your application. Each starter provides a predefined set of dependencies tailored to a specific type of application or functionality.

Instead of manually figuring out and managing compatible versions for various libraries, you include a single starter dependency in your pom.xml (for Maven) or build.gradle (for Gradle), and Spring Boot handles the rest.

Key Features of Starter Projects:

Convenient Dependency Management:
- Include a single starter dependency to get all required libraries.
- Reduces complexity in configuring dependencies.
Predefined Compatibility:
- Ensures that all dependencies in the starter are compatible with each other and with Spring Boot.
Quick Start for Applications:
- Each starter provides everything needed for a specific type of application (e.g., web, JPA, or RESTful services).

Example Starter Project:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

spring-boot-starter-web includes:
- Spring MVC for web applications.
- Embedded Tomcat as the default server.
- JSON support with Jackson.
- Hibernate Validator for validation.

Can you give examples of important Starter Projects? #

Here are some commonly used starter projects and their purposes:

1. Spring Boot Starter Web:

Used for building web applications and RESTful services.
Includes dependencies for Spring MVC, Jackson (for JSON processing), and an embedded Tomcat server.

Example:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

2. Spring Boot Starter Data JPA:

Used for building applications with JPA and Hibernate.
Includes Spring Data JPA, Hibernate, and a transaction manager.

Example:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

3. Spring Boot Starter Security:

Provides authentication and authorization features for web and RESTful services.
Includes Spring Security for features like form-based login, OAuth2, and JWT.

Example:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

4. Spring Boot Starter Test:

Helps in writing unit tests and integration tests.
Includes libraries like JUnit, Mockito, and Spring TestContext Framework.

Example:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

5. Spring Boot Starter Cache:

Provides caching support.
Works with in-memory caches (e.g., ConcurrentHashMap) and distributed caches (e.g., Hazelcast).

Example:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

6. Spring Boot Starter Web Services:

Used for building SOAP-based web services.
Supports creating and consuming SOAP services, defining WSDLs, and handling SOAP requests.

Example:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web-services</artifactId>
</dependency>

7. Spring Boot Starter Data REST:

Automatically exposes Spring Data repositories as RESTful web services.
Simplifies building REST APIs for JPA entities.

Example:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>

What is Starter Parent? #

The Starter Parent is a key concept in Spring Boot, acting as a parent POM for most Spring Boot applications. It provides a standard structure and configuration for Maven-based projects, ensuring consistency and reducing boilerplate code.

The Spring Boot Starter Parent inherits from another parent POM called Spring Boot Dependencies, which defines dependency versions and common project configurations.

What are the different things that are defined in Starter Parent? #

The Starter Parent defines several important settings and configurations that simplify project management:

Parent POM:
- Inherits from Spring Boot Dependencies, which manages versions for over 250 libraries.
Dependency Management:
- Delegates version management to Spring Boot Dependencies, ensuring compatibility across libraries.
Default Java Version:
- Specifies the Java version to be used for compiling the project.
- Example: Java 17, Java 11.

Encoding and Compilation:

Sets the default encoding to UTF-8.
Configures the source and target Java version for the compiler.

Example:

<properties>
    <java.version>17</java.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>${java.version}</maven.compiler.source>
    <maven.compiler.target>${java.version}</maven.compiler.target>
</properties>

Build Plugins:
- Includes plugins like the Maven Compiler Plugin and resources plugin with default configurations.
Simplified Dependency Declaration:
- Allows developers to include dependencies without specifying versions.

How does Spring Boot enforce common dependency management for all its Starter projects? #

Spring Boot enforces consistent dependency management through Spring Boot Dependencies.

Centralized Version Management:
- All dependency versions are predefined in the Spring Boot Dependencies POM.
- You only specify the dependency name, and Spring Boot ensures the correct version is used.
Example:
```
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>
```
- The version for jackson-databind is automatically managed based on the Spring Boot version.
Version Compatibility:
- Ensures that all included libraries (e.g., Spring Framework, Hibernate, Jackson) are compatible with each other.
Starter Projects:
- Spring Boot Starters inherit from the Starter Parent, which simplifies the inclusion of dependencies for specific use cases (e.g., web applications, JPA).
No Version Conflicts:
- Avoids the trial-and-error process of finding compatible library versions.

Customizable Defaults:

If you need a specific version of a library, you can override the default version by explicitly declaring it in your dependencyManagement section.

Example:

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.0</version>
        </dependency>
    </dependencies>
</dependencyManagement>

What is Spring Initializr? #

Spring Initializr is a web-based tool designed to help developers create Spring Boot projects quickly and efficiently. It eliminates the need for manual configuration by generating a ready-to-use project structure tailored to your specifications.

You can access it at start.spring.io.

Key Features of Spring Initializr:

Dependency Management Made Simple:
- Allows you to choose the dependencies (starters) needed for your project.
- Automatically sets up the pom.xml (Maven) or build.gradle (Gradle) file with compatible versions.
Customizable Project Setup:
- Choose the following options:
  - Build Tool: Maven or Gradle.
  - Programming Language: Java, Kotlin, or Groovy.
  - Spring Boot Version: Select a specific version of Spring Boot.
  - Metadata: Define Group ID, Artifact ID, Description, and Package Name.
Starter Dependencies:
- Easily add dependencies like:
  - Spring Web (for RESTful web services).
  - Spring Data JPA (for database access).
  - Spring Security, Actuator, and more.
Support for Popular Databases and Frameworks:
- Includes both SQL (JPA, JDBC) and NoSQL (MongoDB, Cassandra) options.
- Integrates with Spring Cloud for building cloud-native applications.
Generates Downloadable Project:
- Creates a ZIP file with the project structure, which can be directly imported into IDEs like Eclipse, IntelliJ IDEA, or VS Code.

How to Use Spring Initializr:

Visit the Website:
- Go to start.spring.io.
Configure Your Project:
- Select the build tool (Maven/Gradle).
- Choose the language (Java/Kotlin/Groovy).
- Specify the Spring Boot version (latest stable version recommended).
- Fill in project metadata:
  - Group ID: com.example
  - Artifact ID: my-spring-boot-app
  - Name and Description.
Add Dependencies:
- Use the search box to add dependencies.
- Examples:
  - Spring Web for web applications.
  - Spring Security for authentication and authorization.
  - Spring Data JPA for working with relational databases.
Generate and Download:
- Click Generate Project to download a ZIP file containing your project.
- Extract the ZIP and import it into your preferred IDE.

Example: Creating a RESTful Web Application

Choose:
- Build Tool: Maven
- Language: Java
- Dependencies:
  - Spring Web
  - Spring Boot DevTools
  - Spring Data JPA
  - H2 Database

Generated pom.xml (snippet):

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

Import the project into your IDE and start coding.

What is `application.properties`? #

application.properties is a configuration file used in Spring Boot applications to define key-value pairs for application settings. It acts as a central place to configure various aspects of your Spring Boot application, such as logging levels, database properties, server settings, and more.

What are some of the important things that can be customized in `application.properties`? #

You can customize a wide variety of settings in application.properties. Below are some of the most commonly used configurations:

1. Logging Configuration:

Customize log levels for your application.
Set the log file location and format.

Examples:

logging.level.org.springframework=DEBUG
logging.level.com.example=INFO
logging.file.name=logs/app.log
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} - %msg%n

2. Server Settings:

Configure server properties like port, context path, and error page.

Examples:

server.port=8081            # Change default port (default is 8080)
server.servlet.context-path=/myapp
server.error.path=/custom-error

3. Database Configuration:

Set up database connection details such as URL, username, password, and driver class.

Examples:

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.show-sql=true              # Print SQL queries in the log
spring.jpa.hibernate.ddl-auto=update # Automatically update schema

4. H2 Console Settings:

Enable the H2 in-memory database console.

Example:

spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

5. Security Settings:

Define user credentials and enable/disable basic security.

Examples:

spring.security.user.name=admin
spring.security.user.password=admin123
spring.security.enabled=true

6. Profiles and Environment-Specific Settings:

Configure active profiles for environment-specific properties.

Example:

spring.profiles.active=dev  # Activate the "dev" profile

7. JSON and HTTP Message Converters:

Customize how JSON is serialized and deserialized.

Example:

spring.jackson.serialization.write-dates-as-timestamps=false # Use ISO-8601 for dates

8. Exclude Auto Configurations:

Disable specific auto-configuration classes.

Example:

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

9. Actuator Settings:

Configure Spring Boot Actuator endpoints for monitoring and management.

Examples:

management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always

10. File Upload Settings:

Configure multipart file upload limits.

Examples:

spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=15MB

11. Starter-Specific Configurations:

Each Spring Boot starter can have its own configurable properties.

Example for Spring Cloud:

spring.cloud.config.uri=http://config-server:8888

How do you externalize configuration using Spring Boot? #

Spring Boot makes it easy to externalize configuration, allowing you to customize behavior across different environments (e.g., development, testing, production).

Ways to Externalize Configuration:

Application Properties or YAML Files:
- Use application.properties or application.yaml files to define configuration.
- These files are placed in the src/main/resources directory.
- YAML provides a more readable, hierarchical format.
Example (application.properties):
```
logging.level.org.springframework=DEBUG
app.name=MyApp
app.description=An amazing application
```
Equivalent Example (application.yaml):
```
logging:
  level:
    org:
      springframework: DEBUG
app:
  name: MyApp
  description: An amazing application
```
Environment Variables:
- Define configurations as environment variables to override defaults.
- Use SPRING_APPLICATION_NAME=MyApp for the spring.application.name property.
Command-Line Arguments:
- Pass properties as command-line arguments during application startup.
```
java -jar myapp.jar --server.port=9090
```
Profiles for Environment-Specific Configurations:
- Use application-{profile}.properties or application-{profile}.yaml for specific environments.
- Activate a profile using:
```
spring.profiles.active=dev
```

How can you add custom application properties using Spring Boot? #

To define and use custom properties in Spring Boot:

Define Custom Properties:
- Add your custom properties in application.properties or application.yaml.
Example (application.properties):
```
basic.value=true
basic.message=Hello, Spring Boot!
basic.number=42
```
Equivalent Example (application.yaml):
```
basic:
  value: true
  message: Hello, Spring Boot!
  number: 42
```

Create a Configuration Class:

Use the @ConfigurationProperties annotation to map custom properties to a Java bean.
Annotate the bean with @Component or register it as a Spring bean.

Example:

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "basic")
public class BasicConfiguration {
    private boolean value;
    private String message;
    private int number;

    // Getters and setters
    public boolean isValue() { return value; }
    public void setValue(boolean value) { this.value = value; }
    public String getMessage() { return message; }
    public void setMessage(String message) { this.message = message; }
    public int getNumber() { return number; }
    public void setNumber(int number) { this.number = number; }
}

Use the Configuration in Your Application:

Inject the configuration bean using @Autowired.

Example:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class BasicController {
    @Autowired
    private BasicConfiguration basicConfig;

    @GetMapping("/config")
    public String getConfig() {
        return "Value: " + basicConfig.isValue() +
               ", Message: " + basicConfig.getMessage() +
               ", Number: " + basicConfig.getNumber();
    }
}

What is `@ConfigurationProperties`? #

@ConfigurationProperties is an annotation in Spring Boot used to map application properties to a Java object in a type-safe manner.

Features:

Maps hierarchical properties from application.properties or application.yaml to a Java bean.
Supports type safety, ensuring mismatched types throw errors at startup.

Why Use @ConfigurationProperties:

Type Safety:
- Prevents errors caused by assigning invalid types (e.g., trying to map a string to an integer).
Cleaner Code:
- Centralizes related configuration properties into a single Java class.
- Avoids sprinkling @Value annotations across the application.
Reusable Configuration:
- Allows you to reuse the configuration bean across multiple components.

Configuration Management /spring-boot-application-configuration

What is application configuration?
Why do we need application configuration?
What is application.properties?
What are some of the important things that can customized in application.properties?
How do you externalize configuration using Spring Boot?
How can you add custom application properties using Spring Boot?
What is @ConfigurationProperties?
What are the advantages of using @ConfigurationProperties?

/spring-boot-profiles-tutorial

What is a Profile?
How do you provide different application configuration in different environments using Profiles?
How do you activate beans based on Profiles?
What is the default profiles with Spring Boot? /spring-boot-profiles
What is application configuration?
What is a profile?
How do you define beans for a specific profile?
How do you create application configuration for a specific profile?
How do you have different configuration for different environments? /spring-boot-application-configuration-with-yaml
What is application configuration?
What is YAML?
What are the advantages of YAML?
How do you specify application configuration using YAML with Spring Boot?

What is a profile? #

A profile in Spring Boot is a mechanism that allows you to define different configurations for different environments (e.g., dev, QA, prod). Profiles enable you to customize application behavior and resource connections for each environment without modifying the application code.

How do you define beans for a specific profile? #

To define beans for a specific profile, you use the @Profile annotation on your bean definitions. This ensures the bean is only available when the specified profile is active.

Steps to Define Beans for a Profile:

Annotate the Bean:
- Use @Profile("profile-name") to specify the profile.
Activate the Profile:
- Set the active profile using one of the methods below.

Example:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;

@Configuration
public class ProfileConfig {

    @Bean
    @Profile("dev")
    public MyService devService() {
        return new MyService("Development Service");
    }

    @Bean
    @Profile("prod")
    public MyService prodService() {
        return new MyService("Production Service");
    }
}

In this example:

The devService bean is only available when the dev profile is active.
The prodService bean is only available when the prod profile is active.

How do you create application configuration for a specific profile? #

To create environment-specific configurations, you use profile-specific property files, such as application-{profile}.properties or application-{profile}.yaml.

Steps to Create Profile-Specific Configuration:

Define Common Properties:
- Place common properties in application.properties or application.yaml.
Create Profile-Specific Files:
- Create files named application-{profile}.properties or application-{profile}.yaml.
- For example:
  - application-dev.properties
  - application-prod.properties
Activate the Profile:
- Specify the active profile in one of the following ways:
  - Command-Line Argument:
```
java -jar myapp.jar --spring.profiles.active=dev
```
  - Environment Variable:
```
export SPRING_PROFILES_ACTIVE=prod
```
  - Inside application.properties:
```
spring.profiles.active=qa
```

Example Files:

Common Properties (application.properties):
```
app.name=MyApp
```

Dev Properties (application-dev.properties):

app.environment=Development
app.database.url=jdbc:h2:mem:devdb

Prod Properties (application-prod.properties):

app.environment=Production
app.database.url=jdbc:mysql://prod-db-server:3306/mydb

When the dev profile is active:

The app.environment will be "Development."
The database URL will point to an H2 in-memory database.

What is Spring Boot Actuator? #

Spring Boot Actuator is a powerful management and monitoring tool for Spring Boot applications. It provides a set of built-in endpoints to access information about the application, its environment, and runtime metrics. With Actuator, you can monitor, troubleshoot, and manage your applications effectively.

How do you monitor web services using Spring Boot Actuator? #

To monitor web services using Actuator:

Add the Actuator Dependency:

Include the Spring Boot Actuator starter in your pom.xml or build.gradle.

Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Gradle:

implementation 'org.springframework.boot:spring-boot-starter-actuator'

Enable Actuator Endpoints:
- Most endpoints are disabled by default. Enable the ones you need in application.properties or application.yaml.
Example Configuration:
```
management.endpoints.web.exposure.include=health,metrics,env,beans
```
- Use * to expose all endpoints:
```
management.endpoints.web.exposure.include=*
```
Monitor Key Metrics:
- Access endpoints via HTTP (e.g., http://localhost:8080/actuator/).
- Some useful endpoints include:
  - /actuator/health: Checks the application's health.
  - /actuator/metrics: Displays application metrics like memory usage and request counts.
  - /actuator/httptrace: Shows the last few HTTP requests and responses.
  - /actuator/loggers: Manages logging levels dynamically.

Track Specific Web Service Usage:

Use the metrics endpoint to monitor REST endpoints.
Example: If your endpoint /users/{id} is hit multiple times, Actuator logs success and failure counts for each status code (e.g., 200, 404).

Sample Interaction:

Hit /users/1 a few times.

Access /actuator/metrics/http.server.requests to view the stats:

{
  "name": "http.server.requests",
  "measurements": [
    {
      "statistic": "COUNT",
      "value": 15
    },
    {
      "statistic": "TOTAL_TIME",
      "value": 3.2
    }
  ],
  "availableTags": [
    {
      "tag": "status",
      "values": ["200", "404"]
    }
  ]
}

How do you find more information about your application environment using Spring Boot? #

Spring Boot Actuator provides several endpoints to fetch detailed information about the application and its environment:

Environment Information (/actuator/env):

Displays all environment variables and system properties, including:
- JVM details.
- Active profiles.
- Environment-specific configurations.

Example Output:

{
    "activeProfiles": ["dev"],
    "propertySources": [
        {
            "name": "applicationConfig: [classpath:/application-dev.properties]",
            "properties": {
                "app.name": {
                    "value": "MyDevApp"
                }
            }
        }
    ]
}

Application Health (/actuator/health):

Checks the health of the application and its dependencies (e.g., database, disk space).

Example:

{
  "status": "UP",
  "components": {
    "db": {
      "status": "UP",
      "details": {
        "database": "H2",
        "result": "1"
      }
    },
    "diskSpace": {
      "status": "UP",
      "details": {
        "total": 500000000,
        "free": 400000000
      }
    }
  }
}

Auto Configuration (/actuator/conditions):
- Lists positive and negative auto-configuration matches.

Beans Information (/actuator/beans):

Displays all Spring beans registered in the application context.

Sample Output:

{
  "contexts": {
    "application": {
      "beans": {
        "userController": {
          "type": "com.example.controller.UserController",
          "scope": "singleton"
        }
      }
    }
  }
}

Metrics (/actuator/metrics):
- Provides runtime metrics like memory usage, active threads, and garbage collection statistics.
Key Metrics:
- JVM memory: jvm.memory.used
- Thread count: jvm.threads.live
- HTTP requests: http.server.requests

What is a CommandLineRunner? #

A CommandLineRunner in Spring Boot is a functional interface that allows you to run custom logic after the Spring application context has been initialized and before the application is fully up and running. It’s particularly useful for executing code during application startup, such as:

Initializing data in the database.
Configuring application settings.
Logging important startup information.

Key Features of CommandLineRunner

Runs on Startup: Executes immediately after the Spring Boot application context is fully initialized.
Access to Application Arguments: The run method receives the same arguments passed to the main method of your application.
Ease of Implementation: Simply implement the CommandLineRunner interface and override the run method.

How to Use CommandLineRunner

Implement the Interface:
- Create a class that implements CommandLineRunner.
Define the Logic in the run Method:
- Add your startup logic inside the overridden run method.
Annotate the Class as a Bean:
- Use @Component or register the class as a Spring Bean.

Example:

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class UserDataLoader implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        System.out.println("Application started with the following arguments:");
        for (String arg : args) {
            System.out.println(arg);
        }

        // Example logic: initializing user data
        System.out.println("Loading initial user data...");
        // Add code here to populate your database or configure resources
    }
}

Real-World Use Case

Imagine you are building a Spring Boot application that requires some initial data in a database. Instead of manually inserting this data, you can use a CommandLineRunner to load the data when the application starts.

Example with Database Interaction:

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Autowired;

@Component
public class UserRepositoryCommandLineRunner implements CommandLineRunner {

    @Autowired
    private UserRepository userRepository;

    @Override
    public void run(String... args) throws Exception {
        // Adding initial users
        userRepository.save(new User("John Doe", "[email protected]"));
        userRepository.save(new User("Jane Smith", "[email protected]"));

        // Fetching and printing users
        userRepository.findAll().forEach(user -> System.out.println(user));
    }
}

When to Use CommandLineRunner?

Data Initialization: Insert default or test data into a database.
One-Time Setup: Configure an application resource or initialize caches.
Diagnostics: Log key information about the application environment during startup.
Custom Tasks: Run tasks like file processing or API calls that are needed at startup.

On this page

Coming soon! #

What were the main challenges of building applications before Spring Boot? #

What challenges did Spring MVC face before Spring Boot? #

How does Spring Boot solve the challenges of Spring MVC and Spring Framework? #

What is Spring Boot? #

What are the important Goals of Spring Boot? #

What are the important Features of Spring Boot? #

Compare Spring Boot vs Spring #

Compare Spring Boot vs Spring MVC #

What is the importance of @SpringBootApplication? #

What is Auto Configuration? #

How can we find more information about Auto Configuration? #

What is an embedded server? Why is it important? #

What is the default embedded server with Spring Boot? #

What are the other embedded servers supported by Spring Boot? #

What are Starter Projects? #

Can you give examples of important Starter Projects? #

What is Starter Parent? #

What are the different things that are defined in Starter Parent? #

How does Spring Boot enforce common dependency management for all its Starter projects? #

What is Spring Initializr? #

What is application.properties? #

What are some of the important things that can be customized in application.properties? #

How do you externalize configuration using Spring Boot? #

How can you add custom application properties using Spring Boot? #

What is @ConfigurationProperties? #

What is a profile? #

How do you define beans for a specific profile? #

How do you create application configuration for a specific profile? #

What is Spring Boot Actuator? #

How do you monitor web services using Spring Boot Actuator? #

How do you find more information about your application environment using Spring Boot? #

What is a CommandLineRunner? #

What is the importance of `@SpringBootApplication`? #

What is `application.properties`? #

What are some of the important things that can be customized in `application.properties`? #

What is `@ConfigurationProperties`? #