Spring Boot — Création des beans, scopes & cycle de vie

flowchart LR
    A["Démarrage ApplicationContext"] --> B["Scan des @Component / @Bean"]
    B --> C["Résolution des dépendances"]
    C --> D{"Dépendance manquante ?"}
    D -- Oui --> E["NoSuchBeanDefinitionException au démarrage"]
    D -- Non --> F["Instanciation des singletons"]
    F --> G["Injection des dépendances"]
    G --> H["BeanPostProcessors — création des proxies AOP"]
    H --> I["@PostConstruct"]
    I --> J["Contexte prêt — Application opérationnelle"]
    J --> K["Arrêt / shutdown"]
    K --> L["@PreDestroy"]

sequenceDiagram
    participant SC as Spring Container
    participant BP as BeanPostProcessors
    participant B as Bean (instance brute)
    participant P as Proxy AOP

    SC->>B: new ReportService(...)
    SC->>B: injection des @Autowired (champs, setters)
    SC->>BP: postProcessBeforeInitialization()
    BP->>P: crée le proxy (wrapping AOP)
    SC->>P: appel @PostConstruct via le proxy
    P->>B: méthode init() — proxy actif
    SC-->>SC: bean enregistré comme prêt
    Note over SC,P: ...application en cours d'utilisation...
    SC->>P: appel @PreDestroy
    P->>B: méthode destroy()

@Service
public class ReportService {

    @Autowired
    private ReportRepository reportRepository;

    // ⚠️ DANGER : appel depuis le constructeur — proxy AOP pas encore créé
    public ReportService() {
        // Ne jamais faire ça :
        // this.generateDailyReport(); // ← @Transactional ignorée, pas de transaction !
    }

    @PostConstruct
    public void init() {
        // ✓ Ici le proxy est en place : @Transactional fonctionne
        generateDailyReport(); // ← appel intercepté par le proxy, transaction ouverte
    }

    @Transactional // ✓ interceptée via proxy AOP en @PostConstruct, ignorée depuis le constructeur
    public void generateDailyReport() {
        reportRepository.deleteOlderThan(LocalDate.now().minusDays(30));
        reportRepository.save(new DailyReport(LocalDate.now()));
    }

    @PreDestroy
    public void cleanup() {
        reportRepository.flush(); // ✓ libération des ressources à l'arrêt
    }
}

@Service
@Lazy // ← bean instancié seulement à la première utilisation
public class HeavyAnalyticsService {

    @PostConstruct
    public void init() {
        loadMLModel(); // opération coûteuse — s'exécute au 1er getBean(), pas au démarrage
    }
}

@Component
@Scope("prototype")
public class CsvImportJob {
    private List<String> errors = new ArrayList<>(); // état local, safe en prototype
}

@Service
public class ImportService {

    @Autowired
    private ApplicationContext context;

    public void runImport(MultipartFile file) {
        // ✓ nouvelle instance à chaque appel
        CsvImportJob job = context.getBean(CsvImportJob.class);
        job.process(file);
    }
}

@Service
public class AlertService {

    // ✓ Pattern Optional<T> — injection safe si le bean est absent
    @Autowired
    private Optional<NotificationService> notificationService;

    public void sendAlert(String message) {
        notificationService.ifPresentOrElse(
            svc -> svc.notify(message),
            () -> log.warn("Aucun service de notification actif")
        );
    }
}

@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestContext {
    private String correlationId = UUID.randomUUID().toString();
}