Patrones de Arquitectura Spring Boot

@RestController
@RequestMapping("/api/v1/predictions")
@Validated
class PredictionController {
  private final PredictionService predictionService;

  // Constructor injection — no field injection
  PredictionController(PredictionService svc) {
    this.predictionService = svc;
  }

  @PostMapping
  ResponseEntity<PredictionResponse> analyze(
      @Valid @RequestBody AnalysisRequest req) {
    Prediction result = predictionService.analyze(req);
    return ResponseEntity
      .status(HttpStatus.CREATED)
      .body(PredictionResponse.from(result));
  }

  @GetMapping
  ResponseEntity<Page<PredictionResponse>> history(
      @RequestParam(defaultValue="0") int page,
      @RequestParam(defaultValue="20") int size) {
    return ResponseEntity.ok(
      predictionService.history(
        PageRequest.of(page, size,
          Sort.by("createdAt").descending())
      ).map(PredictionResponse::from)
    );
  }
}

public interface PredictionRepository
    extends JpaRepository<PredictionEntity, Long> {

  // Historial paginado por tenant (cliente B2B)
  @Query("select p from PredictionEntity p " +
         "where p.tenantId = :tenantId " +
         "order by p.createdAt desc")
  Page<PredictionEntity> findByTenant(
      @Param("tenantId") String tenantId,
      Pageable pageable);

  // Búsqueda por hash de ingredientes (cache miss check)
  Optional<PredictionEntity> findByIngredientsHash(
      String hash);

  // Alertas pendientes de procesar
  @Query("select p from PredictionEntity p " +
         "where p.score >= :threshold " +
         "and p.alertSent = false")
  List<PredictionEntity> findPendingAlerts(
      @Param("threshold") double threshold);
}

@Service
public class PredictionService {
  private static final Logger log =
    LoggerFactory.getLogger(PredictionService.class);

  private final PredictionRepository repo;
  private final MlClientService mlClient;
  private final AlertService alertService;

  @Transactional
  public Prediction analyze(AnalysisRequest req) {
    log.info("analyze tenant={} items={}",
      req.tenantId(), req.ingredients().size());

    String hash = IngredientHasher.hash(req.ingredients());

    // Score via ML model con retry exponencial
    double score = withRetry(
      () -> mlClient.predict(req.ingredients()), 3);

    PredictionEntity entity = new PredictionEntity(
      req.tenantId(), hash, score, req.ingredients());
    PredictionEntity saved = repo.save(entity);

    // Alerta async si score alto (riesgo nutricional)
    if (score >= 7.5) {
      alertService.sendAsync(saved);
    }
    return Prediction.from(saved);
  }

  @Transactional(readOnly = true)
  public Page<Prediction> history(Pageable pageable) {
    return repo.findAll(pageable).map(Prediction::from);
  }
}

// REQUEST — validado con Bean Validation
public record AnalysisRequest(
  @NotBlank
  String tenantId,

  @NotEmpty @Size(max = 50)
  List<@Valid IngredientItem> ingredients,

  @Size(max = 200)
  String productName
) {}

public record IngredientItem(
  @NotBlank String name,
  @Positive double grams,
  @NotBlank String unit
) {}

// RESPONSE — projection sin datos internos
public record PredictionResponse(
  Long id,
  double nutriScore,
  String grade,      // A/B/C/D/E
  Instant analyzedAt,
  List<String> warnings
) {
  static PredictionResponse from(Prediction p) {
    return new PredictionResponse(
      p.id(), p.score(),
      NutriGrade.from(p.score()),
      p.createdAt(), p.warnings()
    );
  }
}

@Component
public class RequestLoggingFilter
    extends OncePerRequestFilter {
  private static final Logger log =
    LoggerFactory.getLogger(RequestLoggingFilter.class);

  @Override
  protected void doFilterInternal(...) {
    long start = System.currentTimeMillis();
    try {
      chain.doFilter(req, res);
    } finally {
      long ms = System.currentTimeMillis()-start;
      log.info(
        "req method={} uri={} status={} ms={}",
        req.getMethod(),
        req.getRequestURI(),
        res.getStatus(), ms);
    }
  }
}

Stack de observabilidad NutriScore:

• ✅
  Constructor injection Sin @Autowired en campos — testabilidad garantizada
• ✅
  @Transactional(readOnly=true) En todas las queries — HikariCP optimiza el pool
• ✅
  RFC 7807 Problem Details spring.mvc.problemdetails.enabled=true
• ✅
  ForwardedHeaderFilter forward-headers-strategy=NATIVE en prod (AWS ALB)
• ✅
  HikariCP tuning max-pool-size=20, timeouts configurados
• ✅
  @Async + thread pool dedicado alertExecutor separado del request thread
• ⚠️
  Retry exponencial en ML call withRetry(supplier, 3) — pendiente Resilience4j
• ⚠️
  Null-safety con @NonNull Pendiente activar en módulo principal