@booklib/core 2.0.0

package/skills/spring-boot-in-action/examples/after.md

@@ -0,0 +1,185 @@
+# After: Spring Boot in Action
+
+The same library API rewritten with idiomatic Spring Boot — auto-configuration, constructor injection, externalized config, profiles, proper testing, and Actuator.
+
+```java
+// @SpringBootApplication enables auto-config, component scan, config (Ch 1, 2)
+@SpringBootApplication
+public class LibraryApp {
+    public static void main(String[] args) {
+        SpringApplication.run(LibraryApp.class, args);
+    }
+}
+
+// No DatabaseConfig class needed — auto-configuration handles DataSource (Ch 2, 3)
+// Credentials externalized to application.properties via environment variables
+
+// Constructor injection — testable without Spring context (Ch 2)
+@RestController
+@RequestMapping("/api/books")
+public class BookController {
+    private final BookService service;
+
+    public BookController(BookService service) {
+        this.service = service;
+    }
+
+    // Returns 404 when not found, not null (Ch 2)
+    @GetMapping("/{id}")
+    public ResponseEntity<Book> getBook(@PathVariable Long id) {
+        return ResponseEntity.ok(service.findById(id));
+    }
+
+    // Returns 201 Created with Location header (Ch 2)
+    @PostMapping
+    public ResponseEntity<Book> createBook(@RequestBody Book book) {
+        Book saved = service.save(book);
+        URI location = URI.create("/api/books/" + saved.getId());
+        return ResponseEntity.created(location).body(saved);
+    }
+
+    @GetMapping
+    public List<Book> search(@RequestParam(required = false, defaultValue = "") String q) {
+        return service.search(q);
+    }
+}
+
+// Service with constructor injection and proper logging (Ch 2)
+@Service
+public class BookService {
+    private static final Logger log = LoggerFactory.getLogger(BookService.class);
+    private final BookRepository repo;
+
+    public BookService(BookRepository repo) {
+        this.repo = repo;
+    }
+
+    public Book findById(Long id) {
+        // Optional — 404 automatically surfaced (Ch 2)
+        return repo.findById(id)
+                   .orElseThrow(() -> new ResponseStatusException(
+                       HttpStatus.NOT_FOUND, "Book " + id + " not found"));
+    }
+
+    public Book save(Book book) {
+        return repo.save(book);
+    }
+
+    public List<Book> search(String query) {
+        log.debug("Searching for: {}", query);  // proper logger, not println (Ch 3)
+        return query.isBlank()
+                ? repo.findAll()
+                : repo.findByTitleContainingIgnoreCase(query);
+    }
+}
+
+// Repository — Spring Data does the rest (Ch 2)
+public interface BookRepository extends JpaRepository<Book, Long> {
+    List<Book> findByTitleContainingIgnoreCase(String title);
+}
+
+// Type-safe configuration object (Ch 3)
+@ConfigurationProperties(prefix = "app.library")
+@Component
+public class LibraryProperties {
+    private int maxSearchResults = 50;
+    private String defaultSortField = "title";
+    // getters + setters
+}
+
+// Custom health indicator for critical dependency (Ch 7)
+@Component
+public class StorageHealthIndicator implements HealthIndicator {
+    private final BookRepository repo;
+    public StorageHealthIndicator(BookRepository repo) { this.repo = repo; }
+
+    @Override
+    public Health health() {
+        try {
+            long count = repo.count();
+            return Health.up().withDetail("books", count).build();
+        } catch (Exception e) {
+            return Health.down().withDetail("error", e.getMessage()).build();
+        }
+    }
+}
+
+// Controller slice test — no full context, fast (Ch 4)
+@WebMvcTest(BookController.class)
+public class BookControllerTest {
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private BookService service;  // real service replaced with mock (Ch 4)
+
+    @Test
+    void getBook_returnsOk() throws Exception {
+        Book book = new Book(1L, "Spring Boot in Action", "9781617292545");
+        given(service.findById(1L)).willReturn(book);
+
+        mockMvc.perform(get("/api/books/1"))
+               .andExpect(status().isOk())
+               .andExpect(jsonPath("$.title").value("Spring Boot in Action"));
+    }
+
+    @Test
+    void getBook_returns404WhenNotFound() throws Exception {
+        given(service.findById(99L))
+            .willThrow(new ResponseStatusException(HttpStatus.NOT_FOUND));
+
+        mockMvc.perform(get("/api/books/99"))
+               .andExpect(status().isNotFound());
+    }
+
+    @Test
+    @WithMockUser(roles = "USER")
+    void createBook_returns201() throws Exception {
+        Book book = new Book(null, "New Book", "1234567890");
+        Book saved = new Book(1L, "New Book", "1234567890");
+        given(service.save(any())).willReturn(saved);
+
+        mockMvc.perform(post("/api/books")
+                   .contentType(MediaType.APPLICATION_JSON)
+                   .content("{\"title\":\"New Book\",\"isbn\":\"1234567890\"}"))
+               .andExpect(status().isCreated())
+               .andExpect(header().string("Location", "/api/books/1"));
+    }
+}
+```
+
+```properties
+# application.properties — base config, all env-specific values externalized (Ch 3)
+spring.datasource.url=${DB_URL:jdbc:h2:mem:library}
+spring.datasource.username=${DB_USER:sa}
+spring.datasource.password=${DB_PASS:}
+spring.jpa.hibernate.ddl-auto=validate
+
+# Actuator — health and info only exposed publicly (Ch 7)
+management.endpoints.web.exposure.include=health,info
+management.endpoint.health.show-details=when-authorized
+
+# application-dev.properties — dev overrides (Ch 3)
+# spring.datasource.url=jdbc:h2:mem:library
+# spring.jpa.hibernate.ddl-auto=create-drop
+# logging.level.com.example=DEBUG
+# management.endpoints.web.exposure.include=*
+
+# application-production.properties — production hardening (Ch 8)
+# spring.jpa.hibernate.ddl-auto=validate
+# logging.level.root=WARN
+# management.endpoints.web.exposure.include=health,info
+```
+
+**Key improvements:**
+- `@SpringBootApplication` enables auto-configuration — no manual `DataSource` bean (Ch 2)
+- Credentials externalized to env vars via `${DB_URL}` — never hardcoded (Ch 3)
+- Constructor injection throughout — testable without Spring context (Ch 2)
+- `ResponseEntity` with correct status codes: 200, 201, 404 (Ch 2)
+- `Optional` → `orElseThrow` → `ResponseStatusException` — clean 404 (Ch 2)
+- `@ConfigurationProperties` for grouped app config (Ch 3)
+- `@WebMvcTest` + `@MockBean` — fast, isolated controller tests (Ch 4)
+- `@WithMockUser` — security tested explicitly (Ch 4)
+- Custom `HealthIndicator` — DB health visible in Actuator (Ch 7)
+- Actuator locked down — only `health` and `info` public (Ch 7)
+- Profile-based properties — no env checks in code (Ch 3, 8)

