Spring - Configurazione basata su Java

Finora hai visto come configuriamo i bean Spring utilizzando il file di configurazione XML. Se ti senti a tuo agio con la configurazione XML, non è davvero necessario imparare come procedere con la configurazione basata su Java poiché otterrai lo stesso risultato utilizzando una delle configurazioni disponibili.

L'opzione di configurazione basata su Java consente di scrivere la maggior parte della configurazione Spring senza XML ma con l'aiuto di poche annotazioni basate su Java spiegate in questo capitolo.

@Configuration e @Bean Annotations

Annotare una classe con @Configurationindica che la classe può essere utilizzata dal contenitore Spring IoC come origine delle definizioni dei bean. Il@Beanannotation dice a Spring che un metodo annotato con @Bean restituirà un oggetto che dovrebbe essere registrato come bean nel contesto dell'applicazione Spring. La classe @Configuration più semplice possibile sarebbe la seguente:

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class HelloWorldConfig {
   @Bean 
   public HelloWorld helloWorld(){
      return new HelloWorld();
   }
}

Il codice precedente sarà equivalente alla seguente configurazione XML:

<beans>
   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" />
</beans>

Qui, il nome del metodo è annotato con @Bean funziona come ID bean e crea e restituisce il bean effettivo. La tua classe di configurazione può avere una dichiarazione per più di un @Bean. Una volta definite le classi di configurazione, è possibile caricarle e fornirle al contenitore Spring utilizzando AnnotationConfigApplicationContext come segue:

public static void main(String[] args) {
   ApplicationContext ctx = new AnnotationConfigApplicationContext(HelloWorldConfig.class);
   
   HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
   helloWorld.setMessage("Hello World!");
   helloWorld.getMessage();
}

È possibile caricare varie classi di configurazione come segue:

public static void main(String[] args) {
   AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();

   ctx.register(AppConfig.class, OtherConfig.class);
   ctx.register(AdditionalConfig.class);
   ctx.refresh();

   MyService myService = ctx.getBean(MyService.class);
   myService.doStuff();
}

Esempio

Cerchiamo di avere un IDE Eclipse funzionante e di eseguire i seguenti passaggi per creare un'applicazione Spring:

Passi	Descrizione
1	Crea un progetto con un nome SpringExample e crea un pacchetto com.tutorialspoint sottosrc cartella nel progetto creato.
2	Aggiungere le librerie Spring richieste utilizzando l' opzione Aggiungi JAR esterni come spiegato nel capitolo Esempio Spring Hello World .
3	Poiché stai utilizzando annotazioni basate su Java, devi anche aggiungere CGLIB.jar dalla directory di installazione di Java e la libreria ASM.jar che può essere scaricata da asm.ow2.org .
4	Crea classi Java HelloWorldConfig , HelloWorld e MainApp nel pacchetto com.tutorialspoint .
5	Il passaggio finale consiste nel creare il contenuto di tutti i file Java e nel file di configurazione Bean ed eseguire l'applicazione come spiegato di seguito.

Ecco il contenuto di HelloWorldConfig.java file

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class HelloWorldConfig {
   @Bean 
   public HelloWorld helloWorld(){
      return new HelloWorld();
   }
}

Ecco il contenuto di HelloWorld.java file

package com.tutorialspoint;

public class HelloWorld {
   private String message;

   public void setMessage(String message){
      this.message  = message;
   }
   public void getMessage(){
      System.out.println("Your Message : " + message);
   }
}

Di seguito è riportato il contenuto del file MainApp.java file

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext ctx = 
         new AnnotationConfigApplicationContext(HelloWorldConfig.class);
   
      HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
      helloWorld.setMessage("Hello World!");
      helloWorld.getMessage();
   }
}

Dopo aver creato tutti i file sorgente e aggiunto le librerie aggiuntive richieste, eseguiamo l'applicazione. Si noti che non è richiesto alcun file di configurazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:

Your Message : Hello World!

Iniezione di dipendenze da fagioli

Quando @Beans hanno dipendenze l'una dall'altra, esprimendo che la dipendenza è semplice come avere un metodo bean che ne chiama un altro come segue:

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class AppConfig {
   @Bean
   public Foo foo() {
      return new Foo(bar());
   }
   @Bean
   public Bar bar() {
      return new Bar();
   }
}

