Cosa nel mondo sono i fagioli di primavera?

Devo ancora trovare una definizione di alto livello di fagioli primavera che posso capire. Li vedo citati spesso nella documentazione e nei libri del Grails, ma penso che comprendere ciò che sono sarebbe utile. Cosa sono i fagioli di primavera? Come possono essere usati? Hanno qualcosa a che fare con l'iniezione di dipendenza?

Gli oggetti che formano la struttura portante della tua applicazione e che sono gestiti dal contenitore Spring IoC * sono chiamati bean. Un bean è un oggetto che viene istanziato, assemblato e altrimenti gestito da un contenitore Spring IoC. Questi bean vengono creati con i metadati di configurazione forniti al contenitore, ad esempio sotto forma di <bean/>definizioni XML .

Altre informazioni su bean e ambito di SpringSource :

Quando si crea una definizione di bean, ciò che si sta effettivamente creando è una ricetta per creare istanze effettive della classe definita da tale definizione di bean. L'idea che una definizione di bean sia una ricetta è importante, perché significa che, proprio come una classe, è possibile avere potenzialmente molte istanze di oggetti create da una singola ricetta.

È possibile controllare non solo le varie dipendenze e i valori di configurazione che devono essere collegati a un oggetto creato da una definizione di bean particolare, ma anche l'ambito degli oggetti creati da una definizione di bean particolare. Questo approccio è molto potente e ti dà la flessibilità di scegliere l'ambito degli oggetti che crei attraverso la configurazione invece di dover "inserire" l'ambito di un oggetto a livello di classe Java. I bean possono essere definiti per essere distribuiti in uno dei numerosi ambiti

* IoC: inversione di controllo

I bean di primavera sono solo oggetti di istanza gestiti dal contenitore Spring, ovvero creati e cablati dal framework e inseriti in una "borsa di oggetti" (il container) da cui è possibile ottenerli in un secondo momento.

La parte "cablaggio" è ciò che riguarda l'iniezione di dipendenza, ciò che significa è che puoi semplicemente dire "Avrò bisogno di questa cosa" e il framework seguirà alcune regole per ottenere l'istanza corretta.

Per qualcuno che non è abituato a Spring, penso che l'articolo di Wikipedia Spring abbia una bella descrizione :

Fondamentale per Spring Framework è la sua inversione del contenitore di controllo, che fornisce un mezzo coerente per configurare e gestire gli oggetti Java usando la riflessione. Il contenitore è responsabile della gestione dei cicli di vita degli oggetti di oggetti specifici: creazione di questi oggetti, chiamata dei loro metodi di inizializzazione e configurazione di questi oggetti collegandoli insieme.

Gli oggetti creati dal contenitore sono anche chiamati oggetti gestiti o bean . Il contenitore può essere configurato caricando file XML o rilevando specifiche annotazioni Java sulle classi di configurazione. Queste origini dati contengono le definizioni dei bean che forniscono le informazioni necessarie per creare i bean.

Gli oggetti possono essere ottenuti mediante la ricerca delle dipendenze o l' iniezione delle dipendenze . La ricerca delle dipendenze è un modello in cui un chiamante richiede all'oggetto contenitore un oggetto con un nome specifico o di un tipo specifico. L'iniezione delle dipendenze è un modello in cui il contenitore passa gli oggetti per nome ad altri oggetti, tramite costruttori, proprietà o metodi di fabbrica.

Prima di tutto cerchiamo di capire la primavera:

La primavera è una struttura leggera e flessibile.

Analogia:

Bean: è un oggetto che viene creato, gestito e distrutto in Spring Container. Possiamo iniettare un oggetto nel contenitore di primavera attraverso i metadati (XML o annotazione), che si chiama inversione di controllo.

Analogia: supponiamo che l'agricoltore abbia un terreno agricolo coltivato da semi (o fagioli). Qui Farmer è Spring Framework, il terreno agricolo è Spring Container, i fagioli sono Spring Beans, la coltivazione è Spring Processors.

