Chiamata a un metodo annotato @Bean nella configurazione Java di Spring

Sono curioso di sapere come Spring injection gestisce i metodi di chiamata con l' @Beanannotazione. Se metto @Beanun'annotazione su un metodo e restituisco un'istanza, capisco che ciò dice a spring di creare un bean chiamando il metodo e ottenendo l'istanza restituita. Tuttavia, a volte quel bean deve essere utilizzato per collegare altri bean o impostare altro codice. Il modo usuale per farlo è chiamare il @Beanmetodo annotato per ottenere un'istanza. La mia domanda è: perché questo non causa la presenza di più istanze del fagiolo in giro?

Ad esempio, vedere il codice seguente (tratto da un'altra domanda). Il entryPoint()metodo è annotato con @Bean, quindi immagino che spring creerà una nuova istanza di BasicAuthenticationEntryPointas a bean. Quindi, chiamiamo di entryPoint()nuovo nel blocco configure, ma sembra che entryPoint()restituisca l'istanza del bean e non venga chiamato più volte (ho provato a eseguire il log e ho ottenuto solo una voce di log). Potenzialmente potremmo chiamare entryPoint()più volte in altre parti della configurazione e avremmo sempre la stessa istanza. La mia comprensione di questo è corretta? La primavera fa qualche magica riscrittura di metodi annotati con @Bean?

@Bean
public BasicAuthenticationEntryPoint entryPoint() {
    BasicAuthenticationEntryPoint basicAuthEntryPoint = new BasicAuthenticationEntryPoint();
    basicAuthEntryPoint.setRealmName("My Realm");
    return basicAuthEntryPoint;
}

@Override
protected void configure(HttpSecurity http) throws Exception {

    http
        .exceptionHandling()
            .authenticationEntryPoint(entryPoint())
            .and()
        .authorizeUrls()
            .anyRequest().authenticated()
            .and()
        .httpBasic();       
}

Sì, la primavera fa un po 'di magia . Controlla i documenti di primavera :

È qui che entra in gioco la magia: tutte le @Configurationclassi sono sottoclassi all'avvio con CGLIB . Nella sottoclasse, il metodo figlio controlla prima il contenitore per eventuali bean memorizzati nella cache (con ambito) prima di chiamare il metodo padre e creare una nuova istanza.

Ciò significa che le chiamate ai @Beanmetodi vengono trasmesse tramite proxy tramite CGLIB e quindi viene restituita la versione memorizzata nella cache del bean (non ne viene creata una nuova).

L'ambito predefinito di @Beans è SINGLETON, se si specifica un ambito diverso, ad esempio PROTOTYPEla chiamata verrà passata al metodo originale.

Si noti che questo non è valido per i metodi statici . Come da documenti di primavera:

Le chiamate a @Beanmetodi statici non vengono mai intercettate dal contenitore, nemmeno all'interno delle @Configurationclassi (come descritto in precedenza in questa sezione), a causa di limitazioni tecniche: le sottoclassi CGLIB possono sovrascrivere solo metodi non statici. Di conseguenza, una chiamata diretta a un altro @Beanmetodo ha una semantica Java standard, risultando in un'istanza indipendente restituita direttamente dal metodo factory stesso.