spring-boot-engineer

name	spring-boot-engineer
description	Generates Spring Boot 3.x configurations, creates REST controllers, implements Spring Security 6 authentication flows, sets up Spring Data JPA repositories, and configures reactive WebFlux endpoints. Use when building Spring Boot 3.x applications, microservices, or reactive Java applications.

Spring Boot Engineer

Core Workflow

1. Analyze requirements — Identify service boundaries, APIs, data models, security needs
2. Design architecture — Plan microservices, data access, cloud integration, security
3. Implement — Create services with constructor injection and layered architecture
4. Secure — Add Spring Security, OAuth2, method security, CORS configuration
5. Test — Write unit, integration, and slice tests; run ./mvnw test and confirm all pass
6. Deploy — Configure health checks and observability via Actuator

Reference Guide

Topic	Reference	Load When
Web Layer	references/web.md	Controllers, REST APIs, validation, exception handling
Data Access	references/data.md	Spring Data JPA, repositories, transactions, projections
Security	references/security.md	Spring Security 6, OAuth2, JWT, method security
Cloud Native	references/cloud.md	Spring Cloud, Config, Discovery, Gateway, resilience
Testing	references/testing.md	@SpringBootTest, MockMvc, Testcontainers, test slices

Quick Start — Minimal Working Structure

Entity

@Entity
@Table(name = "products")
public class Product {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @NotBlank private String name;
    @DecimalMin("0.0") private BigDecimal price;
}

Repository

public interface ProductRepository extends JpaRepository<Product, Long> {
    List<Product> findByNameContainingIgnoreCase(String name);
}

Service (constructor injection)

@Service
public class ProductService {
    private final ProductRepository repo;
    public ProductService(ProductRepository repo) { this.repo = repo; }

    @Transactional(readOnly = true)
    public List<Product> search(String name) {
        return repo.findByNameContainingIgnoreCase(name);
    }

    @Transactional
    public Product create(ProductRequest request) {
        var product = new Product();
        product.setName(request.name());
        product.setPrice(request.price());
        return repo.save(product);
    }
}

REST Controller

@RestController
@RequestMapping("/api/v1/products")
@Validated
public class ProductController {
    private final ProductService service;
    public ProductController(ProductService service) { this.service = service; }

    @GetMapping
    public List<Product> search(@RequestParam(defaultValue = "") String name) {
        return service.search(name);
    }

    @PostMapping @ResponseStatus(HttpStatus.CREATED)
    public Product create(@Valid @RequestBody ProductRequest request) {
        return service.create(request);
    }
}

DTO (record)

public record ProductRequest(@NotBlank String name, @DecimalMin("0.0") BigDecimal price) {}

Global Exception Handler

@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public Map<String, String> handleValidation(MethodArgumentNotValidException ex) {
        return ex.getBindingResult().getFieldErrors().stream()
            .collect(Collectors.toMap(FieldError::getField, FieldError::getDefaultMessage));
    }

    @ExceptionHandler(EntityNotFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public Map<String, String> handleNotFound(EntityNotFoundException ex) {
        return Map.of("error", ex.getMessage());
    }
}

Constraints

MUST DO

Rule	Correct Pattern
Constructor injection	public MyService(Dep dep) { this.dep = dep; }
Validate API input	@Valid @RequestBody MyRequest req
Type-safe config	@ConfigurationProperties(prefix = "app")
Transaction scope	@Transactional on writes; readOnly = true on reads
Hide internals	@RestControllerAdvice for errors
Externalize secrets	Environment variables or Spring Cloud Config

MUST NOT DO

• Use field injection (@Autowired on fields)
• Skip input validation on API endpoints
• Mix blocking and reactive code
• Store secrets in application.properties
• Use deprecated Spring Boot 2.x patterns