Come il ciclo di vita dei fagioli, anche i fagioli di primavera hanno il proprio ciclo di vita.

fonte img

Di seguito è riportata la sequenza di un ciclo di vita del fagiolo in primavera:

• Istanza: prima il contenitore di primavera trova la definizione del bean dal file XML e crea un'istanza del bean.

• Popola le proprietà: usando l'iniezione delle dipendenze, spring popola tutte le proprietà come specificato nella definizione del bean.

• Imposta nome bean: se il bean implementa l' BeanNameAwareinterfaccia, spring passa l'ID del bean al setBeanName()metodo.

• Set Bean factory: Se Bean implementa l' BeanFactoryAwareinterfaccia, la molla passa il beanfactory al setBeanFactory()metodo.

• Pre-inizializzazione: anche chiamata post process del bean. Se sono presenti bean BeanPostProcessors associati al bean, Spring chiama il postProcesserBeforeInitialization()metodo.

• Inizializza bean: se il bean implementa IntializingBean, afterPropertySet()viene chiamato il suo metodo. Se il bean ha la dichiarazione del metodo init, viene chiamato il metodo di inizializzazione specificato.

• Post-inizializzazione: - Se sono presenti BeanPostProcessorsdei bean associati, postProcessAfterInitialization()verranno chiamati i loro metodi.

• Pronto per l'uso: ora il bean è pronto per essere utilizzato dall'applicazione

• Distruggi: se il bean viene implementato DisposableBean, chiamerà il destroy()metodo

Beh, l'hai capito parzialmente. Devi personalizzare i fagioli in base alle tue esigenze e informare il contenitore Spring per gestirli quando necessario, utilizzando una metodologia populalrly nota come IoC ( Inversion of Control ) coniata da Martin Fowler , nota anche come Dependency Injection (DI).

Collega i bean in un modo, in modo da non doverti occupare dell'istanza o valutare alcuna dipendenza dal bean. Questo è popolarmente noto come Principio di Hollywood .

Google è lo strumento migliore per esplorare di più su questo oltre ai link che ti verrebbero inondati qui in questa domanda. :)

La primavera ha il contenitore IoC che trasporta la borsa di fagioli; la creazione e la cancellazione della creazione sono responsabilità di Spring Container. Possiamo mettere il bean in Spring tramite Wiring e Auto Wiring. Cablaggio significa che lo configuriamo manualmente nel file XML e "Cablaggio automatico" significa che inseriamo le annotazioni nel file Java, quindi Spring scansiona automaticamente il contesto di root in cui il file di configurazione Java, lo fa e lo inseriamo nel sacchetto di Spring.

Ecco l'URI di dettaglio in cui hai ottenuto maggiori informazioni sui fagioli

I fagioli primaverili sono classi. Invece di creare un'istanza di una classe (usando new), si ottiene un'istanza come beancast per il proprio tipo di classe dal contesto dell'applicazione, dove il bean è ciò che è stato configurato nella configurazione del contesto dell'applicazione. In questo modo, l'intera applicazione mantiene l'istanza dell'ambito singleton in tutta l'applicazione. Tutti i bean vengono inizializzati seguendo il loro ordine di configurazione subito dopo aver creato un'istanza del contesto dell'applicazione. Anche se non si ottengono bean nell'applicazione, tutte le istanze di bean vengono già create nel momento in cui è stato creato il contesto dell'applicazione.

• I bean Spring sono solo istanze di oggetto gestite dal contenitore IOC Spring.

• Il contenitore Spring IOC trasporta il Bag of Bean. La creazione, la manutenzione e la cancellazione dei bean sono responsabilità di Spring Container.

• Possiamo mettere il bean in Spring tramite Wiring e Auto Wiring.

• Cablaggio significa che lo configuriamo manualmente nel file XML.

