​

Spring Boot Quickstart

​

1. The Magic of Spring Initializr

1. Go to start.spring.io
2. Project: Maven / Gradle (We’ll use Maven for this course)
3. Language: Java
4. Spring Boot: 3.x.x (Latest stable)
5. Project Metadata:
   • Group: com.devweekends
   • Artifact: demo
   • Packaging: Jar
   • Java: 17
6. Dependencies (Add these):
   • Spring Web: For building REST APIs (uses Tomcat as default embedded server).
   • Spring Boot DevTools: For fast feedback loops (auto-restart).
   • Lombok: To reduce boilerplate code.

​

2. Project Structure

src/
├── main/
│   ├── java/
│   │   └── com/devweekends/demo/
│   │       └── DemoApplication.java  <-- Entry Point
│   └── resources/
│       ├── application.properties    <-- Configuration
│       ├── static/                   <-- Static assets (JS/CSS)
│       └── templates/                <-- Server-side templates (Thymeleaf)

​

The Entry Point

package com.devweekends.demo;

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);
    }
}

• @Configuration: Tags the class as a source of bean definitions.
• @EnableAutoConfiguration: Tells Spring Boot to start adding beans based on classpath settings (e.g., if spring-web is on the classpath, setup Tomcat).
• @ComponentScan: Tells Spring to look for other components, configurations, and services in the com/devweekends/demo package.

​

3. Your First REST Controller

package com.devweekends.demo;

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, Dev Weekends!";
    }
}

• @RestController: Marks this class as a request handler where every method returns a domain object directly (JSON/XML) instead of a view.
• @GetMapping("/hello"): Maps HTTP GET requests to /hello to the sayHello() method.

​

4. Running the Application

./mvnw spring-boot:run

​

5. Dependency Injection (DI) Basics

@Service // 1. Register this class as a Bean
public class GreetingService {
    public String getGreeting() {
        return "Welcome to Spring Boot Mastery";
    }
}

@RestController
public class HelloController {

    private final GreetingService greetingService;

    // 2. Constructor Injection (Recommended)
    public HelloController(GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    @GetMapping("/greet")
    public String greet() {
        return greetingService.getGreeting();
    }
}

​

6. Spring Boot Internals: How it Works

1. @SpringBootConfiguration: Just a specialized @Configuration.
2. @ComponentScan: Scans the current package and sub-packages for Components.
3. @EnableAutoConfiguration: The Magic.

​

How Auto-Configuration Works

• Is spring-webmvc on the classpath? -> Configure DispatcherServlet.
• Is h2 on the classpath? -> Configure DataSource.
• Is hibernate-core on the classpath? -> Configure EntityManagerFactory.

​

7. Bean Scopes & Lifecycle

​

Scopes

• Singleton (Default): One instance per container.
• Prototype: A new instance every single time it is requested.
• Request: One instance per HTTP Request.
• Session: One instance per HTTP Session.

@Component
@Scope("prototype")
public class UserAction {
    // New instance created every time
}

​

Lifecycle Callbacks

@Component
public class DatabaseConnection {

    @PostConstruct
    public void init() {
        System.out.println("Bean created! Opening connection...");
    }

    @PreDestroy
    public void cleanup() {
        System.out.println("App shutting down! Closing connection...");
    }
}

​

8. Type-Safe Configuration

app:
  mail:
    host: smtp.gmail.com
    port: 587
    enabled: true

@ConfigurationProperties(prefix = "app.mail")
public record MailConfig(String host, int port, boolean enabled) {}

@SpringBootApplication
@EnableConfigurationProperties(MailConfig.class)
public class DemoApplication {}

​

9. Deep Dive: The IoC Container

​

BeanFactory vs ApplicationContext

• BeanFactory: The root interface. Provides basic features (DI). Lazy loading.
• ApplicationContext: A sub-interface. Adds enterprise specific functionality:
  • Internationalization (i18n).
  • Event publishing.
  • Web application support.
  • Eager loading (instantiates singletons on startup), which is better for detecting errors early.

In Spring Boot, SpringApplication.run() returns an ApplicationContext.

​

10. Dependency Injection Patterns

​

1. Field Injection (Avoid)

@Autowired
private UserService userService;

• Pros: Concise.
• Cons: Hides dependencies. Impossible to unit test without reflection/mocks. Creates circular dependency risks.

​

2. Setter Injection (Optional Deps)

@Autowired
public void setUserService(UserService userService) {
    this.userService = userService;
}

• Pros: Allows optional dependencies (can re-configure later).
• Cons: Bean is not immutable.

​

3. Constructor Injection (Recommended)

private final UserService userService;

public UserController(UserService userService) {
    this.userService = userService;
}

• Pros:
  • Immutability: Fields can be final.
  • Testability: Just pass mocks in new UserController(mockService).
  • Safety: Object is fully initialized before use.
  • Circular Dependency Detection: Fails fast at startup if A -> B -> A.

​

multiple Implementations? Use @Qualifier or @Primary

• @Primary: The default choice.
• @Qualifier("sms"): Specific choice injecting time.

public class CheckoutService {
    public CheckoutService(@Qualifier("sms") NotificationService sender) { ... }
}

​

11. Advanced Bean Lifecycle

​

BeanPostProcessors (BPP)