Spring - konfiguracja oparta na języku Java

Do tej pory widzieliście, jak konfigurujemy fasolę Spring za pomocą pliku konfiguracyjnego XML. Jeśli czujesz się komfortowo z konfiguracją XML, to naprawdę nie jest wymagane nauczenie się, jak postępować z konfiguracją opartą na Javie, ponieważ zamierzasz osiągnąć ten sam wynik, używając jednej z dostępnych konfiguracji.

Opcja konfiguracji oparta na Javie umożliwia napisanie większości konfiguracji Springa bez XML, ale z pomocą kilku adnotacji opartych na Javie, opisanych w tym rozdziale.

@Konfiguracja i adnotacje @Bean

Adnotowanie klasy z rozszerzeniem @Configurationwskazuje, że klasa może być używana przez kontener Spring IoC jako źródło definicji komponentów bean. Plik@Beanadnotacja mówi Springowi, że metoda z adnotacją @Bean zwróci obiekt, który powinien zostać zarejestrowany jako ziarno w kontekście aplikacji Spring. Najprostsza możliwa klasa @Configuration wyglądałaby następująco -

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

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

Powyższy kod będzie równoważny z następującą konfiguracją XML -

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

Tutaj nazwa metody jest oznaczona adnotacją @Bean, która działa jako identyfikator ziarna i tworzy i zwraca rzeczywisty element bean. Twoja klasa konfiguracji może mieć deklarację dla więcej niż jednego @Bean. Po zdefiniowaniu klas konfiguracji możesz załadować i dostarczyć je do kontenera Spring za pomocą narzędzia AnnotationConfigApplicationContext w następujący sposób -

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

Możesz załadować różne klasy konfiguracyjne w następujący sposób -

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

Przykład

Przygotujmy działające środowisko Eclipse IDE i wykonaj następujące czynności, aby utworzyć aplikację Spring -

Kroki	Opis
1	Utwórz projekt o nazwie SpringExample i utwórz pakiet com.tutorialspoint w obszarzesrc folder w utworzonym projekcie.
2	Dodaj wymagane biblioteki Spring za pomocą opcji Dodaj zewnętrzne pliki JAR , jak wyjaśniono w rozdziale Spring Hello World Example .
3	Ponieważ używasz adnotacji opartych na języku Java, musisz również dodać plik CGLIB.jar z katalogu instalacyjnego Java i biblioteki ASM.jar, którą można pobrać ze strony asm.ow2.org .
4	Utwórz klasy Java HelloWorldConfig , HelloWorld i MainApp w pakiecie com.tutorialspoint .
5	Ostatnim krokiem jest utworzenie zawartości wszystkich plików Java i pliku konfiguracyjnego Bean i uruchomienie aplikacji, jak wyjaśniono poniżej.

Oto treść HelloWorldConfig.java plik

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

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

Oto treść HelloWorld.java plik

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

Poniżej znajduje się zawartość MainApp.java plik

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

Po utworzeniu wszystkich plików źródłowych i dodaniu wymaganych dodatkowych bibliotek uruchom aplikację. Należy pamiętać, że nie jest wymagany żaden plik konfiguracyjny. Jeśli wszystko jest w porządku z Twoją aplikacją, wydrukuje następujący komunikat -

Your Message : Hello World!

Wstrzykiwanie zależności fasoli

Kiedy @Beans mają wzajemne zależności, wyrażając, że zależność jest tak prosta, jak wywołanie innej metody bean w następujący sposób:

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

W tym przypadku fasola foo otrzymuje odwołanie do bar poprzez iniekcję konstruktora. Spójrzmy teraz na inny działający przykład.

Przykład

Przygotujmy działające środowisko Eclipse IDE i wykonaj następujące czynności, aby utworzyć aplikację Spring -

Kroki	Opis
1	Utwórz projekt o nazwie SpringExample i utwórz pakiet com.tutorialspoint w obszarzesrc folder w utworzonym projekcie.
2	Dodaj wymagane biblioteki Spring za pomocą opcji Dodaj zewnętrzne pliki JAR , jak wyjaśniono w rozdziale Spring Hello World Example .
3	Ponieważ używasz adnotacji opartych na języku Java, musisz również dodać plik CGLIB.jar z katalogu instalacyjnego Java i biblioteki ASM.jar, którą można pobrać ze strony asm.ow2.org .
4	Tworzenie klas Java TextEditorConfig , TextEditor , sprawdzania pisowni i MainApp pod com.tutorialspoint opakowaniu.
5	Ostatnim krokiem jest utworzenie zawartości wszystkich plików Java i pliku konfiguracyjnego Bean i uruchomienie aplikacji, jak wyjaśniono poniżej.

Oto treść TextEditorConfig.java plik

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

Oto treść TextEditor.java plik

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

Poniżej znajduje się zawartość innego pliku klas zależnych SpellChecker.java

package com.tutorialspoint;

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

Poniżej znajduje się zawartość MainApp.java plik

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

Inside SpellChecker constructor.
Inside TextEditor constructor.
Inside checkSpelling.

Adnotacja @Import

Plik @Importadnotacja umożliwia ładowanie definicji @Bean z innej klasy konfiguracyjnej. Rozważ klasę ConfigA w następujący sposób -

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

Możesz zaimportować powyższą deklarację Bean do innej deklaracji Bean w następujący sposób -

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

Teraz zamiast określać zarówno ConfigA.class, jak i ConfigB.class podczas tworzenia wystąpienia kontekstu, wystarczy podać tylko ConfigB w następujący sposób -

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

Wywołania zwrotne w cyklu życia

Adnotacja @Bean obsługuje określanie dowolnych metod wywołania zwrotnego inicjalizacji i niszczenia, podobnie jak atrybuty metody inicjowania i niszczenia metody Spring XML w elemencie 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();
   }
}

Określanie zakresu fasoli

Zakres domyślny to singleton, ale można to zastąpić adnotacją @Scope w następujący sposób -

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