package/skills/spring-boot-in-action/examples/before.md

@@ -0,0 +1,84 @@
+# Before: Spring Boot in Action
+
+A book library REST API with common Spring Boot anti-patterns — manual configuration fighting auto-config, field injection, hardcoded values, missing tests, and no Actuator.
+
+```java
+// Main class missing @SpringBootApplication — won't auto-configure anything
+@Configuration
+@ComponentScan
+public class LibraryApp {
+    public static void main(String[] args) {
+        SpringApplication.run(LibraryApp.class, args);
+    }
+}
+
+// Manual DataSource bean — fights auto-configuration (Ch 2, 3)
+@Configuration
+public class DatabaseConfig {
+    @Bean
+    public DataSource dataSource() {
+        DriverManagerDataSource ds = new DriverManagerDataSource();
+        ds.setDriverClassName("org.postgresql.Driver");
+        ds.setUrl("jdbc:postgresql://localhost/library");  // hardcoded (Ch 3)
+        ds.setUsername("admin");                           // hardcoded credential!
+        ds.setPassword("secret123");                       // hardcoded credential!
+        return ds;
+    }
+}
+
+// Field injection — untestable without Spring context (Ch 2)
+@RestController
+public class BookController {
+    @Autowired
+    private BookRepository bookRepository;
+
+    @Autowired
+    private BookService bookService;
+
+    // Returns null instead of 404 when book not found (Ch 2)
+    @GetMapping("/books/{id}")
+    public Book getBook(@PathVariable Long id) {
+        return bookRepository.findById(id).orElse(null);  // null slips to client
+    }
+
+    // No status code — always returns 200 even on create (Ch 2)
+    @PostMapping("/books")
+    @ResponseBody
+    public Book createBook(@RequestBody Book book) {
+        return bookRepository.save(book);
+    }
+}
+
+// Service with field injection and no error handling
+@Service
+public class BookService {
+    @Autowired
+    private BookRepository bookRepository;
+
+    public List<Book> search(String query) {
+        // Environment check in code instead of using profiles (Ch 3)
+        if (System.getProperty("env").equals("dev")) {
+            System.out.println("Searching for: " + query);  // println not logger
+        }
+        return bookRepository.findAll();  // returns everything, ignores query
+    }
+}
+
+// Test that boots full context just to test one controller method (Ch 4)
+@SpringBootTest
+public class BookControllerTest {
+    @Autowired
+    private BookController controller;
+
+    @Test
+    public void testGetBook() {
+        // Direct controller call — no HTTP semantics, no status code testing
+        Book result = controller.getBook(1L);
+        assertNotNull(result);
+    }
+}
+
+// application.properties — missing externalized config
+// (no datasource url, credentials baked into Java code above)
+// spring.jpa.hibernate.ddl-auto=create  // destroys data on restart!
+```