• Auto Wiring significa che inseriamo le annotazioni nel file Java, quindi Spring esegue automaticamente la scansione del contesto root in cui si trova il file di configurazione java, lo facciamo e lo inseriamo nel sacchetto di Spring.

Un Bean è un POJO (Plain Old Java Object), gestito dal contenitore a molla.

I contenitori a molla creano solo un'istanza del bean per impostazione predefinita. Questo bean è memorizzato nella cache in modo che tutte le richieste per il bean restituiranno un riferimento condiviso allo stesso bean.

L'annotazione @Bean restituisce un oggetto che spring registra come bean nel contesto dell'applicazione. La logica all'interno del metodo è responsabile della creazione dell'istanza.

Quando utilizziamo l'annotazione @Bean?

Quando la configurazione automatica non è un'opzione. Ad esempio, quando vogliamo collegare i componenti da una libreria di terze parti, perché il codice sorgente non è disponibile, quindi non possiamo annotare le classi con @Component.

Uno scenario in tempo reale potrebbe essere che qualcuno vuole connettersi al bucket Amazon S3. Poiché la fonte non è disponibile, dovrebbe creare un @bean.

@Bean
public AmazonS3 awsS3Client() {
    BasicAWSCredentials awsCreds = new BasicAWSCredentials(awsKeyId, accessKey);
    return AmazonS3ClientBuilder.standard().withRegion(Regions.fromName(region))
            .withCredentials(new AWSStaticCredentialsProvider(awsCreds)).build();
}

Fonte per il codice sopra -> https://www.devglan.com/spring-mvc/aws-s3-java

Perché ho citato l'annotazione @Component sopra.

@Component Indica che una classe annotata è un "componente". Tali classi sono considerate candidate per il rilevamento automatico quando si utilizza la configurazione basata su annotazioni e la scansione del percorso di classe.

L'annotazione del componente registra la classe come un singolo bean.

In primavera, quegli oggetti che formano la spina dorsale dell'applicazione e che sono gestiti dal contenitore Spring IoC sono chiamati bean. Un bean è semplicemente un oggetto che viene istanziato, assemblato e altrimenti gestito da un contenitore IoC Spring;

Per la primavera, tutti gli oggetti sono fagioli! Il passaggio fondamentale in Spring Framework è definire i tuoi oggetti come bean. I bean non sono altro che istanze di oggetti che verrebbero create dal framework spring osservando le definizioni delle loro classi. Queste definizioni fondamentalmente formano i metadati di configurazione. Il framework crea quindi un piano per il quale è necessario creare un'istanza degli oggetti, quali dipendenze devono essere impostate e iniettate, l'ambito dell'istanza appena creata, ecc., In base a questi metadati di configurazione.

I metadati possono essere forniti in un semplice file XML, proprio come nel primo capitolo. In alternativa, è possibile fornire i metadati come Annotation o Java Configuration.

Libro: solo primavera

La configurazione XML di Spring è composta da Beans e Beans sono sostanzialmente classi. Sono solo POJO che usiamo all'interno del nostro ApplicationContext. La definizione di bean può essere considerata come la sostituzione della parola chiave new. Quindi, ovunque tu stia usando la parola chiave new nella tua applicazione qualcosa come:

MyRepository myRepository =new MyRepository ();

Dove stai usando quella parola chiave nuova che è da qualche parte puoi guardare rimuovendo quella configurazione e posizionandola in un file XML. Quindi codificheremo in questo modo:

<bean name="myRepository " 
      class="com.demo.repository.MyRepository " />

Ora possiamo semplicemente usare Setter Injection / Costruttore Injection. Sto usando Setter Injection.

public class MyServiceImpl implements MyService {
    private MyRepository myRepository;
    public void setMyRepository(MyRepository myRepository)
        {
    this.myRepository = myRepository ;
        }
public List<Customer> findAll() {
        return myRepository.findAll();
    }
}