Spring Boot in Action Skill
Apply the practices from Craig Walls' "Spring Boot in Action" to review existing code and write new Spring Boot applications. This skill operates in two modes: Review Mode (analyze code for violations of Spring Boot idioms) and Write Mode (produce clean, idiomatic Spring Boot from scratch).
The core philosophy: Spring Boot removes boilerplate through auto-configuration, starter dependencies, and sensible defaults. Fight the framework only when necessary — and when you do, prefer application.properties over code.
Reference Files
practices-catalog.md — Before/after examples for auto-configuration, starters, properties, profiles, security, testing, Actuator, and deployment
How to Use This Skill
Before responding, read practices-catalog.md for the topic at hand. For configuration issues read the properties/profiles section. For test code read the testing section. For a full review, read all sections.
Mode 1: Code Review
When the user asks you to review Spring Boot code, follow this process:
Step 1: Identify the Layer
Determine whether the code is a controller, service, repository, configuration class, or test. Review focus shifts by layer.
Step 2: Analyze the Code
Check these areas in order of severity:
Auto-Configuration (Ch 2, 3): Is auto-configuration being fought manually? Look for @Bean definitions that replicate what Spring Boot already provides (DataSource, Jackson, Security, etc.). Remove manual config where auto-config suffices.
Starter Dependencies (Ch 2): Are dependencies declared individually instead of using starters? spring-boot-starter-web, spring-boot-starter-data-jpa, spring-boot-starter-security etc. bundle correct transitive dependencies and version-manage them.
Externalized Configuration (Ch 3): Are values hardcoded that belong in application.properties? Ports, URLs, credentials, timeouts should all be externalized. Use @ConfigurationProperties for type-safe config objects; use @Value only for single values.
Profiles (Ch 3): Is environment-specific config (dev DB vs prod DB) handled with if statements or system properties? Use @Profile and application-{profile}.properties instead.
Security (Ch 3): Is WebSecurityConfigurerAdapter extended when simple property-based config would suffice? Is HTTP Basic enabled in production? Are actuator endpoints exposed without auth?
Testing (Ch 4):
- Use
@SpringBootTest for full integration tests, not raw new MyService()
- Use
@WebMvcTest for controller-only tests (no full context)
- Use
@DataJpaTest for repository tests (in-memory DB, no web layer)
- Use
MockMvc for controller assertions without starting a server
- Use
@MockBean to replace real beans with mocks in slice tests
- Avoid
@SpringBootTest(webEnvironment = RANDOM_PORT) unless testing the full HTTP stack
- Flag missing negative test cases: if there is no test for "not found" (expecting 404), or no test verifying a POST returns 201 with a Location header, call these out explicitly as missing coverage
Actuator (Ch 7): Is the application missing health/metrics endpoints? Is /actuator fully exposed without security? Are custom health indicators implemented for critical dependencies?
Deployment (Ch 8): Is spring.profiles.active set for production? Is database migration (Flyway/Liquibase) configured? Is the app packaged as a self-contained JAR (preferred) or WAR?
General Idioms:
- Constructor injection over field injection (
@Autowired on fields)
@RestController = @Controller + @ResponseBody — use it for REST APIs
- Return
ResponseEntity<T> from controllers when status codes matter
Optional<T> from repository methods, never null
Step 3: Calibrate Before Reporting
Do NOT manufacture issues. If the code already follows idiomatic Spring Boot practices, say so explicitly and acknowledge what is correct. Do not invent problems to fill a review.
Rule: Only flag what is actually wrong in the code shown. Do not raise issues about code or configuration files that are NOT present in the review.
- Missing test files are not an issue in a review of production code unless the prompt asks about test coverage.
- Missing Flyway/Liquibase is not an issue unless
spring.jpa.hibernate.ddl-auto=create is used in a production context.
spring.jpa.hibernate.ddl-auto=validate combined with H2 or any datasource is NOT a conflict — validate is a safe, correct choice.
- Missing
spring.application.name is NOT an issue unless service discovery is involved.
These patterns are correct and must NOT be flagged as issues:
@SpringBootApplication on the main class — correct (Ch 1)
- Constructor injection without
@Autowired — correct; Spring auto-wires single-constructor beans (Ch 2)
ResponseEntity.created(URI.create("/api/resource/" + id)).body(saved) — correct; relative URIs are standard practice here (Ch 2)
repo.findById(id).orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND)) — correct pattern (Ch 2); at most suggest adding a descriptive message string, do NOT recommend replacing it with a domain exception + @RestControllerAdvice
SLF4J logger via LoggerFactory.getLogger(...) — correct (Ch 3)
${ENV_VAR:default} syntax in application.properties — correct externalization (Ch 3)
management.endpoints.web.exposure.include=health,info — correct Actuator lockdown (Ch 7)
When the code is idiomatic, the only acceptable suggestions are:
- Add a descriptive message to
ResponseStatusException if one is missing (minor suggestion only)
- Add
spring-boot-starter-actuator dependency if the management.* properties are present but the starter might not be (minor suggestion only)
Do not suggest Flyway, @Valid, test classes, or @RestControllerAdvice unless the code has a concrete problem that requires them.
Step 4: Report Findings
For each genuine issue, report:
- Chapter reference (e.g., "Ch 3: Externalized Configuration")
- Location in the code
- What's wrong (the anti-pattern)
- How to fix it (the Spring Boot idiomatic way)
- Priority: Critical (security/bugs), Important (maintainability), Suggestion (polish)
Step 5: Provide Fixed Code
Offer a corrected version with comments explaining each change.
Mode 2: Writing New Code
When the user asks you to write new Spring Boot code, apply these core principles:
Project Bootstrap (Ch 1, 2)
Start with Spring Initializr (Ch 1). Use start.spring.io or spring init CLI. Select starters upfront — don't add raw dependencies manually.
Use starters, not individual dependencies (Ch 2). spring-boot-starter-web includes Tomcat, Spring MVC, Jackson, and logging at compatible versions. Never declare spring-webmvc + jackson-databind + tomcat-embed-core separately.
The main class is the only required boilerplate (Ch 2):
@SpringBootApplication
public class MyApp {
public static void main(String[] args) {
SpringApplication.run(MyApp.class, args);
}
}
@SpringBootApplication = @Configuration + @EnableAutoConfiguration + @ComponentScan.
Configuration (Ch 3)
Externalize all environment-specific values (Ch 3). Nothing deployment-specific belongs in code. Use application.properties / application.yml for defaults.
Use @ConfigurationProperties for grouped config (Ch 3). Bind a prefix to a POJO — type-safe, IDE-friendly, testable:
@ConfigurationProperties(prefix = "app.mail")
@Component
public class MailProperties {
private String host;
private int port = 25;
// getters + setters
}
Use profiles for environment differences (Ch 3). application-dev.properties overrides application.properties when spring.profiles.active=dev. Never use if (env.equals("production")) in code.
Override auto-configuration surgically (Ch 3). Use spring.* properties first. Only define a @Bean when properties are insufficient. Annotate with @ConditionalOnMissingBean if providing a fallback.
Customize error pages declaratively (Ch 3). Place error/404.html, error/500.html in src/main/resources/templates/error/. No custom ErrorController needed for basic cases.
Security (Ch 3)
Extend WebSecurityConfigurerAdapter only for custom rules (Ch 3). For simple HTTP Basic with custom users, spring.security.user.name / spring.security.user.password properties suffice.
Always secure Actuator endpoints in production (Ch 7). Expose only health and info publicly; require authentication for env, beans, mappings, shutdown.
REST Controllers (Ch 2)
Use @RestController for API endpoints (Ch 2). Eliminates @ResponseBody on every method.
Return ResponseEntity<T> when HTTP status matters (Ch 2). ResponseEntity.ok(body), ResponseEntity.notFound().build(), ResponseEntity.status(201).body(created).
Use constructor injection, not field injection (Ch 2). Constructor injection makes dependencies explicit and enables testing without Spring context:
// Prefer this:
@RestController
public class BookController {
private final BookRepository repo;
public BookController(BookRepository repo) { this.repo = repo; }
}
Use Optional from repository queries (Ch 2). repo.findById(id).orElseThrow(() -> new ResponseStatusException(NOT_FOUND)).
Testing (Ch 4)
Match test slice to the layer being tested (Ch 4):
- Web layer only →
@WebMvcTest(MyController.class) + MockMvc
- Repository only →
@DataJpaTest
- Full app →
@SpringBootTest
- External service →
@MockBean to replace
Use MockMvc for controller assertions without starting a server (Ch 4):
mockMvc.perform(get("/books/1"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.title").value("Spring Boot in Action"));
Use @MockBean to isolate the unit under test (Ch 4). Replaces the real bean in the Spring context with a Mockito mock — cleaner than manual wiring.
Test security explicitly (Ch 4). Use .with(user("admin").roles("ADMIN")) or @WithMockUser to assert secured endpoints reject unauthenticated requests.
Actuator (Ch 7)
Enable Actuator in every production app (Ch 7). Add spring-boot-starter-actuator. At minimum expose health and info.
Write custom HealthIndicator for critical dependencies (Ch 7):
@Component
public class DatabaseHealthIndicator implements HealthIndicator {
@Override
public Health health() {
return canConnect() ? Health.up().build()
: Health.down().withDetail("reason", "timeout").build();
}
}
Add custom metrics via MeterRegistry (Ch 7). Counter, gauge, timer — gives Prometheus/Grafana visibility into business events.
Restrict Actuator exposure in production (Ch 7):
management.endpoints.web.exposure.include=health,info
management.endpoint.health.show-details=when-authorized
Deployment (Ch 8)
Package as an executable JAR by default (Ch 8). mvn package produces a fat JAR with embedded Tomcat. Run with java -jar app.jar. No application server needed.
Create a production profile (Ch 8). application-production.properties sets spring.datasource.url, disables dev tools, sets log levels to WARN.
Use Flyway or Liquibase for database migrations (Ch 8). Add spring-boot-starter-flyway; place scripts in classpath:db/migration/V1__init.sql. Never use spring.jpa.hibernate.ddl-auto=create in production.
Starter Cheat Sheet (Ch 2, Appendix B)
| Need |
Starter |
| REST API |
spring-boot-starter-web |
| JPA / Hibernate |
spring-boot-starter-data-jpa |
| Security |
spring-boot-starter-security |
| Observability |
spring-boot-starter-actuator |
| Testing |
spring-boot-starter-test |
| Thymeleaf views |
spring-boot-starter-thymeleaf |
| Redis cache |
spring-boot-starter-data-redis |
| Messaging |
spring-boot-starter-amqp |
| DB migration |
flyway-core |
Code Structure Template
// Main class (Ch 2)
@SpringBootApplication
public class LibraryApp {
public static void main(String[] args) {
SpringApplication.run(LibraryApp.class, args);
}
}
// Entity (Ch 2)
@Entity
public class Book {
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String title;
private String isbn;
// constructors, getters, setters
}
// Repository (Ch 2)
public interface BookRepository extends JpaRepository<Book, Long> {
List<Book> findByTitleContainingIgnoreCase(String title);
}
// Service (Ch 2) — constructor injection
@Service
public class BookService {
private final BookRepository repo;
public BookService(BookRepository repo) { this.repo = repo; }
public Book findById(Long id) {
return repo.findById(id)
.orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
}
}
// Controller (Ch 2)
@RestController
@RequestMapping("/api/books")
public class BookController {
private final BookService service;
public BookController(BookService service) { this.service = service; }
@GetMapping("/{id}")
public ResponseEntity<Book> getBook(@PathVariable Long id) {
return ResponseEntity.ok(service.findById(id));
}
@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);
}
}
// application.properties (Ch 3)
// spring.datasource.url=jdbc:postgresql://localhost/library
// spring.datasource.username=${DB_USER}
// spring.datasource.password=${DB_PASS}
// spring.jpa.hibernate.ddl-auto=validate
// management.endpoints.web.exposure.include=health,info
// application-dev.properties (Ch 3)
// spring.datasource.url=jdbc:h2:mem:library
// spring.jpa.hibernate.ddl-auto=create-drop
// logging.level.org.springframework=DEBUG
Priority of Practices by Impact
Critical (Security & Correctness)
- Ch 3: Never hardcode credentials — use
${ENV_VAR} in properties
- Ch 3: Secure Actuator endpoints —
env, beans, shutdown must require auth
- Ch 4: Test secured endpoints explicitly — assert 401/403 on unauthenticated requests
- Ch 8: Never use
ddl-auto=create in production — use Flyway/Liquibase
Important (Idiom & Maintainability)
- Ch 2: Constructor injection over
@Autowired field injection
- Ch 2:
@RestController over @Controller + @ResponseBody for APIs
- Ch 2:
Optional from repository, never null
- Ch 3:
@ConfigurationProperties over scattered @Value for grouped config
- Ch 3: Profiles for environment differences — not
if statements
- Ch 4:
@WebMvcTest for controller tests — not full @SpringBootTest
- Ch 7: Custom
HealthIndicator for each critical dependency
Suggestions (Polish)
- Ch 3: Custom error pages in
templates/error/ — no code needed
- Ch 7: Custom metrics via
MeterRegistry for business events
- Ch 8: Production profile disables dev tools, sets WARN log level
- Ch 2: Use
spring-boot-devtools in dev for live reload
1---2name: spring-boot-in-action3version: "1.0"4license: MIT5tags: [java, spring, backend]6description: >7 Write and review Spring Boot applications using practices from "Spring Boot in Action"8 by Craig Walls. Covers auto-configuration, starter dependencies, externalizing9 configuration with properties and profiles, Spring Security, testing with MockMvc10 and @SpringBootTest, Spring Actuator for production observability, and deployment11 strategies (JAR, WAR, Cloud Foundry). Use when building Spring Boot apps, configuring12 beans, writing integration tests, setting up health checks, or deploying to production.13 Trigger on: "Spring Boot", "Spring", "@SpringBootApplication", "auto-configuration",14 "application.properties", "application.yml", "@RestController", "@Service",15 "@Repository", "SpringBootTest", "Actuator", "starter", ".java files", "Maven", "Gradle".16metadata:17 source: https://skillmd.com/skills/booklib-ai/spring-boot-in-action18---1920# Spring Boot in Action Skill2122Apply the practices from Craig Walls' "Spring Boot in Action" to review existing code and write new Spring Boot applications. This skill operates in two modes: **Review Mode** (analyze code for violations of Spring Boot idioms) and **Write Mode** (produce clean, idiomatic Spring Boot from scratch).2324The core philosophy: Spring Boot removes boilerplate through **auto-configuration**, **starter dependencies**, and **sensible defaults**. Fight the framework only when necessary — and when you do, prefer `application.properties` over code.2526## Reference Files2728- `practices-catalog.md` — Before/after examples for auto-configuration, starters, properties, profiles, security, testing, Actuator, and deployment2930## How to Use This Skill3132**Before responding**, read `practices-catalog.md` for the topic at hand. For configuration issues read the properties/profiles section. For test code read the testing section. For a full review, read all sections.3334---3536## Mode 1: Code Review3738When the user asks you to **review** Spring Boot code, follow this process:3940### Step 1: Identify the Layer41Determine whether the code is a controller, service, repository, configuration class, or test. Review focus shifts by layer.4243### Step 2: Analyze the Code4445Check these areas in order of severity:46471. **Auto-Configuration** (Ch 2, 3): Is auto-configuration being fought manually? Look for `@Bean` definitions that replicate what Spring Boot already provides (DataSource, Jackson, Security, etc.). Remove manual config where auto-config suffices.48492. **Starter Dependencies** (Ch 2): Are dependencies declared individually instead of using starters? `spring-boot-starter-web`, `spring-boot-starter-data-jpa`, `spring-boot-starter-security` etc. bundle correct transitive dependencies and version-manage them.50513. **Externalized Configuration** (Ch 3): Are values hardcoded that belong in `application.properties`? Ports, URLs, credentials, timeouts should all be externalized. Use `@ConfigurationProperties` for type-safe config objects; use `@Value` only for single values.52534. **Profiles** (Ch 3): Is environment-specific config (dev DB vs prod DB) handled with `if` statements or system properties? Use `@Profile` and `application-{profile}.properties` instead.54555. **Security** (Ch 3): Is `WebSecurityConfigurerAdapter` extended when simple property-based config would suffice? Is HTTP Basic enabled in production? Are actuator endpoints exposed without auth?56576. **Testing** (Ch 4):58 - Use `@SpringBootTest` for full integration tests, not raw `new MyService()`59 - Use `@WebMvcTest` for controller-only tests (no full context)60 - Use `@DataJpaTest` for repository tests (in-memory DB, no web layer)61 - Use `MockMvc` for controller assertions without starting a server62 - Use `@MockBean` to replace real beans with mocks in slice tests63 - Avoid `@SpringBootTest(webEnvironment = RANDOM_PORT)` unless testing the full HTTP stack64 - Flag missing negative test cases: if there is no test for "not found" (expecting 404), or no test verifying a POST returns 201 with a Location header, call these out explicitly as missing coverage65667. **Actuator** (Ch 7): Is the application missing health/metrics endpoints? Is `/actuator` fully exposed without security? Are custom health indicators implemented for critical dependencies?67688. **Deployment** (Ch 8): Is `spring.profiles.active` set for production? Is database migration (Flyway/Liquibase) configured? Is the app packaged as a self-contained JAR (preferred) or WAR?69709. **General Idioms**:71 - Constructor injection over field injection (`@Autowired` on fields)72 - `@RestController` = `@Controller` + `@ResponseBody` — use it for REST APIs73 - Return `ResponseEntity<T>` from controllers when status codes matter74 - `Optional<T>` from repository methods, never `null`7576### Step 3: Calibrate Before Reporting7778**Do NOT manufacture issues.** If the code already follows idiomatic Spring Boot practices, say so explicitly and acknowledge what is correct. Do not invent problems to fill a review.7980**Rule: Only flag what is actually wrong in the code shown. Do not raise issues about code or configuration files that are NOT present in the review.**81- Missing test files are not an issue in a review of production code unless the prompt asks about test coverage.82- Missing Flyway/Liquibase is not an issue unless `spring.jpa.hibernate.ddl-auto=create` is used in a production context.83- `spring.jpa.hibernate.ddl-auto=validate` combined with H2 or any datasource is NOT a conflict — validate is a safe, correct choice.84- Missing `spring.application.name` is NOT an issue unless service discovery is involved.8586These patterns are **correct** and must NOT be flagged as issues:87- `@SpringBootApplication` on the main class — correct (Ch 1)88- Constructor injection without `@Autowired` — correct; Spring auto-wires single-constructor beans (Ch 2)89- `ResponseEntity.created(URI.create("/api/resource/" + id)).body(saved)` — correct; relative URIs are standard practice here (Ch 2)90- `repo.findById(id).orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND))` — correct pattern (Ch 2); at most suggest adding a descriptive message string, do NOT recommend replacing it with a domain exception + `@RestControllerAdvice`91- `SLF4J` logger via `LoggerFactory.getLogger(...)` — correct (Ch 3)92- `${ENV_VAR:default}` syntax in `application.properties` — correct externalization (Ch 3)93- `management.endpoints.web.exposure.include=health,info` — correct Actuator lockdown (Ch 7)9495**When the code is idiomatic, the only acceptable suggestions are:**961. Add a descriptive message to `ResponseStatusException` if one is missing (minor suggestion only)972. Add `spring-boot-starter-actuator` dependency if the `management.*` properties are present but the starter might not be (minor suggestion only)98Do not suggest Flyway, `@Valid`, test classes, or `@RestControllerAdvice` unless the code has a concrete problem that requires them.99100### Step 4: Report Findings101For each genuine issue, report:102- **Chapter reference** (e.g., "Ch 3: Externalized Configuration")103- **Location** in the code104- **What's wrong** (the anti-pattern)105- **How to fix it** (the Spring Boot idiomatic way)106- **Priority**: Critical (security/bugs), Important (maintainability), Suggestion (polish)107108### Step 5: Provide Fixed Code109Offer a corrected version with comments explaining each change.110111---112113## Mode 2: Writing New Code114115When the user asks you to **write** new Spring Boot code, apply these core principles:116117### Project Bootstrap (Ch 1, 2)1181191. **Start with Spring Initializr** (Ch 1). Use `start.spring.io` or `spring init` CLI. Select starters upfront — don't add raw dependencies manually.1201212. **Use starters, not individual dependencies** (Ch 2). `spring-boot-starter-web` includes Tomcat, Spring MVC, Jackson, and logging at compatible versions. Never declare `spring-webmvc` + `jackson-databind` + `tomcat-embed-core` separately.1221233. **The main class is the only required boilerplate** (Ch 2):124 ```java125 @SpringBootApplication126 public class MyApp {127 public static void main(String[] args) {128 SpringApplication.run(MyApp.class, args);129 }130 }131 ```132 `@SpringBootApplication` = `@Configuration` + `@EnableAutoConfiguration` + `@ComponentScan`.133134### Configuration (Ch 3)1351364. **Externalize all environment-specific values** (Ch 3). Nothing deployment-specific belongs in code. Use `application.properties` / `application.yml` for defaults.1371385. **Use `@ConfigurationProperties` for grouped config** (Ch 3). Bind a prefix to a POJO — type-safe, IDE-friendly, testable:139 ```java140 @ConfigurationProperties(prefix = "app.mail")141 @Component142 public class MailProperties {143 private String host;144 private int port = 25;145 // getters + setters146 }147 ```1481496. **Use profiles for environment differences** (Ch 3). `application-dev.properties` overrides `application.properties` when `spring.profiles.active=dev`. Never use `if (env.equals("production"))` in code.1501517. **Override auto-configuration surgically** (Ch 3). Use `spring.*` properties first. Only define a `@Bean` when properties are insufficient. Annotate with `@ConditionalOnMissingBean` if providing a fallback.1521538. **Customize error pages declaratively** (Ch 3). Place `error/404.html`, `error/500.html` in `src/main/resources/templates/error/`. No custom `ErrorController` needed for basic cases.154155### Security (Ch 3)1561579. **Extend `WebSecurityConfigurerAdapter` only for custom rules** (Ch 3). For simple HTTP Basic with custom users, `spring.security.user.name` / `spring.security.user.password` properties suffice.15815910. **Always secure Actuator endpoints in production** (Ch 7). Expose only `health` and `info` publicly; require authentication for `env`, `beans`, `mappings`, `shutdown`.160161### REST Controllers (Ch 2)16216311. **Use `@RestController` for API endpoints** (Ch 2). Eliminates `@ResponseBody` on every method.16416512. **Return `ResponseEntity<T>` when HTTP status matters** (Ch 2). `ResponseEntity.ok(body)`, `ResponseEntity.notFound().build()`, `ResponseEntity.status(201).body(created)`.16616713. **Use constructor injection, not field injection** (Ch 2). Constructor injection makes dependencies explicit and enables testing without Spring context:168 ```java169 // Prefer this:170 @RestController171 public class BookController {172 private final BookRepository repo;173 public BookController(BookRepository repo) { this.repo = repo; }174 }175 ```17617714. **Use `Optional` from repository queries** (Ch 2). `repo.findById(id).orElseThrow(() -> new ResponseStatusException(NOT_FOUND))`.178179### Testing (Ch 4)18018115. **Match test slice to the layer being tested** (Ch 4):182 - Web layer only → `@WebMvcTest(MyController.class)` + `MockMvc`183 - Repository only → `@DataJpaTest`184 - Full app → `@SpringBootTest`185 - External service → `@MockBean` to replace18618716. **Use `MockMvc` for controller assertions without starting a server** (Ch 4):188 ```java189 mockMvc.perform(get("/books/1"))190 .andExpect(status().isOk())191 .andExpect(jsonPath("$.title").value("Spring Boot in Action"));192 ```19319417. **Use `@MockBean` to isolate the unit under test** (Ch 4). Replaces the real bean in the Spring context with a Mockito mock — cleaner than manual wiring.19519618. **Test security explicitly** (Ch 4). Use `.with(user("admin").roles("ADMIN"))` or `@WithMockUser` to assert secured endpoints reject unauthenticated requests.197198### Actuator (Ch 7)19920019. **Enable Actuator in every production app** (Ch 7). Add `spring-boot-starter-actuator`. At minimum expose `health` and `info`.20120220. **Write custom `HealthIndicator` for critical dependencies** (Ch 7):203 ```java204 @Component205 public class DatabaseHealthIndicator implements HealthIndicator {206 @Override207 public Health health() {208 return canConnect() ? Health.up().build()209 : Health.down().withDetail("reason", "timeout").build();210 }211 }212 ```21321421. **Add custom metrics via `MeterRegistry`** (Ch 7). Counter, gauge, timer — gives Prometheus/Grafana visibility into business events.21521622. **Restrict Actuator exposure in production** (Ch 7):217 ```properties218 management.endpoints.web.exposure.include=health,info219 management.endpoint.health.show-details=when-authorized220 ```221222### Deployment (Ch 8)22322423. **Package as an executable JAR by default** (Ch 8). `mvn package` produces a fat JAR with embedded Tomcat. Run with `java -jar app.jar`. No application server needed.22522624. **Create a production profile** (Ch 8). `application-production.properties` sets `spring.datasource.url`, disables dev tools, sets log levels to WARN.22722825. **Use Flyway or Liquibase for database migrations** (Ch 8). Add `spring-boot-starter-flyway`; place scripts in `classpath:db/migration/V1__init.sql`. Never use `spring.jpa.hibernate.ddl-auto=create` in production.229230---231232## Starter Cheat Sheet (Ch 2, Appendix B)233234| Need | Starter |235|------|---------|236| REST API | `spring-boot-starter-web` |237| JPA / Hibernate | `spring-boot-starter-data-jpa` |238| Security | `spring-boot-starter-security` |239| Observability | `spring-boot-starter-actuator` |240| Testing | `spring-boot-starter-test` |241| Thymeleaf views | `spring-boot-starter-thymeleaf` |242| Redis cache | `spring-boot-starter-data-redis` |243| Messaging | `spring-boot-starter-amqp` |244| DB migration | `flyway-core` |245246---247248## Code Structure Template249250```java251// Main class (Ch 2)252@SpringBootApplication253public class LibraryApp {254 public static void main(String[] args) {255 SpringApplication.run(LibraryApp.class, args);256 }257}258259// Entity (Ch 2)260@Entity261public class Book {262 @Id @GeneratedValue(strategy = GenerationType.IDENTITY)263 private Long id;264 private String title;265 private String isbn;266 // constructors, getters, setters267}268269// Repository (Ch 2)270public interface BookRepository extends JpaRepository<Book, Long> {271 List<Book> findByTitleContainingIgnoreCase(String title);272}273274// Service (Ch 2) — constructor injection275@Service276public class BookService {277 private final BookRepository repo;278 public BookService(BookRepository repo) { this.repo = repo; }279280 public Book findById(Long id) {281 return repo.findById(id)282 .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));283 }284}285286// Controller (Ch 2)287@RestController288@RequestMapping("/api/books")289public class BookController {290 private final BookService service;291 public BookController(BookService service) { this.service = service; }292293 @GetMapping("/{id}")294 public ResponseEntity<Book> getBook(@PathVariable Long id) {295 return ResponseEntity.ok(service.findById(id));296 }297298 @PostMapping299 public ResponseEntity<Book> createBook(@RequestBody Book book) {300 Book saved = service.save(book);301 URI location = URI.create("/api/books/" + saved.getId());302 return ResponseEntity.created(location).body(saved);303 }304}305306// application.properties (Ch 3)307// spring.datasource.url=jdbc:postgresql://localhost/library308// spring.datasource.username=${DB_USER}309// spring.datasource.password=${DB_PASS}310// spring.jpa.hibernate.ddl-auto=validate311// management.endpoints.web.exposure.include=health,info312313// application-dev.properties (Ch 3)314// spring.datasource.url=jdbc:h2:mem:library315// spring.jpa.hibernate.ddl-auto=create-drop316// logging.level.org.springframework=DEBUG317```318319---320321## Priority of Practices by Impact322323### Critical (Security & Correctness)324- Ch 3: Never hardcode credentials — use `${ENV_VAR}` in properties325- Ch 3: Secure Actuator endpoints — `env`, `beans`, `shutdown` must require auth326- Ch 4: Test secured endpoints explicitly — assert 401/403 on unauthenticated requests327- Ch 8: Never use `ddl-auto=create` in production — use Flyway/Liquibase328329### Important (Idiom & Maintainability)330- Ch 2: Constructor injection over `@Autowired` field injection331- Ch 2: `@RestController` over `@Controller` + `@ResponseBody` for APIs332- Ch 2: `Optional` from repository, never `null`333- Ch 3: `@ConfigurationProperties` over scattered `@Value` for grouped config334- Ch 3: Profiles for environment differences — not `if` statements335- Ch 4: `@WebMvcTest` for controller tests — not full `@SpringBootTest`336- Ch 7: Custom `HealthIndicator` for each critical dependency337338### Suggestions (Polish)339- Ch 3: Custom error pages in `templates/error/` — no code needed340- Ch 7: Custom metrics via `MeterRegistry` for business events341- Ch 8: Production profile disables dev tools, sets WARN log level342- Ch 2: Use `spring-boot-devtools` in dev for live reload