1) The Problem: Manual Configuration Pain

Imagine a supermarket with automatic sliding doors. You walk up and they open. Classic Spring Framework was the opposite — you had to push every door yourself.

Before Spring Boot, a typical project required:

• Adding every dependency individually — and managing version conflicts by hand
• Writing XML or Java @Configuration classes for every component
• Configuring and deploying to an external application server
• Wiring DispatcherServlet, DataSource, transaction managers, and view resolvers manually

"Focus on your business logic. I'll handle the infrastructure." — Spring Boot's core promise

2) Spring Boot Starters

A starter is a single dependency that pulls in everything you need for a feature — at mutually compatible versions. No more dependency hell.

3) Auto-Configuration Explained

When Spring Boot starts up, it scans the classpath and runs hundreds of @Conditional checks. For each library it detects, it creates the right beans automatically — unless you've already defined your own.

4) Example App: Reading List

The best way to understand Spring Boot is to build something. This app lets users add and view books in a personal reading list — persisted with JPA and rendered with Thymeleaf.

Tech stack

Bootstrap with Spring Initializr

1. Go to start.spring.io and select Gradle – Groovy as the build tool.
2. Add dependencies: Web, Thymeleaf, Spring Data JPA, H2 Database.
3. Click Generate — Spring Initializr creates the project structure, build file, and @SpringBootApplication class.
4. Import into your IDE and you're ready to write business logic immediately.

5) Domain Layer — the Book entity

The core domain object is a Book with six fields. Annotate it with JPA annotations:

@Entity
public class Book {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String reader;
    private String isbn;
    private String title;
    private String author;
    private String description;

    // getters and setters ...
}

6) Repository Layer — Spring Data JPA

Spring Data JPA eliminates all CRUD boilerplate. Declare an interface extending JpaRepository and Spring Boot generates the implementation at runtime:

public interface ReadingListRepository
        extends JpaRepository<Book, Long> {

    List<Book> findByReader(String reader);
}

The findByReader method is derived automatically from its name — no SQL or @Query annotation required.

7) Web Layer — Controller & Thymeleaf

Controller responsibilities

• GET /{reader} — fetches books from the repository, adds them to the model, returns readingList.html
• POST /{reader} — saves the submitted book entity and redirects back to the reader's page

@Controller
@RequestMapping("/{reader}")
public class ReadingListController {

    private final ReadingListRepository repo;

    public ReadingListController(ReadingListRepository repo) {
        this.repo = repo;
    }

    @GetMapping
    public String readersBooks(@PathVariable String reader, Model model) {
        model.addAttribute("books", repo.findByReader(reader));
        model.addAttribute("reader", reader);
        return "readingList";
    }

    @PostMapping
    public String addToReadingList(@PathVariable String reader, Book book) {
        book.setReader(reader);
        repo.save(book);
        return "redirect:/{reader}";
    }
}

Thymeleaf template

Place readingList.html in src/main/resources/templates/. Spring Boot's auto-configured ViewResolver picks it up with no extra setup:

• Iterates over the books list with th:each
• Shows "No books on the list" when empty using th:if
• Renders an add-book form that posts back to the controller

8) Running the Application

Option 1 — Gradle bootRun

./gradlew bootRun

Option 2 — Build a fat JAR

./gradlew build
java -jar build/libs/readinglist-0.0.1-SNAPSHOT.jar

Either way, Spring Boot starts the following with zero configuration on your part:

1. Embedded Tomcat on http://localhost:8080
2. Spring MVC with DispatcherServlet registered
3. JPA + Hibernate against an in-memory H2 database
4. Thymeleaf view resolver pointed at /templates/

9) Behind the Scenes: @Conditional magic

Every piece of Spring Boot's auto-configuration is guarded by a @Conditional annotation. The most important ones are:

10) What You Gain with Spring Boot

"You don't push the door. The door opens for you." — and you still control every hinge.

11) Related Guides

• Configuring Spring Boot with application.properties
• Spring Data JPA complete guide
• Testing Spring Boot applications with @SpringBootTest
• Spring Security basics and form login
• Spring Boot Actuator — monitoring & health checks