Introduction to Spring Boot

Spring Boot is a powerful framework built on top of the Spring Framework that simplifies the development of standalone, production-grade, and microservice-based applications. It provides auto-configuration, embedded servers, and opinionated defaults, allowing developers to focus on writing business logic rather than boilerplate configuration.

---

1. Key Features of Spring Boot

1. Auto-Configuration:

• Automatically configures Spring and third-party libraries based on dependencies.

1. Standalone Applications:

• Creates standalone applications with embedded servers (e.g., Tomcat, Jetty).

1. Opinionated Defaults:

• Provides sensible defaults to reduce configuration effort.

1. Production-Ready:

• Includes features like actuators, metrics, and health checks.

1. No Code Generation:

• No XML configuration or code generation is required.

1. Microservices Support:

• Simplifies the development of microservices with tools like Spring Cloud.

---

2. Spring Boot vs Spring Framework

Feature	Spring Framework	Spring Boot
Configuration	Requires manual configuration.	Auto-configuration with sensible defaults.
Embedded Server	Requires external server setup.	Comes with embedded servers (e.g., Tomcat).
Dependency Management	Manual dependency management.	Provides starter dependencies for easy setup.
Development Speed	Slower due to manual setup.	Faster due to auto-configuration and defaults.
Use Case	Suitable for complex, customizable setups.	Ideal for rapid application development.

---

3. Creating a Spring Boot Application

Spring Boot applications can be created using:

• Spring Initializr (https://start.spring.io/).
• IDE (e.g., IntelliJ IDEA, Eclipse).
• Command Line.

Example: Using Spring Initializr

1. Go to Spring Initializr.
2. Select dependencies (e.g., Spring Web, Spring Data JPA).
3. Generate and download the project.
4. Import the project into your IDE.

---

4. Spring Boot Project Structure

A typical Spring Boot project has the following structure:

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── demo
│   │               ├── DemoApplication.java
│   │               ├── controller
│   │               │   └── HelloController.java
│   │               ├── service
│   │               │   └── HelloService.java
│   │               └── repository
│   │                   └── UserRepository.java
│   └── resources
│       ├── application.properties
│       └── static
│       └── templates
└── test
    └── java
        └── com
            └── example
                └── demo
                    └── DemoApplicationTests.java

---

5. Example: Simple Spring Boot Application

Step 1: Create a Spring Boot Application

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

Step 2: Create a REST Controller

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, Spring Boot!";
    }
}

Step 3: Run the Application

• Run the DemoApplication class.
• Open a browser and navigate to http://localhost:8080/hello.

---

6. Spring Boot Starters

Spring Boot provides starter dependencies to simplify dependency management. Some popular starters include:

• spring-boot-starter-web: For building web applications.
• spring-boot-starter-data-jpa: For JPA-based database access.
• spring-boot-starter-security: For securing applications.
• spring-boot-starter-test: For testing.

Example: Adding Starters

<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>
</dependencies>

---

7. Spring Boot Auto-Configuration

Spring Boot automatically configures your application based on the dependencies in the classpath.

Example: Auto-Configuring a DataSource

If you include spring-boot-starter-data-jpa and a database driver (e.g., H2, MySQL), Spring Boot automatically configures a DataSource.

---

8. Spring Boot Actuator

Spring Boot Actuator provides production-ready features like health checks, metrics, and monitoring.

Example: Enabling Actuator

Add the spring-boot-starter-actuator dependency:

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

Access actuator endpoints (e.g., http://localhost:8080/actuator/health).

---

9. Spring Boot Profiles

Spring Boot supports profiles to configure applications for different environments (e.g., dev, prod).

Example: Using Profiles

• Create application-dev.properties and application-prod.properties.
• Activate a profile using the spring.profiles.active property:

  spring.profiles.active=dev

---

10. Spring Boot Testing

Spring Boot provides tools for testing applications using JUnit, Mockito, and Spring Test.

Example: Testing a Controller

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
public class HelloControllerTest {
    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testHello() throws Exception {
        mockMvc.perform(get("/hello"))
               .andExpect(status().isOk())
               .andExpect(content().string("Hello, Spring Boot!"));
    }
}

---

11. Best Practices

• Use Spring Initializr to bootstrap your project.
• Leverage auto-configuration to reduce boilerplate code.
• Use profiles for environment-specific configurations.
• Add actuators for production monitoring.
• Write unit and integration tests for robust applications.

---

By mastering Spring Boot, you can rapidly develop and deploy modern, production-ready applications!