Spring Boot Introduction: Why It Exists and How to Build Your First App

package io.thecodeforge.bookstore;

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

/**
 * @SpringBootApplication is a convenience annotation that combines three annotations:
 *   1. @Configuration       — marks this class as a source of bean definitions
 *   2. @EnableAutoConfiguration — tells Spring Boot to start auto-configuring beans
 *                               based on what's on the classpath
 *   3. @ComponentScan       — tells Spring to scan this package (and sub-packages)
 *                               for @Component, @Service, @Repository, @Controller etc.
 *
 * You almost never split these three apart in a real project.
 */
@SpringBootApplication
public class BookstoreApplication {

    public static void main(String[] args) {
        // SpringApplication.run() does the heavy lifting:
        // - Creates the ApplicationContext
        // - Registers all auto-configured beans
        // - Starts the embedded Tomcat server on port 8080
        SpringApplication.run(BookstoreApplication.class, args);
    }
}

package io.thecodeforge.bookstore.controller;

import io.thecodeforge.bookstore.model.Book;
import io.thecodeforge.bookstore.service.BookService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @RestController = @Controller + @ResponseBody
 * Every method return value is automatically serialized to JSON by
 * Jackson — which was auto-configured because spring-boot-starter-web
 * is on the classpath. You didn't configure Jackson. Spring Boot did.
 */
@RestController
@RequestMapping("/api/books")  // All endpoints in this class are prefixed with /api/books
public class BookController {

    // Spring injects BookService automatically via constructor injection.
    // This is the preferred injection style — it makes the dependency explicit
    // and the class easy to unit test without Spring.
    private final BookService bookService;

    public BookController(BookService bookService) {
        this.bookService = bookService;
    }

    /**
     * GET /api/books — returns all books as a JSON array.
     * ResponseEntity gives us full control over the HTTP status code.
     */
    @GetMapping
    public ResponseEntity<List<Book>> getAllBooks() {
        List<Book> books = bookService.findAllBooks();
        return ResponseEntity.ok(books);  // 200 OK + JSON body
    }

    /**
     * POST /api/books — creates a new book.
     * @RequestBody tells Spring to deserialize the incoming JSON into a Book object.
     * @ResponseStatus sets the default HTTP response code to 201 Created.
     */
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)  // Returns 201 instead of default 200
    public Book createBook(@RequestBody Book newBook) {
        return bookService.saveBook(newBook);  // Returns saved book with generated ID
    }

    /**
     * GET /api/books/{id} — find a specific book by its ID.
     * Returns 404 if not found — handled cleanly via Optional.
     */
    @GetMapping("/{bookId}")
    public ResponseEntity<Book> getBookById(@PathVariable Long bookId) {
        return bookService.findBookById(bookId)
                .map(ResponseEntity::ok)              // Found: 200 OK with book
                .orElse(ResponseEntity.notFound().build()); // Not found: 404
    }
}

// ─────────────────────────────────────────────
// FILE 1: Book.java  (the Model / Entity)
// ─────────────────────────────────────────────
package io.thecodeforge.bookstore.model;

import jakarta.persistence.*;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Positive;

/**
 * @Entity marks this class as a JPA entity — Spring Data JPA will
 * automatically create a 'book' table in the database for this.
 * With H2 in-memory DB on the classpath, no SQL setup needed.
 */
@Entity
@Table(name = "books")
public class Book {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // Auto-increment primary key
    private Long id;

    @NotBlank(message = "Title cannot be empty")  // Validated by @Valid in controller
    @Column(nullable = false)
    private String title;

    @NotBlank(message = "Author cannot be empty")
    private String author;

    @Positive(message = "Price must be greater than zero")
    private Double price;

    // JPA requires a no-arg constructor
    protected Book() {}

    public Book(String title, String author, Double price) {
        this.title = title;
        this.author = author;
        this.price = price;
    }

    // Getters and setters — needed for Jackson JSON serialization
    public Long getId() { return id; }
    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }
    public String getAuthor() { return author; }
    public void setAuthor(String author) { this.author = author; }
    public Double getPrice() { return price; }
    public void setPrice(Double price) { this.price = price; }
}

// ─────────────────────────────────────────────
// FILE 2: BookRepository.java  (the Data Layer)
// ─────────────────────────────────────────────
package io.thecodeforge.bookstore.repository;

import io.thecodeforge.bookstore.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/**
 * JpaRepository<Book, Long> gives us findById, findAll, save, delete etc.
 * for FREE — Spring Data generates the implementation at runtime.
 * We don't write a single SQL query for standard CRUD operations.
 */
@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
    // Spring Data can generate queries from method names alone:
    // findByAuthor(String author) → SELECT * FROM books WHERE author = ?
    // No SQL needed — the method name IS the query.
}

// ─────────────────────────────────────────────
// FILE 3: BookService.java  (the Business Layer)
// ─────────────────────────────────────────────
package io.thecodeforge.bookstore.service;

import io.thecodeforge.bookstore.model.Book;
import io.thecodeforge.bookstore.repository.BookRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Optional;

/**
 * @Service is a specialization of @Component — it marks this class
 * as a service-layer bean and makes it eligible for component scanning.
 * Functionally identical to @Component, but communicates intent clearly.
 */
@Service
public class BookService {

    private final BookRepository bookRepository;

    // Constructor injection — Spring automatically injects the BookRepository bean.
    // Because there's only ONE constructor, @Autowired is not required in Spring 4.3+.
    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    public List<Book> findAllBooks() {
        return bookRepository.findAll();
    }

    public Optional<Book> findBookById(Long bookId) {
        return bookRepository.findById(bookId);
    }

    @Transactional  // Wraps the DB operation in a transaction — rolls back on exception
    public Book saveBook(Book newBook) {
        return bookRepository.save(newBook);
    }
}

// ─────────────────────────────────────────────
// FILE 4: application.properties
// Location: src/main/resources/application.properties
// ─────────────────────────────────────────────
// server.port=8080                     ← default, shown for clarity
// spring.application.name=bookstore-api
//
// # H2 in-memory database (auto-configured when h2 is on classpath)
// spring.datasource.url=jdbc:h2:mem:bookstoredb
// spring.datasource.driver-class-name=org.h2.Driver
// spring.h2.console.enabled=true       ← access DB GUI at /h2-console
//
// # Show SQL queries in console during development
// spring.jpa.show-sql=true
// spring.jpa.hibernate.ddl-auto=create-drop  ← creates schema on start, drops on stop