Qui, il foo bean riceve un riferimento a bar tramite l'iniezione del costruttore. Vediamo ora un altro esempio funzionante.

Esempio

Cerchiamo di avere un IDE Eclipse funzionante e di eseguire i seguenti passaggi per creare un'applicazione Spring:

Passi	Descrizione
1	Crea un progetto con un nome SpringExample e crea un pacchetto com.tutorialspoint sottosrc cartella nel progetto creato.
2	Aggiungere le librerie Spring richieste utilizzando l' opzione Aggiungi JAR esterni come spiegato nel capitolo Esempio Spring Hello World .
3	Poiché stai utilizzando annotazioni basate su Java, devi anche aggiungere CGLIB.jar dalla directory di installazione di Java e la libreria ASM.jar che può essere scaricata da asm.ow2.org .
4	Crea classi Java TextEditorConfig , TextEditor , SpellChecker e MainApp nel pacchetto com.tutorialspoint .
5	Il passaggio finale consiste nel creare il contenuto di tutti i file Java e nel file di configurazione Bean ed eseguire l'applicazione come spiegato di seguito.

Ecco il contenuto di TextEditorConfig.java file

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class TextEditorConfig {
   @Bean 
   public TextEditor textEditor(){
      return new TextEditor( spellChecker() );
   }

   @Bean 
   public SpellChecker spellChecker(){
      return new SpellChecker( );
   }
}

Ecco il contenuto di TextEditor.java file

package com.tutorialspoint;

public class TextEditor {
   private SpellChecker spellChecker;

   public TextEditor(SpellChecker spellChecker){
      System.out.println("Inside TextEditor constructor." );
      this.spellChecker = spellChecker;
   }
   public void spellCheck(){
      spellChecker.checkSpelling();
   }
}

Di seguito è riportato il contenuto di un altro file di classe dipendente SpellChecker.java

package com.tutorialspoint;

public class SpellChecker {
   public SpellChecker(){
      System.out.println("Inside SpellChecker constructor." );
   }
   public void checkSpelling(){
      System.out.println("Inside checkSpelling." );
   }
}

Di seguito è riportato il contenuto del file MainApp.java file

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext ctx = 
         new AnnotationConfigApplicationContext(TextEditorConfig.class);

      TextEditor te = ctx.getBean(TextEditor.class);
      te.spellCheck();
   }
}

Dopo aver creato tutti i file sorgente e aggiunto le librerie aggiuntive richieste, eseguiamo l'applicazione. Si noti che non è richiesto alcun file di configurazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:

Inside SpellChecker constructor.
Inside TextEditor constructor.
Inside checkSpelling.

L'annotazione @Import

Il @Importl'annotazione consente di caricare le definizioni @Bean da un'altra classe di configurazione. Considera una classe ConfigA come segue:

@Configuration
public class ConfigA {
   @Bean
   public A a() {
      return new A(); 
   }
}

È possibile importare la dichiarazione Bean sopra in un'altra dichiarazione Bean come segue:

@Configuration
@Import(ConfigA.class)
public class ConfigB {
   @Bean
   public B b() {
      return new B(); 
   }
}

Ora, invece di dover specificare sia ConfigA.class che ConfigB.class durante l'istanza del contesto, solo ConfigB deve essere fornito come segue:

public static void main(String[] args) {
   ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class);
   
   // now both beans A and B will be available...
   A a = ctx.getBean(A.class);
   B b = ctx.getBean(B.class);
}

Callback del ciclo di vita

L'annotazione @Bean supporta la specifica di metodi di callback di inizializzazione e distruzione arbitrari, proprio come gli attributi init-method e destroy-method di Spring XML sull'elemento bean -

public class Foo {
   public void init() {
      // initialization logic
   }
   public void cleanup() {
      // destruction logic
   }
}
@Configuration
public class AppConfig {
   @Bean(initMethod = "init", destroyMethod = "cleanup" )
   public Foo foo() {
      return new Foo();
   }
}

Specifica dell'ambito del bean

L'ambito predefinito è singleton, ma puoi sovrascriverlo con l'annotazione @Scope come segue:

@Configuration
public class AppConfig {
   @Bean
   @Scope("prototype")
   public Foo foo() {
      return new Foo();
   }
}