Konwersja pliku XML spring do klasy konfiguracyjnej spring @

(Disclaimer - Ta odpowiedź jest oparta na moim blogu )

Migracja XML do @Configuration

1. Utwórz klasę @Configuration przypisaną:

   @Configuration
   public class MyApplicationContext {
   
   }
   

2. Dla każdego znacznika <bean> Utwórz metodę z adnotacją @Bean:

   @Configuration
   public class MyApplicationContext {
   
     @Bean(name = "someBean")
     public SomeClass getSomeClass() {
       return new SomeClassImpl(someInterestingProperty); // We still need to inject someInterestingProperty
     }
   
     @Bean(name = "anotherBean")
     public AnotherClass getAnotherClass() {
       return new AnotherClassImpl(getSomeClass(), beanFromSomewhereElse); // We still need to inject beanFromSomewhereElse
     }
   }
   

3. Aby zaimportować beanFromSomewhereElse musimy zaimportować jego definicję. Może być zdefiniowany w XML i będziemy używać @ImportResource:

   @ImportResource("another-application-context.xml")
   @Configuration
   public class MyApplicationContext {
     ...  
   }
   

   Jeśli bean jest zdefiniowany w innej klasie @Configuration możemy użyć adnotacji @Import:

   @Import(OtherConfiguration.class)
   @Configuration
   public class MyApplicationContext {
     ...
   }
   

4. Po zaimportowaniu innych klas XML lub @Configuration, możemy użyć beans, które deklarują w naszym kontekście, deklarując prywatny członek do klasy @Configuration w następujący sposób:

   @Autowired
   @Qualifier(value = "beanFromSomewhereElse")
   private final StrangeBean beanFromSomewhereElse;
   

   Lub użyć go bezpośrednio jako parametru w metodzie, która definiuje ziarno, które zależy od tego beanFromSomewhereElse, używając @Qualifier w następujący sposób:

   @Bean(name = "anotherBean")
   public AnotherClass getAnotherClass(@Qualifier (value = "beanFromSomewhereElse") final StrangeBean beanFromSomewhereElse) {
     return new AnotherClassImpl(getSomeClass(), beanFromSomewhereElse);
   }
   

5. Importowanie właściwości jest bardzo podobny do importowania bean z innej klasy xml lub @Configuration. Zamiast używać @Qualifier użyjemy {[24] } z właściwościami w następujący sposób:

   @Autowired
   @Value("${some.interesting.property}")
   private final String someInterestingProperty;
   

   Może być również używany z wyrażeniami SpEL.

6. Aby spring mógł traktować takie klasy jak kontenery beans, musimy oznaczyć to w naszym głównym xml poprzez umieszczenie tego znacznika w kontekście:

   <context:annotation-config/>
   

   Możesz teraz zaimportować @Configuration klasy dokładnie tak samo, jak tworzysz prosty bean:

   <bean class="some.package.MyApplicationContext"/>
   

   Istnieją sposoby na całkowite uniknięcie spring XML, ale nie są one objęte zakresem tej odpowiedzi. Jedną z tych opcji można znaleźć w moim blogu, na którym opieram swoją odpowiedź.

Zalety i wady stosowania tej metody

Zasadniczo uważam, że ta metoda deklarowania fasoli jest znacznie wygodniejsza niż używanie XMLs ze względu na kilka korzyści, które widzę: {]}

1. literówki - @Configuration zajęcia są kompilacji i literówek po prostu nie pozwalają na Kompilacje [41]}
2. Jeśli nie uda Ci się wprowadzić fasoli, to nie uda Ci się w czasie kompilacji, a nie w czasie wykonywania, jak w przypadku XMLs]}
3. łatwiej poruszać się w IDE - pomiędzy konstruktorami beans, aby zrozumieć drzewo zależności.
4. możliwość łatwego debugowania konfiguracji startowej

Wad nie jest wiele, jak je widzę, ale jest kilka, które mógłbym myśleć of:

1. Abuse - kod jest łatwiejszy do nadużycia niż XMLs
2. Z XMLs można definiować zależności na podstawie klas, które nie są dostępne w czasie kompilacji, ale są dostarczane w czasie wykonywania. Z klasami @Configuration musisz mieć klasy dostępne w czasie kompilacji. Zazwyczaj to nie jest problem, ale są przypadki, że może być.

Reasumując: idealnie jest łączyć XMLS, @Configuration i adnotacje w kontekście aplikacji. Wiosna nie obchodzi mnie sposób, w jaki fasola została zadeklarowana.