Spring - Java-basierte Konfiguration

Bisher haben Sie gesehen, wie wir Spring Beans mithilfe einer XML-Konfigurationsdatei konfigurieren. Wenn Sie mit der XML-Konfiguration vertraut sind, müssen Sie nicht unbedingt lernen, wie Sie mit der Java-basierten Konfiguration fortfahren, da Sie mit einer der verfügbaren Konfigurationen das gleiche Ergebnis erzielen.

Mit der Java-basierten Konfigurationsoption können Sie den größten Teil Ihrer Spring-Konfiguration ohne XML schreiben, jedoch mithilfe einiger Java-basierter Anmerkungen, die in diesem Kapitel erläutert werden.

@Configuration & @Bean Annotations

Annotieren einer Klasse mit dem @ConfigurationGibt an, dass die Klasse vom Spring IoC-Container als Quelle für Bean-Definitionen verwendet werden kann. Das@BeanDie Annotation teilt Spring mit, dass eine mit @Bean annotierte Methode ein Objekt zurückgibt, das im Spring-Anwendungskontext als Bean registriert werden soll. Die einfachste mögliche @ Configuration-Klasse wäre wie folgt:

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

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

Der obige Code entspricht der folgenden XML-Konfiguration:

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

Hier wird der Methodenname mit @Bean kommentiert. Er fungiert als Bean-ID und erstellt die eigentliche Bean und gibt sie zurück. Ihre Konfigurationsklasse kann eine Deklaration für mehr als eine @ Bean haben. Sobald Ihre Konfigurationsklassen definiert sind, können Sie sie mithilfe von AnnotationConfigApplicationContext wie folgt laden und für den Spring-Container bereitstellen :

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

Sie können verschiedene Konfigurationsklassen wie folgt laden:

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();
}

Beispiel

Lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:

Schritte	Beschreibung
1	Erstellen Sie ein Projekt mit dem Namen SpringExample und erstellen Sie ein Paket com.tutorialspoint unter demsrc Ordner im erstellten Projekt.
2	Fügen Sie die erforderlichen Spring-Bibliotheken mit der Option Externe JARs hinzufügen hinzu, wie im Kapitel Spring Hello World-Beispiel erläutert .
3	Da Sie Java-basierte Anmerkungen verwenden, müssen Sie auch CGLIB.jar aus Ihrem Java-Installationsverzeichnis und der ASM.jar- Bibliothek hinzufügen, die von asm.ow2.org heruntergeladen werden kann .
4	Erstellen Java - Klassen HelloWorldConfig , Hello World und MainApp unter dem com.tutorialspoint Paket.
5	Der letzte Schritt besteht darin, den Inhalt aller Java-Dateien und der Bean-Konfigurationsdatei zu erstellen und die Anwendung wie unten erläutert auszuführen.

Hier ist der Inhalt von HelloWorldConfig.java Datei

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

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

Hier ist der Inhalt von HelloWorld.java Datei

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);
   }
}

Es folgt der Inhalt der MainApp.java Datei

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();
   }
}

Nachdem Sie alle Quelldateien erstellt und die erforderlichen zusätzlichen Bibliotheken hinzugefügt haben, lassen Sie uns die Anwendung ausführen. Sie sollten beachten, dass keine Konfigurationsdatei erforderlich ist. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt:

Your Message : Hello World!

Injizieren von Bean-Abhängigkeiten

Wenn @Beans Abhängigkeiten voneinander haben, wird ausgedrückt, dass die Abhängigkeit so einfach ist, als würde eine Bean-Methode eine andere aufrufen:

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();
   }
}

Hier erhält die Foo Bean über die Konstruktorinjektion einen Verweis auf bar. Schauen wir uns nun ein anderes Arbeitsbeispiel an.

Beispiel

Lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:

Schritte	Beschreibung
1	Erstellen Sie ein Projekt mit dem Namen SpringExample und erstellen Sie ein Paket com.tutorialspoint unter demsrc Ordner im erstellten Projekt.
2	Fügen Sie die erforderlichen Spring-Bibliotheken mit der Option Externe JARs hinzufügen hinzu, wie im Kapitel Spring Hello World-Beispiel erläutert .
3	Da Sie Java-basierte Anmerkungen verwenden, müssen Sie auch CGLIB.jar aus Ihrem Java-Installationsverzeichnis und der ASM.jar- Bibliothek hinzufügen, die von asm.ow2.org heruntergeladen werden kann .
4	Erstellen Sie Java-Klassen TextEditorConfig , TextEditor , SpellChecker und MainApp unter dem Paket com.tutorialspoint .
5	Der letzte Schritt besteht darin, den Inhalt aller Java-Dateien und der Bean-Konfigurationsdatei zu erstellen und die Anwendung wie unten erläutert auszuführen.

Hier ist der Inhalt von TextEditorConfig.java Datei

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( );
   }
}

Hier ist der Inhalt von TextEditor.java Datei

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();
   }
}

Es folgt der Inhalt einer anderen abhängigen Klassendatei SpellChecker.java

package com.tutorialspoint;

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

Es folgt der Inhalt der MainApp.java Datei

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();
   }
}

Nachdem Sie alle Quelldateien erstellt und die erforderlichen zusätzlichen Bibliotheken hinzugefügt haben, lassen Sie uns die Anwendung ausführen. Sie sollten beachten, dass keine Konfigurationsdatei erforderlich ist. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt:

Inside SpellChecker constructor.
Inside TextEditor constructor.
Inside checkSpelling.

Die @ Import-Anmerkung

Das @ImportMit Annotation können @ Bean-Definitionen aus einer anderen Konfigurationsklasse geladen werden. Betrachten Sie eine ConfigA-Klasse wie folgt:

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

Sie können die obige Bean-Deklaration wie folgt in eine andere Bean-Deklaration importieren:

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

Anstatt beim Instanziieren des Kontexts sowohl ConfigA.class als auch ConfigB.class angeben zu müssen, muss nur ConfigB wie folgt angegeben werden:

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);
}

Lebenszyklus-Rückrufe

Die Annotation @Bean unterstützt die Angabe beliebiger Rückrufmethoden für Initialisierung und Zerstörung, ähnlich wie die Attribute init-method und destroy-method von Spring XML für das Bean-Element.

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();
   }
}

Bean Scope festlegen

Der Standardbereich ist Singleton. Sie können dies jedoch mit der Annotation @Scope wie folgt überschreiben:

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