package/skills/spring-boot-in-action/references/practices-catalog.md

@@ -0,0 +1,403 @@
+# Spring Boot in Action — Practices Catalog
+
+Before/after examples from each chapter group.
+
+---
+
+## Auto-Configuration: Let Boot Do Its Job (Ch 2, 3)
+
+**Before — manual DataSource fighting auto-config:**
+```java
+@Configuration
+public class DatabaseConfig {
+    @Bean
+    public DataSource dataSource() {
+        DriverManagerDataSource ds = new DriverManagerDataSource();
+        ds.setUrl("jdbc:postgresql://localhost/mydb");
+        ds.setUsername("user");
+        ds.setPassword("pass");
+        return ds;
+    }
+}
+```
+**After — delete the class; use properties:**
+```properties
+spring.datasource.url=jdbc:postgresql://localhost/mydb
+spring.datasource.username=${DB_USER}
+spring.datasource.password=${DB_PASS}
+```
+Spring Boot auto-configures a connection pool (HikariCP) from these properties automatically.
+
+---
+
+## Overriding Auto-Configuration Surgically (Ch 3)
+
+**When auto-config is not enough — extend, don't replace:**
+```java
+// Wrong: replaces all security auto-config
+@Configuration
+public class SecurityConfig extends WebSecurityConfigurerAdapter {
+    @Override
+    protected void configure(HttpSecurity http) throws Exception {
+        http.authorizeRequests().anyRequest().permitAll();  // disables everything
+    }
+}
+
+// Right: override only what differs (Ch 3)
+@Configuration
+public class SecurityConfig extends WebSecurityConfigurerAdapter {
+    @Override
+    protected void configure(HttpSecurity http) throws Exception {
+        http
+            .authorizeRequests()
+                .antMatchers("/api/public/**").permitAll()
+                .anyRequest().authenticated()
+            .and()
+            .httpBasic();
+    }
+}
+```
+
+---
+
+## Externalized Configuration (Ch 3)
+
+**Before — hardcoded values:**
+```java
+@Service
+public class MailService {
+    private String host = "smtp.gmail.com";   // hardcoded
+    private int port = 587;                    // hardcoded
+    private int timeout = 5000;               // hardcoded
+}
+```
+**After — `@ConfigurationProperties` (type-safe, testable):**
+```java
+@ConfigurationProperties(prefix = "app.mail")
+@Component
+public class MailProperties {
+    private String host;
+    private int port = 587;
+    private int timeoutMs = 5000;
+    // getters + setters
+}
+```
+```properties
+# application.properties
+app.mail.host=smtp.gmail.com
+app.mail.port=587
+app.mail.timeout-ms=5000
+```
+
+---
+
+## Profiles for Environment Differences (Ch 3)
+
+**Before — environment check in code:**
+```java
+@Bean
+public DataSource dataSource() {
+    if (System.getProperty("env").equals("dev")) {
+        return new EmbeddedDatabaseBuilder().setType(H2).build();
+    }
+    return productionDataSource();  // messy
+}
+```
+**After — profile-specific properties files:**
+```properties
+# application.properties (defaults)
+spring.datasource.url=jdbc:postgresql://${DB_HOST:localhost}/myapp
+
+# application-dev.properties (activated by: spring.profiles.active=dev)
+spring.datasource.url=jdbc:h2:mem:myapp
+spring.jpa.hibernate.ddl-auto=create-drop
+logging.level.org.springframework=DEBUG
+
+# application-production.properties
+spring.jpa.hibernate.ddl-auto=validate
+logging.level.root=WARN
+```
+```java
+// Profile-specific beans (Ch 3)
+@Bean
+@Profile("dev")
+public DataSource devDataSource() { ... }
+
+@Bean
+@Profile("production")
+public DataSource prodDataSource() { ... }
+```
+
+---
+
+## Constructor Injection (Ch 2)
+
+**Before — field injection, untestable:**
+```java
+@Service
+public class OrderService {
+    @Autowired
+    private OrderRepository repo;  // can't test without Spring context
+
+    @Autowired
+    private PaymentGateway gateway;
+}
+```
+**After — constructor injection:**
+```java
+@Service
+public class OrderService {
+    private final OrderRepository repo;
+    private final PaymentGateway gateway;
+
+    public OrderService(OrderRepository repo, PaymentGateway gateway) {
+        this.repo = repo;
+        this.gateway = gateway;
+    }
+    // Now testable: new OrderService(mockRepo, mockGateway)
+}
+```
+
+---
+
+## REST Controllers: Status Codes & ResponseEntity (Ch 2)
+
+**Before — always 200, null on missing:**
+```java
+@GetMapping("/users/{id}")
+public User getUser(@PathVariable Long id) {
+    return repo.findById(id).orElse(null);  // 200 with null body
+}
+
+@PostMapping("/users")
+public User createUser(@RequestBody User user) {
+    return repo.save(user);  // 200, should be 201
+}
+```
+**After — correct HTTP semantics:**
+```java
+@GetMapping("/users/{id}")
+public ResponseEntity<User> getUser(@PathVariable Long id) {
+    return repo.findById(id)
+               .map(ResponseEntity::ok)
+               .orElse(ResponseEntity.notFound().build());  // 404
+}
+
+@PostMapping("/users")
+public ResponseEntity<User> createUser(@RequestBody User user) {
+    User saved = repo.save(user);
+    URI location = URI.create("/users/" + saved.getId());
+    return ResponseEntity.created(location).body(saved);  // 201 + Location
+}
+```
+
+---
+
+## Testing: Match Slice to Layer (Ch 4)
+
+**Before — full context for every test (slow):**
+```java
+@SpringBootTest  // loads ALL beans — overkill for a controller test
+public class ProductControllerTest {
+    @Autowired
+    private ProductController controller;
+
+    @Test
+    public void testGet() {
+        // No HTTP semantics, no status code, no content-type testing
+        assertNotNull(controller.getProduct(1L));
+    }
+}
+```
+**After — slice tests by layer:**
+```java
+// Controller slice — only web layer, MockMvc, no DB (Ch 4)
+@WebMvcTest(ProductController.class)
+public class ProductControllerTest {
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private ProductService service;
+
+    @Test
+    void getProduct_found() throws Exception {
+        given(service.findById(1L)).willReturn(new Product(1L, "Widget", 9.99));
+
+        mockMvc.perform(get("/api/products/1").accept(MediaType.APPLICATION_JSON))
+               .andExpect(status().isOk())
+               .andExpect(jsonPath("$.name").value("Widget"))
+               .andExpect(jsonPath("$.price").value(9.99));
+    }
+
+    @Test
+    void getProduct_notFound() throws Exception {
+        given(service.findById(99L))
+            .willThrow(new ResponseStatusException(HttpStatus.NOT_FOUND));
+
+        mockMvc.perform(get("/api/products/99"))
+               .andExpect(status().isNotFound());
+    }
+}
+
+// Repository slice — real DB (H2 in-memory), no web layer (Ch 4)
+@DataJpaTest
+public class ProductRepositoryTest {
+    @Autowired
+    private ProductRepository repo;
+
+    @Test
+    void findByName_returnsMatches() {
+        repo.save(new Product(null, "Blue Widget", 9.99));
+        List<Product> found = repo.findByNameContaining("Widget");
+        assertThat(found).hasSize(1);
+    }
+}
+
+// Full stack test — only when testing HTTP ↔ DB integration (Ch 4)
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+public class ProductIntegrationTest {
+    @Autowired
+    private TestRestTemplate restTemplate;
+
+    @Test
+    void createAndFetch() {
+        ResponseEntity<Product> created = restTemplate
+            .postForEntity("/api/products", new Product(null, "Gadget", 19.99), Product.class);
+        assertThat(created.getStatusCode()).isEqualTo(HttpStatus.CREATED);
+    }
+}
+```
+
+---
+
+## Testing Security (Ch 4)
+
+```java
+@WebMvcTest(AdminController.class)
+public class AdminControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @Test
+    void adminEndpoint_rejectsAnonymous() throws Exception {
+        mockMvc.perform(get("/admin/dashboard"))
+               .andExpect(status().isUnauthorized());  // or 403 depending on config
+    }
+
+    @Test
+    @WithMockUser(roles = "ADMIN")
+    void adminEndpoint_allowsAdmin() throws Exception {
+        mockMvc.perform(get("/admin/dashboard"))
+               .andExpect(status().isOk());
+    }
+
+    @Test
+    @WithMockUser(roles = "USER")
+    void adminEndpoint_rejectsUser() throws Exception {
+        mockMvc.perform(get("/admin/dashboard"))
+               .andExpect(status().isForbidden());
+    }
+}
+```
+
+---
+
+## Actuator: Health, Metrics, Custom Indicators (Ch 7)
+
+```java
+// Custom HealthIndicator (Ch 7)
+@Component
+public class ExternalApiHealthIndicator implements HealthIndicator {
+    private final RestTemplate restTemplate;
+
+    public ExternalApiHealthIndicator(RestTemplate restTemplate) {
+        this.restTemplate = restTemplate;
+    }
+
+    @Override
+    public Health health() {
+        try {
+            ResponseEntity<String> resp = restTemplate.getForEntity(
+                "https://api.partner.com/health", String.class);
+            if (resp.getStatusCode().is2xxSuccessful()) {
+                return Health.up().withDetail("partner-api", "reachable").build();
+            }
+            return Health.down().withDetail("status", resp.getStatusCode()).build();
+        } catch (Exception e) {
+            return Health.down(e).build();
+        }
+    }
+}
+
+// Custom counter metric (Ch 7)
+@Service
+public class OrderService {
+    private final Counter ordersCreated;
+
+    public OrderService(MeterRegistry registry) {
+        this.ordersCreated = Counter.builder("orders.created")
+            .description("Total orders placed")
+            .register(registry);
+    }
+
+    public Order place(Order order) {
+        Order saved = repo.save(order);
+        ordersCreated.increment();  // visible in /actuator/metrics
+        return saved;
+    }
+}
+```
+
+```properties
+# Secure Actuator — expose only what's needed (Ch 7)
+management.endpoints.web.exposure.include=health,info,metrics
+management.endpoint.health.show-details=when-authorized
+management.endpoint.shutdown.enabled=false
+```
+
+---
+
+## Deployment: JAR, Profiles, Flyway (Ch 8)
+
+```xml
+<!-- pom.xml: flyway for production migrations (Ch 8) -->
+<dependency>
+    <groupId>org.flywaydb</groupId>
+    <artifactId>flyway-core</artifactId>
+</dependency>
+```
+
+```sql
+-- src/main/resources/db/migration/V1__create_books.sql
+CREATE TABLE book (
+    id BIGSERIAL PRIMARY KEY,
+    title VARCHAR(255) NOT NULL,
+    isbn VARCHAR(20) UNIQUE NOT NULL
+);
+```
+
+```properties
+# application-production.properties (Ch 8)
+# Never use create or create-drop in production
+spring.jpa.hibernate.ddl-auto=validate
+spring.flyway.enabled=true
+
+# Disable dev tools
+spring.devtools.restart.enabled=false
+
+# Tighten logging
+logging.level.root=WARN
+logging.level.com.example=INFO
+
+# Actuator: health only
+management.endpoints.web.exposure.include=health
+management.endpoint.health.show-details=never
+```
+
+```bash
+# Build and run (Ch 8)
+mvn clean package -DskipTests
+java -jar target/library-1.0.0.jar --spring.profiles.active=production
+```