Wiosna - szybki przewodnik

Spring to najpopularniejszy framework do tworzenia aplikacji dla języka Java dla przedsiębiorstw. Miliony programistów na całym świecie używa Spring Framework do tworzenia kodu o wysokiej wydajności, łatwego do testowania i wielokrotnego użytku.

Spring Framework to platforma Java typu open source. Został pierwotnie napisany przez Roda Johnsona i po raz pierwszy został wydany na licencji Apache 2.0 w czerwcu 2003 roku.

Wiosna jest lekka, jeśli chodzi o rozmiar i przezroczystość. Podstawowa wersja frameworka Spring to około 2MB.

Podstawowe funkcje Spring Framework można wykorzystać przy tworzeniu dowolnej aplikacji Java, ale istnieją rozszerzenia do tworzenia aplikacji internetowych na platformie Java EE. Spring ma na celu ułatwienie programowania J2EE i promuje dobre praktyki programistyczne, umożliwiając model programowania oparty na POJO.

Korzyści z używania Spring Framework

Poniżej znajduje się lista kilku wspaniałych korzyści płynących z używania Spring Framework -

Spring umożliwia programistom tworzenie aplikacji klasy korporacyjnej przy użyciu POJO. Zaletą używania tylko POJO jest to, że nie potrzebujesz produktu kontenera EJB, takiego jak serwer aplikacji, ale masz możliwość korzystania tylko z solidnego kontenera serwletów, takiego jak Tomcat lub jakiś produkt komercyjny.
Wiosna jest zorganizowana modułowo. Mimo że liczba pakietów i klas jest znaczna, musisz martwić się tylko o te, których potrzebujesz, a resztę zignorować.
Spring nie wymyśla na nowo koła, zamiast tego naprawdę wykorzystuje niektóre istniejące technologie, takie jak kilka ram ORM, ramy rejestrowania, zegary JEE, Quartz i JDK oraz inne technologie widoku.
Testowanie aplikacji napisanej w Spring jest proste, ponieważ kod zależny od środowiska jest przenoszony do tego frameworka. Ponadto, korzystając z POJO w stylu JavaBean, łatwiej jest używać wstrzykiwania zależności w celu wstrzykiwania danych testowych.
Framework sieciowy Springa to dobrze zaprojektowana platforma sieciowa MVC, która stanowi doskonałą alternatywę dla struktur internetowych, takich jak Struts lub innych zbyt rozbudowanych lub mniej popularnych platform internetowych.
Spring zapewnia wygodny interfejs API do tłumaczenia wyjątków specyficznych dla technologii (generowanych na przykład przez JDBC, Hibernate lub JDO) na spójne, niezaznaczone wyjątki.
Lekkie kontenery IoC wydają się być lekkie, zwłaszcza w porównaniu na przykład z kontenerami EJB. Jest to korzystne w przypadku tworzenia i wdrażania aplikacji na komputerach z ograniczoną pamięcią i zasobami procesora.
Spring zapewnia spójny interfejs zarządzania transakcjami, który można skalować w dół do transakcji lokalnej (na przykład przy użyciu jednej bazy danych) i skalować w górę do transakcji globalnych (na przykład przy użyciu JTA).

Dependency Injection (DI)

Technologia, z którą Spring jest najbardziej utożsamiana, to Dependency Injection (DI)smak Odwrócenia Kontroli. PlikInversion of Control (IoC)to pojęcie ogólne, które można wyrazić na wiele różnych sposobów. Dependency Injection to tylko jeden konkretny przykład odwrócenia kontroli.

Pisząc złożoną aplikację Java, klasy aplikacji powinny być jak najbardziej niezależne od innych klas Java, aby zwiększyć możliwość ponownego użycia tych klas i testowania ich niezależnie od innych klas podczas testów jednostkowych. Dependency Injection pomaga w sklejaniu tych klas ze sobą i jednocześnie utrzymaniu ich niezależności.

Czym dokładnie jest wstrzykiwanie zależności? Spójrzmy na te dwa słowa oddzielnie. Tutaj część zależności przekłada się na skojarzenie między dwiema klasami. Na przykład klasa A jest zależna od klasy B. Teraz spójrzmy na drugą część, wtrysk. Wszystko to oznacza, że klasa B zostanie wstrzyknięta do klasy A przez IoC.

Wstrzykiwanie zależności może się zdarzyć podczas przekazywania parametrów do konstruktora lub po zakończeniu konstrukcji przy użyciu metod ustawiających. Ponieważ Dependency Injection jest sercem Spring Framework, wyjaśnimy tę koncepcję w osobnym rozdziale z odpowiednim przykładem.

Programowanie zorientowane na aspekt (AOP)

Jednym z kluczowych elementów Spring jest Aspect Oriented Programming (AOP)struktura. Nazywa się funkcje, które obejmują wiele punktów aplikacjicross-cutting concernsa te przekrojowe problemy są koncepcyjnie oddzielone od logiki biznesowej aplikacji. Istnieje wiele typowych dobrych przykładów aspektów, w tym rejestrowanie, deklaratywne transakcje, bezpieczeństwo, buforowanie itp.

Kluczową jednostką modułowości w OOP jest klasa, podczas gdy w AOP jednostką modułowości jest aspekt. DI pomaga oddzielić obiekty aplikacji od siebie, a AOP pomaga oddzielić zagadnienia związane z cięciami poprzecznymi od obiektów, na które one wpływają.

Moduł AOP Spring Framework zapewnia zorientowaną aspektowo implementację programowania, umożliwiającą definiowanie przechwytywaczy metod i punktów przecięcia w celu czystego oddzielenia kodu, który implementuje funkcje, które powinny być rozdzielone. Więcej o koncepcjach Spring AOP omówimy w osobnym rozdziale.

Spring może być potencjalnym punktem kompleksowej obsługi wszystkich aplikacji korporacyjnych. Jednak Spring jest modułowy, dzięki czemu możesz wybierać i wybierać odpowiednie moduły, bez konieczności dodawania pozostałych. Poniższa sekcja zawiera szczegółowe informacje o wszystkich modułach dostępnych w Spring Framework.

Spring Framework zawiera około 20 modułów, których można używać w zależności od wymagań aplikacji.

Pojemnik na rdzeń

Kontener Core składa się z modułów Core, Beans, Context i Expression Language, których szczegóły są następujące:

Plik Core Moduł zapewnia podstawowe części frameworka, w tym funkcje IoC i Dependency Injection.
Plik Bean Moduł zapewnia BeanFactory, czyli wyrafinowaną implementację wzorca fabrycznego.
Plik Contextmoduł opiera się na solidnej podstawie dostarczonej przez moduły Core i Beans i jest nośnikiem dostępu do dowolnych obiektów zdefiniowanych i skonfigurowanych. Interfejs ApplicationContext jest centralnym punktem modułu Context.
Plik SpEL Moduł zapewnia potężny język wyrażeń do wykonywania zapytań i manipulowania wykresem obiektu w czasie wykonywania.

Dostęp do danych / integracja

Warstwa dostępu do danych / integracji składa się z modułów JDBC, ORM, OXM, JMS i Transaction, których szczegóły są następujące -

Plik JDBC Moduł zapewnia warstwę abstrakcji JDBC, która eliminuje potrzebę żmudnego kodowania związanego z JDBC.
Plik ORM Moduł zapewnia warstwy integracyjne dla popularnych interfejsów API mapowania obiektowo-relacyjnego, w tym JPA, JDO, Hibernate i iBatis.
Plik OXM Moduł zapewnia warstwę abstrakcji, która obsługuje implementacje mapowania obiektów / XML dla JAXB, Castor, XMLBeans, JiBX i XStream.
Usługa wiadomości Java JMS moduł zawiera funkcje do tworzenia i konsumowania wiadomości.
Plik Transaction moduł obsługuje programowe i deklaratywne zarządzanie transakcjami dla klas, które implementują specjalne interfejsy i dla wszystkich Twoich POJO.

Sieć

Warstwa WWW składa się z modułów WWW, Web-MVC, Web-Socket i Web-Portlet, których szczegóły są następujące:

Plik Web Moduł zapewnia podstawowe funkcje integracji zorientowanej na sieć, takie jak wieloczęściowe przesyłanie plików i inicjalizacja kontenera IoC przy użyciu detektorów serwletów i kontekstu aplikacji zorientowanej na sieć.
Plik Web-MVC Moduł zawiera implementację Springa Model-View-Controller (MVC) dla aplikacji internetowych.
Plik Web-Socket moduł zapewnia obsługę opartej o WebSocket, dwukierunkowej komunikacji pomiędzy klientem a serwerem w aplikacjach webowych.
Plik Web-Portlet Moduł zapewnia implementację MVC do wykorzystania w środowisku portletów i odzwierciedla funkcjonalność modułu Web-Servlet.

Różne

Istnieje kilka innych ważnych modułów, takich jak AOP, Aspects, Instrumentation, Web i Test, których szczegóły są następujące -

Plik AOP Moduł zapewnia implementację programowania zorientowaną na aspekty, umożliwiającą definiowanie przechwytywaczy metod i skrótów w celu czystego oddzielenia kodu, który implementuje funkcje, które powinny być rozdzielone.
Plik Aspects moduł zapewnia integrację z AspectJ, który jest ponownie potężnym i dojrzałym frameworkiem AOP.
Plik Instrumentation Moduł zapewnia obsługę instrumentacji klas i implementacje ładowania klas do wykorzystania w niektórych serwerach aplikacji.
Plik MessagingModuł zapewnia obsługę STOMP jako podprotokołu WebSocket do wykorzystania w aplikacjach. Obsługuje również model programowania adnotacji do trasowania i przetwarzania komunikatów STOMP od klientów WebSocket.
Plik Test moduł wspiera testowanie komponentów Springa za pomocą frameworków JUnit lub TestNG.

W tym rozdziale dowiesz się, jak przygotować środowisko programistyczne do rozpoczęcia pracy z Spring Framework. Nauczy Cię również, jak skonfigurować JDK, Tomcat i Eclipse na swoim komputerze przed skonfigurowaniem Spring Framework -

Krok 1 - Skonfiguruj zestaw Java Development Kit (JDK)

Najnowszą wersję pakietu SDK można pobrać z witryny Oracle Java - Java SE Downloads. Znajdziesz instrukcje instalacji JDK w pobranych plikach, postępuj zgodnie z podanymi instrukcjami, aby zainstalować i skonfigurować instalację. Na koniec ustaw zmienne środowiskowe PATH i JAVA_HOME, aby odwoływały się do katalogu zawierającego elementy java i javac, zazwyczaj odpowiednio katalog_instalacyjny_java / bin i katalog_instalacyjny_java.

Jeśli używasz systemu Windows i zainstalowałeś zestaw JDK w C: \ jdk1.6.0_15, musisz umieścić następujący wiersz w pliku C: \ autoexec.bat.

set PATH=C:\jdk1.6.0_15\bin;%PATH% 
set JAVA_HOME=C:\jdk1.6.0_15

Alternatywnie w systemie Windows NT / 2000 / XP należy kliknąć prawym przyciskiem myszy Mój komputer, wybrać Właściwości → Zaawansowane → Zmienne środowiskowe. Następnie musisz zaktualizować wartość PATH i kliknąć przycisk OK.

W systemie Unix (Solaris, Linux itp.), Jeśli SDK jest zainstalowany w /usr/local/jdk1.6.0_15 i używasz powłoki C, będziesz musiał umieścić następujące elementy w swoim pliku .cshrc.

setenv PATH /usr/local/jdk1.6.0_15/bin:$PATH 
setenv JAVA_HOME /usr/local/jdk1.6.0_15

Alternatywnie, jeśli używasz zintegrowanego środowiska programistycznego (IDE), takiego jak Borland JBuilder, Eclipse, IntelliJ IDEA lub Sun ONE Studio, będziesz musiał skompilować i uruchomić prosty program, aby potwierdzić, że IDE wie, gdzie zainstalowałeś Javę. W przeciwnym razie będziesz musiał przeprowadzić odpowiednią konfigurację, jak podano w dokumencie IDE.

Krok 2 - Zainstaluj Apache Common Logging API

Możesz pobrać najnowszą wersję Apache Commons Logging API z https://commons.apache.org/logging/. Po pobraniu instalacji rozpakuj dystrybucję binarną w dogodnej lokalizacji. Na przykład w C: \ commons-logging-1.1.1 w systemie Windows lub /usr/local/commons-logging-1.1.1 w systemie Linux / Unix. W tym katalogu będą znajdować się następujące pliki jar i inne dokumenty pomocnicze itp.

Upewnij się, że poprawnie ustawiłeś zmienną CLASSPATH w tym katalogu, w przeciwnym razie napotkasz problem podczas uruchamiania aplikacji.

Krok 3 - Skonfiguruj Eclipse IDE

Wszystkie przykłady w tym samouczku zostały napisane przy użyciu Eclipse IDE. Dlatego sugerujemy, abyś miał zainstalowaną najnowszą wersję Eclipse na swoim komputerze.

Aby zainstalować Eclipse IDE, pobierz najnowsze pliki binarne Eclipse z https://www.eclipse.org/downloads/. Po pobraniu instalacji rozpakuj dystrybucję binarną w dogodnej lokalizacji. Na przykład w C: \ eclipse w systemie Windows lub / usr / local / eclipse w systemie Linux / Unix i na koniec ustaw odpowiednio zmienną PATH.

Eclipse można uruchomić, wykonując następujące polecenia na komputerze z systemem Windows lub klikając dwukrotnie plik eclipse.exe

%C:\eclipse\eclipse.exe

Eclipse można uruchomić, wykonując następujące polecenia na komputerze z systemem Unix (Solaris, Linux itp.) -

$/usr/local/eclipse/eclipse

Po udanym uruchomieniu, jeśli wszystko jest w porządku, powinien wyświetlić następujący wynik -

Krok 4 - Skonfiguruj biblioteki Spring Framework

Teraz, jeśli wszystko jest w porządku, możesz przystąpić do konfigurowania frameworka Spring. Poniżej przedstawiono proste kroki, aby pobrać i zainstalować framework na swoim komputerze.

Wybierz, czy chcesz zainstalować Spring w systemie Windows czy Unix, a następnie przejdź do następnego kroku, aby pobrać plik .zip dla systemu Windows i plik .tz dla systemu Unix.
Pobierz najnowszą wersję plików binarnych platformy Spring z witryny https://repo.spring.io/release/org/springframework/spring.
W czasie tworzenia tego samouczka spring-framework-4.1.6.RELEASE-dist.zipzostał pobrany na komputer z systemem Windows. Po rozpakowaniu pobranego pliku daje następującą strukturę katalogów wewnątrz E: \ spring.

W katalogu znajdziesz wszystkie biblioteki Springa E:\spring\libs. Upewnij się, że poprawnie ustawiłeś zmienną CLASSPATH w tym katalogu, w przeciwnym razie napotkasz problem podczas uruchamiania aplikacji. Jeśli używasz Eclipse, nie jest wymagane ustawianie CLASSPATH, ponieważ wszystkie ustawienia będą wykonywane za pośrednictwem Eclipse.

Kiedy skończysz z tym ostatnim krokiem, możesz przejść do pierwszego przykładu wiosennego w następnym rozdziale.

Zacznijmy od właściwego programowania w Spring Framework. Zanim zaczniesz pisać swój pierwszy przykład przy użyciu frameworka Spring, musisz upewnić się, że środowisko Spring zostało poprawnie skonfigurowane, jak wyjaśniono w rozdziale Spring - Konfiguracja środowiska . Zakładamy również, że masz trochę praktycznej wiedzy na temat Eclipse IDE.

Przejdźmy teraz do napisania prostej aplikacji wiosennej, która wyświetli napis „Hello World!” lub jakikolwiek inny komunikat oparty na konfiguracji wykonanej w pliku konfiguracyjnym Spring Beans.

Krok 1 - Utwórz projekt Java

Pierwszym krokiem jest stworzenie prostego projektu Java przy użyciu Eclipse IDE. Postępuj zgodnie z opcjąFile → New → Project i na koniec wybierz Java Projectkreator z listy kreatorów. Teraz nazwij swój projekt jakoHelloSpring używając okna kreatora w następujący sposób -

Po pomyślnym utworzeniu projektu będziesz mieć następującą zawartość w swoim Project Explorer -

Krok 2 - Dodaj wymagane biblioteki

W drugim kroku dodajmy do naszego projektu Spring Framework i wspólne biblioteki API logowania. Aby to zrobić, kliknij prawym przyciskiem myszy nazwę projektuHelloSpring a następnie wykonaj następującą opcję dostępną w menu kontekstowym - Build Path → Configure Build Path aby wyświetlić okno ścieżki budowania języka Java w następujący sposób -

Teraz użyj Add External JARs przycisk dostępny pod Libraries aby dodać następujące podstawowe pliki JAR z katalogów instalacyjnych Spring Framework i Common Logging -

commons-logging-1.1.1
spring-aop-4.1.6.RELEASE
spring-aspects-4.1.6.RELEASE
spring-beans-4.1.6.RELEASE
spring-context-4.1.6.RELEASE
spring-context-support-4.1.6.RELEASE
spring-core-4.1.6.RELEASE
spring-expression-4.1.6.RELEASE
spring-instrument-4.1.6.RELEASE
spring-instrument-tomcat-4.1.6.RELEASE
spring-jdbc-4.1.6.RELEASE
spring-jms-4.1.6.RELEASE
spring-messaging-4.1.6.RELEASE
spring-orm-4.1.6.RELEASE
spring-oxm-4.1.6.RELEASE
spring-test-4.1.6.RELEASE
spring-tx-4.1.6.RELEASE
spring-web-4.1.6.RELEASE
spring-webmvc-4.1.6.RELEASE
spring-webmvc-portlet-4.1.6.RELEASE
spring-websocket-4.1.6.RELEASE

Krok 3 - Utwórz pliki źródłowe

Teraz stwórzmy rzeczywiste pliki źródłowe w ramach HelloSpringprojekt. Najpierw musimy utworzyć pakiet o nazwiecom.tutorialspoint. Aby to zrobić, kliknij prawym przyciskiem myszysrc w sekcji eksploratora pakietów i podążaj za opcją - New → Package.

Następnie stworzymy HelloWorld.java i MainApp.java pliki w pakiecie com.tutorialspoint.

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ść drugiego pliku MainApp.java -

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
   }
}

Na temat programu głównego należy zwrócić uwagę na dwie ważne kwestie:

Pierwszym krokiem jest stworzenie kontekstu aplikacji, w którym wykorzystaliśmy framework API ClassPathXmlApplicationContext(). To API ładuje plik konfiguracyjny fasoli i ostatecznie w oparciu o dostarczone API zajmuje się tworzeniem i inicjalizacją wszystkich obiektów, tj. Beanów wymienionych w pliku konfiguracyjnym.
Drugi krok służy do uzyskania wymaganej fasoli za pomocą getBean()metoda tworzonego kontekstu. Ta metoda używa identyfikatora komponentu bean w celu zwrócenia ogólnego obiektu, który ostatecznie można rzutować na rzeczywisty obiekt. Gdy masz już obiekt, możesz użyć tego obiektu do wywołania dowolnej metody klasy.

Krok 4 - Utwórz plik konfiguracyjny Bean

Musisz utworzyć plik konfiguracyjny Bean, który jest plikiem XML i działa jak cement, który skleja ziarna, czyli klasy razem. Ten plik musi zostać utworzony w ramachsrc katalog, jak pokazano na poniższym zrzucie ekranu -

Zwykle programiści nazywają ten plik jako Beans.xml, ale możesz wybrać dowolne imię. Musisz upewnić się, że ten plik jest dostępny w CLASSPATH i użyć tej samej nazwy w głównej aplikacji podczas tworzenia kontekstu aplikacji, jak pokazano w pliku MainApp.java.

Plik Beans.xml służy do przypisywania unikalnych identyfikatorów do różnych komponentów bean i do kontrolowania tworzenia obiektów o różnych wartościach bez wpływu na żaden z plików źródłowych Spring. Na przykład za pomocą następującego pliku można przekazać dowolną wartość zmiennej „komunikat” i wydrukować różne wartości komunikatu bez wpływu na pliki HelloWorld.java i MainApp.java. Zobaczmy, jak to działa -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
      <property name = "message" value = "Hello World!"/>
   </bean>

</beans>

Kiedy aplikacja Spring zostanie załadowana do pamięci, Framework korzysta z powyższego pliku konfiguracyjnego, aby utworzyć wszystkie zdefiniowane komponenty bean i przypisać im unikalny identyfikator, zgodnie z definicją w <bean>etykietka. Możesz użyć<property> tag, aby przekazać wartości różnych zmiennych używanych podczas tworzenia obiektu.

Krok 5 - Uruchomienie programu

Gdy skończysz tworzyć pliki konfiguracyjne źródła i komponentów bean, możesz przystąpić do tego kroku, czyli kompilacji i uruchomienia programu. Aby to zrobić, pozostaw aktywną kartę pliku MainApp.Java i użyj jednego z nichRun opcja dostępna w Eclipse IDE lub użyj Ctrl + F11 skompilować i uruchomić MainApppodanie. Jeśli wszystko jest w porządku z Twoją aplikacją, spowoduje to wyświetlenie następującego komunikatu w konsoli Eclipse IDE -

Your Message : Hello World!

Gratulacje, pomyślnie utworzyłeś swoją pierwszą aplikację wiosenną. Elastyczność powyższej aplikacji Spring można zobaczyć, zmieniając wartość właściwości „message” i zachowując oba pliki źródłowe bez zmian.

Kontener Spring jest rdzeniem Spring Framework. Kontener utworzy obiekty, połączy je ze sobą, skonfiguruje i zarządza ich pełnym cyklem życia od stworzenia do zniszczenia. Kontener Spring używa DI do zarządzania komponentami tworzącymi aplikację. Obiekty te nazywane są wiosennymi fasolkami, które omówimy w następnym rozdziale.

Kontener pobiera instrukcje dotyczące obiektów do utworzenia wystąpienia, skonfigurowania i złożenia, odczytując dostarczone metadane konfiguracji. Metadane konfiguracji mogą być reprezentowane przez XML, adnotacje Java lub kod Java. Poniższy diagram przedstawia ogólny obraz działania Spring. Kontener Spring IoC wykorzystuje klasy Java POJO i metadane konfiguracyjne w celu utworzenia w pełni skonfigurowanego i wykonywalnego systemu lub aplikacji.

Spring udostępnia dwa różne typy pojemników.

Sr.No.	Pojemnik i opis
1	Pojemnik Spring BeanFactory Jest to najprostszy kontener zapewniający podstawowe wsparcie dla DI i jest definiowany przez interfejs org.springframework.beans.factory.BeanFactory . BeanFactory i powiązane interfejsy, takie jak BeanFactoryAware, InitializingBean, DisposableBean, są nadal obecne w Spring w celu zapewnienia wstecznej kompatybilności z dużą liczbą platform innych firm, które integrują się ze Spring.
2	Spring ApplicationContext Container Ten kontener dodaje więcej funkcji specyficznych dla przedsiębiorstwa, takich jak możliwość rozwiązywania komunikatów tekstowych z pliku właściwości i możliwość publikowania zdarzeń aplikacji do zainteresowanych detektorów zdarzeń. Ten kontener jest definiowany przez interfejs org.springframework.context.ApplicationContext .

ApplicationContext pojemnik zawiera wszystkie funkcjonalności BeanFactory pojemnika, więc zaleca się zwykle w ciągu BeanFactory . BeanFactory może być nadal używany do lekkich aplikacji, takich jak urządzenia mobilne lub aplikacje oparte na apletach, w których ilość danych i szybkość są znaczące.

Obiekty stanowiące szkielet aplikacji i zarządzane przez kontener Spring IoC są nazywane beans. Bean to obiekt, który jest tworzony, składany i zarządzany w inny sposób przez kontener Spring IoC. Te komponenty bean są tworzone za pomocą metadanych konfiguracji dostarczonych do kontenera. Na przykład w postaci definicji XML <bean />, które widzieliście już w poprzednich rozdziałach.

Definicja fasoli zawiera informacje o nazwie configuration metadata, który jest potrzebny, aby kontener wiedział:

Jak stworzyć fasolę
Szczegóły cyklu życia Bean
Zależności Beana

Wszystkie powyższe metadane konfiguracji przekładają się na zestaw następujących właściwości, które składają się na definicję każdego ziarna.

Sr.No.	Właściwości i opis
1	class Ten atrybut jest obowiązkowy i określa klasę fasoli, która ma zostać użyta do jej utworzenia.
2	name Ten atrybut jednoznacznie określa identyfikator ziarna. W metadanych konfiguracyjnych opartych na języku XML do określenia identyfikatorów komponentów bean używa się atrybutów id i / lub name.
3	scope Ten atrybut określa zakres obiektów utworzonych na podstawie określonej definicji fasoli i zostanie omówiony w rozdziale zakresy fasoli.
4	constructor-arg Służy do wstrzykiwania zależności i zostanie omówione w kolejnych rozdziałach.
5	properties Służy do wstrzykiwania zależności i zostanie omówione w kolejnych rozdziałach.
6	autowiring mode Służy do wstrzykiwania zależności i zostanie omówione w kolejnych rozdziałach.
7	lazy-initialization mode Fasola inicjowana z opóźnieniem informuje kontener IoC, aby utworzył wystąpienie komponentu bean, gdy jest ono po raz pierwszy żądane, a nie podczas uruchamiania.
8	initialization method Wywołanie zwrotne, które ma zostać wywołane zaraz po ustawieniu przez kontener wszystkich niezbędnych właściwości komponentu bean. Zostanie to omówione w rozdziale dotyczącym cyklu życia fasoli.
9	destruction method Wywołanie zwrotne, które ma być używane, gdy kontener zawierający ziarno zostanie zniszczony. Zostanie to omówione w rozdziale dotyczącym cyklu życia fasoli.

Metadane konfiguracji sprężyny

Kontener Spring IoC jest całkowicie oddzielony od formatu, w którym faktycznie zapisywane są te metadane konfiguracji. Poniżej przedstawiono trzy ważne metody dostarczania metadanych konfiguracji do kontenera Spring:

Plik konfiguracyjny oparty na XML.
Konfiguracja oparta na adnotacjach
Konfiguracja oparta na języku Java

Widzieliście już, jak metadane konfiguracji oparte na XML są dostarczane do kontenera, ale zobaczmy inny przykład pliku konfiguracyjnego opartego na XML z różnymi definicjami komponentów bean, w tym z opóźnioną inicjalizacją, metodą inicjalizacji i metodą niszczenia -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <!-- A simple bean definition -->
   <bean id = "..." class = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- A bean definition with lazy init set on -->
   <bean id = "..." class = "..." lazy-init = "true">
      <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- A bean definition with initialization method -->
   <bean id = "..." class = "..." init-method = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- A bean definition with destruction method -->
   <bean id = "..." class = "..." destroy-method = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- more bean definitions go here -->
   
</beans>

Możesz sprawdzić Spring Hello World Example, aby dowiedzieć się, jak definiować, konfigurować i tworzyć Spring Beans.

Omówimy konfigurację opartą na adnotacjach w osobnym rozdziale. Celowo jest to omówione w osobnym rozdziale, ponieważ chcemy, abyś zrozumiał kilka innych ważnych koncepcji Springa, zanim zaczniesz programować z wtryskiem zależności Springa z adnotacjami.

Definiując <fasolę>, masz możliwość zadeklarowania zakresu dla tej fasoli. Na przykład, aby zmusić Spring do tworzenia nowej instancji fasoli za każdym razem, gdy jest ona potrzebna, należy zadeklarować atrybut scope fasoli jakoprototype. Podobnie, jeśli chcesz, aby Spring zwracał tę samą instancję bean za każdym razem, gdy jest to potrzebne, powinieneś zadeklarować atrybut scope fasoli jakosingleton.

Spring Framework obsługuje następujące pięć zakresów, z których trzy są dostępne tylko wtedy, gdy używasz ApplicationContext obsługującego sieć WWW.

Sr.No.	Zakres i opis
1	singleton Powoduje to zakres definicji komponentu bean do pojedynczego wystąpienia na kontener Spring IoC (ustawienie domyślne).
2	prototype Powoduje to, że definicja pojedynczego komponentu bean ma dowolną liczbę wystąpień obiektu.
3	request To określa zakres definicji komponentu bean do żądania HTTP. Prawidłowe tylko w kontekście kontekstu Spring ApplicationContext obsługującego sieć.
4	session To określa zakres definicji komponentu bean w sesji HTTP. Prawidłowe tylko w kontekście kontekstu Spring ApplicationContext obsługującego sieć.
5	global-session To określa zakres definicji komponentu bean do globalnej sesji HTTP. Prawidłowe tylko w kontekście kontekstu Spring ApplicationContext obsługującego sieć.

W tym rozdziale omówimy pierwsze dwa zakresy, a pozostałe trzy zostaną omówione podczas omawiania kontekstu Spring ApplicationContext obsługującego sieci WWW.

Zakres singletonowy

Jeśli zakres jest ustawiony na pojedynczy, kontener Spring IoC tworzy dokładnie jedno wystąpienie obiektu zdefiniowanego przez tę definicję fasoli. Ta pojedyncza instancja jest przechowywana w pamięci podręcznej takich pojedynczych ziaren, a wszystkie kolejne żądania i odwołania do tej nazwanej fasoli zwracają buforowany obiekt.

Zakres domyślny to zawsze pojedynczy. Jeśli jednak potrzebujesz jednego i tylko jednego wystąpienia fasoli, możesz ustawićscope właściwość do singleton w pliku konfiguracyjnym bean, jak pokazano w poniższym fragmencie kodu -

<!-- A bean definition with singleton scope -->
<bean id = "..." class = "..." scope = "singleton">
   <!-- collaborators and configuration for this bean go here -->
</bean>

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	Utwórz klasy Java HelloWorld i MainApp w pakiecie com.tutorialspoint .
4	Utwórz plik konfiguracyjny Beans Beans.xml w obszarzesrc teczka.
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ść 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.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      HelloWorld objA = (HelloWorld) context.getBean("helloWorld");

      objA.setMessage("I'm object A");
      objA.getMessage();

      HelloWorld objB = (HelloWorld) context.getBean("helloWorld");
      objB.getMessage();
   }
}

Poniżej znajduje się plik konfiguracyjny Beans.xml wymagane dla zakresu pojedynczego -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

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

</beans>

Po utworzeniu plików źródłowych i konfiguracyjnych komponentów bean uruchom aplikację. Jeśli wszystko jest w porządku z Twoją aplikacją, wydrukuje następujący komunikat -

Your Message : I'm object A
Your Message : I'm object A

Zakres prototypu

Jeśli zakres jest ustawiony na prototyp, kontener Spring IoC tworzy nową instancję komponentu bean obiektu za każdym razem, gdy zostanie wysłane żądanie dotyczące tego konkretnego komponentu bean. Z reguły należy używać zakresu prototypu dla wszystkich ziaren pełnostanowych i zakresu pojedynczego dla bezstanowych.

Aby zdefiniować zakres prototypu, możesz ustawić scope właściwość do prototype w pliku konfiguracyjnym bean, jak pokazano w poniższym fragmencie kodu -

<!-- A bean definition with prototype scope -->
<bean id = "..." class = "..." scope = "prototype">
   <!-- collaborators and configuration for this bean go here -->
</bean>

Przykład

Przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, 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	Utwórz klasy Java HelloWorld i MainApp w pakiecie com.tutorialspoint .
4	Utwórz plik konfiguracyjny Beans Beans.xml w obszarzesrc teczka.
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ść 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.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      HelloWorld objA = (HelloWorld) context.getBean("helloWorld");

      objA.setMessage("I'm object A");
      objA.getMessage();

      HelloWorld objB = (HelloWorld) context.getBean("helloWorld");
      objB.getMessage();
   }
}

Poniżej znajduje się plik konfiguracyjny Beans.xml wymagane dla zakresu prototypu -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

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

</beans>

Po utworzeniu plików źródłowych i konfiguracyjnych komponentów bean uruchom aplikację. Jeśli wszystko jest w porządku z Twoją aplikacją, wydrukuje następujący komunikat -

Your Message : I'm object A
Your Message : null

Cykl życia fasoli wiosennej jest łatwy do zrozumienia. Podczas tworzenia wystąpienia komponentu bean może być konieczne wykonanie pewnej inicjalizacji, aby uzyskać stan nadający się do użytku. Podobnie, gdy ziarno nie jest już potrzebne i jest wyjmowane z pojemnika, może być wymagane pewne czyszczenie.

Chociaż istnieją listy czynności, które mają miejsce za kulisami między momentem instancji fasoli a jej zniszczeniem, w tym rozdziale omówimy tylko dwie ważne metody wywołania zwrotnego cyklu życia fasoli, które są wymagane w momencie inicjalizacji fasoli i jej zniszczenia.

Aby zdefiniować konfigurację i rozbiór fasoli, po prostu deklarujemy <fasola> z initmethod i / lub destroy-methodparametry. Atrybut init-method określa metodę, która ma zostać wywołana w komponencie bean natychmiast po utworzeniu instancji. Podobnie destroymethod określa metodę, która jest wywoływana tuż przed usunięciem ziarna z kontenera.

Inicjalizacja wywołań zwrotnych

Interfejs org.springframework.beans.factory.InitializingBean określa jedną metodę -

void afterPropertiesSet() throws Exception;

W ten sposób możesz po prostu zaimplementować powyższy interfejs, a prace inicjalizacyjne można wykonać wewnątrz metody afterPropertiesSet () w następujący sposób -

public class ExampleBean implements InitializingBean {
   public void afterPropertiesSet() {
      // do some initialization work
   }
}

W przypadku metadanych konfiguracji opartych na języku XML można użyć rozszerzenia init-methodatrybut, aby określić nazwę metody, która ma nieważną sygnaturę bez argumentów. Na przykład -

<bean id = "exampleBean" class = "examples.ExampleBean" init-method = "init"/>

Poniżej znajduje się definicja klasy -

public class ExampleBean {
   public void init() {
      // do some initialization work
   }
}

Callback zniszczenia

Org.springframework.beans.factory.DisposableBean interfejs określa jedną metodę -

void destroy() throws Exception;

W ten sposób możesz po prostu zaimplementować powyższy interfejs, a prace finalizacyjne można wykonać wewnątrz metody zniszcz () w następujący sposób -

public class ExampleBean implements DisposableBean {
   public void destroy() {
      // do some destruction work
   }
}

W przypadku metadanych konfiguracji opartych na języku XML można użyć rozszerzenia destroy-methodatrybut, aby określić nazwę metody, która ma nieważną sygnaturę bez argumentów. Na przykład -

<bean id = "exampleBean" class = "examples.ExampleBean" destroy-method = "destroy"/>

Poniżej znajduje się definicja klasy -

public class ExampleBean {
   public void destroy() {
      // do some destruction work
   }
}

Jeśli używasz kontenera IoC Springa w środowisku aplikacji innych niż internetowe; na przykład w bogatym środowisku pulpitu klienta rejestruje się punkt zaczepienia zamykania w maszynie JVM. Takie postępowanie zapewnia bezpieczne zamknięcie i wywołuje odpowiednie metody niszczenia w komponentach bean singleton, dzięki czemu wszystkie zasoby zostaną zwolnione.

Zaleca się, aby nie używać wywołań zwrotnych InitializingBean ani DisposableBean, ponieważ konfiguracja XML zapewnia dużą elastyczność pod względem nazewnictwa metody.

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	Utwórz klasy Java HelloWorld i MainApp w pakiecie com.tutorialspoint .
4	Utwórz plik konfiguracyjny Beans Beans.xml w obszarzesrc teczka.
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ść 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);
   }
   public void init(){
      System.out.println("Bean is going through init.");
   }
   public void destroy() {
      System.out.println("Bean will destroy now.");
   }
}

Poniżej znajduje się zawartość MainApp.javaplik. Tutaj musisz zarejestrować hak zamykającyregisterShutdownHook()metoda zadeklarowana w klasie AbstractApplicationContext. Zapewni to bezpieczne zamknięcie i wywołanie odpowiednich metod niszczenia.

package com.tutorialspoint;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
      context.registerShutdownHook();
   }
}

Poniżej znajduje się plik konfiguracyjny Beans.xml wymagane do inicjowania i niszczenia metod -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" init-method = "init" 
      destroy-method = "destroy">
      <property name = "message" value = "Hello World!"/>
   </bean>

</beans>

Po utworzeniu plików źródłowych i konfiguracyjnych komponentów bean uruchom aplikację. Jeśli wszystko jest w porządku z Twoją aplikacją, wydrukuje następujący komunikat -

Bean is going through init.
Your Message : Hello World!
Bean will destroy now.

Domyślna inicjalizacja i niszczenie metod

Jeśli masz zbyt wiele fasoli z inicjalizacją i / lub niszczeniem metod o tej samej nazwie, nie musisz deklarować init-method i destroy-methodna każdej fasoli. Zamiast tego platforma zapewnia elastyczność konfiguracji takiej sytuacji przy użyciudefault-init-method i default-destroy-method atrybuty elementu <beans> w następujący sposób -

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
   default-init-method = "init" 
   default-destroy-method = "destroy">

   <bean id = "..." class = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>
   
</beans>

Plik BeanPostProcessor interfejs definiuje metody wywołania zwrotnego, które można zaimplementować w celu zapewnienia własnej logiki tworzenia instancji, logiki rozwiązywania zależności itp. Można również zaimplementować niestandardową logikę po zakończeniu tworzenia instancji, konfigurowania i inicjowania komponentu przez kontener Springa przez podłączenie jednej lub więcej implementacji BeanPostProcessor .

Możesz skonfigurować wiele interfejsów BeanPostProcessor i możesz kontrolować kolejność, w jakiej te interfejsy BeanPostProcessor są wykonywane, ustawiając order pod warunkiem, że BeanPostProcessor implementuje Ordered berło.

BeanPostProcessors działają na instancjach bean (lub object), co oznacza, że kontener Spring IoC tworzy instancję bean, a następnie interfejsy BeanPostProcessor wykonują swoją pracę.

Na ApplicationContext automatycznie wykrywa wszystkie ziarna, które są zdefiniowane za pomocą implementacji BeanPostProcessor interfejs i rejestruje te ziarna jako postprocesory, aby były następnie odpowiednio wywoływane przez kontener po ich utworzeniu.

Przykład

Poniższe przykłady pokazują, jak pisać, rejestrować i używać BeanPostProcessors w kontekście ApplicationContext.

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	Utwórz klasy Java HelloWorld , InitHelloWorld i MainApp w pakiecie com.tutorialspoint .
4	Utwórz plik konfiguracyjny Beans Beans.xml w obszarzesrc teczka.
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ść 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);
   }
   public void init(){
      System.out.println("Bean is going through init.");
   }
   public void destroy(){
      System.out.println("Bean will destroy now.");
   }
}

To jest bardzo podstawowy przykład implementacji BeanPostProcessor, który wypisuje nazwę komponentu bean przed i po inicjalizacji dowolnego komponentu bean. Możesz zaimplementować bardziej złożoną logikę przed i po zainicjowaniu komponentu bean, ponieważ masz dostęp do obiektu bean wewnątrz obu metod postprocesora.

Oto treść InitHelloWorld.java plik -

package com.tutorialspoint;

import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.BeansException;

public class InitHelloWorld implements BeanPostProcessor {
   public Object postProcessBeforeInitialization(Object bean, String beanName) 
      throws BeansException {
      
      System.out.println("BeforeInitialization : " + beanName);
      return bean;  // you can return any other object as well
   }
   public Object postProcessAfterInitialization(Object bean, String beanName) 
      throws BeansException {
      
      System.out.println("AfterInitialization : " + beanName);
      return bean;  // you can return any other object as well
   }
}

package com.tutorialspoint;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
      context.registerShutdownHook();
   }
}

Poniżej znajduje się plik konfiguracyjny Beans.xml wymagane do inicjowania i niszczenia metod -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld"
      init-method = "init" destroy-method = "destroy">
      <property name = "message" value = "Hello World!"/>
   </bean>

   <bean class = "com.tutorialspoint.InitHelloWorld" />

</beans>

Gdy skończysz tworzyć pliki źródłowe i konfiguracyjne bean, uruchom aplikację. Jeśli wszystko jest w porządku z Twoją aplikacją, wydrukuje następujący komunikat -

BeforeInitialization : helloWorld
Bean is going through init.
AfterInitialization : helloWorld
Your Message : Hello World!
Bean will destroy now.

Definicja komponentu bean może zawierać wiele informacji konfiguracyjnych, w tym argumenty konstruktora, wartości właściwości i informacje specyficzne dla kontenera, takie jak metoda inicjalizacji, nazwa metody fabryki statycznej i tak dalej.

Definicja podrzędnego komponentu bean dziedziczy dane konfiguracyjne z definicji nadrzędnej. Definicja podrzędna może w razie potrzeby przesłonić niektóre wartości lub dodać inne.

Dziedziczenie definicji Spring Bean nie ma nic wspólnego z dziedziczeniem klas Java, ale koncepcja dziedziczenia jest taka sama. Definicję nadrzędnego komponentu bean można zdefiniować jako szablon, a inne podrzędne ziarna mogą dziedziczyć wymaganą konfigurację z nadrzędnego komponentu bean.

Korzystając z metadanych konfiguracji opartych na języku XML, należy wskazać definicję podrzędnego komponentu bean przy użyciu rozszerzenia parent atrybut, określając nadrzędny komponent bean jako wartość tego atrybutu.

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	Utwórz klasy Java HelloWorld , HelloIndia i MainApp w pakiecie com.tutorialspoint .
4	Utwórz plik konfiguracyjny Beans Beans.xml w obszarzesrc teczka.
5	Ostatnim krokiem jest utworzenie zawartości wszystkich plików Java i pliku konfiguracyjnego Bean i uruchomienie aplikacji, jak wyjaśniono poniżej.

Poniżej znajduje się plik konfiguracyjny Beans.xmlgdzie zdefiniowaliśmy bean „helloWorld”, który ma dwie właściwości message1 i message2 . Następna fasola „helloIndia” została zdefiniowana jako element potomny fasoli „helloWorld” przy użyciu metodyparentatrybut. Podrzędny komponent bean dziedziczy właściwość message2 bez zmian , przesłania właściwość message1 i wprowadza jeszcze jedną właściwość message3 .

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
      <property name = "message1" value = "Hello World!"/>
      <property name = "message2" value = "Hello Second World!"/>
   </bean>

   <bean id ="helloIndia" class = "com.tutorialspoint.HelloIndia" parent = "helloWorld">
      <property name = "message1" value = "Hello India!"/>
      <property name = "message3" value = "Namaste India!"/>
   </bean>
</beans>

Oto treść HelloWorld.java plik -

package com.tutorialspoint;

public class HelloWorld {
   private String message1;
   private String message2;

   public void setMessage1(String message){
      this.message1 = message;
   }
   public void setMessage2(String message){
      this.message2 = message;
   }
   public void getMessage1(){
      System.out.println("World Message1 : " + message1);
   }
   public void getMessage2(){
      System.out.println("World Message2 : " + message2);
   }
}

Oto treść HelloIndia.java plik -

package com.tutorialspoint;

public class HelloIndia {
   private String message1;
   private String message2;
   private String message3;

   public void setMessage1(String message){
      this.message1 = message;
   }
   public void setMessage2(String message){
      this.message2 = message;
   }
   public void setMessage3(String message){
      this.message3 = message;
   }
   public void getMessage1(){
      System.out.println("India Message1 : " + message1);
   }
   public void getMessage2(){
      System.out.println("India Message2 : " + message2);
   }
   public void getMessage3(){
      System.out.println("India Message3 : " + message3);
   }
}

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

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      
      HelloWorld objA = (HelloWorld) context.getBean("helloWorld");
      objA.getMessage1();
      objA.getMessage2();

      HelloIndia objB = (HelloIndia) context.getBean("helloIndia");
      objB.getMessage1();
      objB.getMessage2();
      objB.getMessage3();
   }
}

Po utworzeniu plików źródłowych i konfiguracyjnych komponentów bean uruchom aplikację. Jeśli wszystko jest w porządku z Twoją aplikacją, wydrukuje następujący komunikat -

World Message1 : Hello World!
World Message2 : Hello Second World!
India Message1 : Hello India!
India Message2 : Hello Second World!
India Message3 : Namaste India!

Jeśli zauważyłeś tutaj, nie przekazaliśmy wiadomości message2 podczas tworzenia komponentu bean „helloIndia”, ale została ona przekazana z powodu dziedziczenia definicji fasoli.

Szablon definicji fasoli

Możesz utworzyć szablon definicji Bean, który może być używany przez inne definicje podrzędnych fasoli bez większego wysiłku. Podczas definiowania szablonu definicji fasoli nie należy określać plikuclass atrybut i powinien określać abstract atrybut i powinien określać atrybut abstrakcyjny o wartości true jak pokazano w poniższym fragmencie kodu -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "beanTeamplate" abstract = "true">
      <property name = "message1" value = "Hello World!"/>
      <property name = "message2" value = "Hello Second World!"/>
      <property name = "message3" value = "Namaste India!"/>
   </bean>

   <bean id = "helloIndia" class = "com.tutorialspoint.HelloIndia" parent = "beanTeamplate">
      <property name = "message1" value = "Hello India!"/>
      <property name = "message3" value = "Namaste India!"/>
   </bean>
   
</beans>

Nie można samodzielnie utworzyć wystąpienia nadrzędnego komponentu bean, ponieważ jest niekompletny, a także jest wyraźnie oznaczony jako abstrakcyjny . Gdy definicja jest tak abstrakcyjna, można jej używać tylko jako czystej definicji komponentu bean szablonu, która służy jako definicja nadrzędna dla definicji podrzędnych.

Każda aplikacja oparta na języku Java ma kilka obiektów, które współpracują ze sobą, prezentując to, co użytkownik końcowy widzi jako działającą aplikację. Pisząc złożoną aplikację Java, klasy aplikacji powinny być jak najbardziej niezależne od innych klas Java, aby zwiększyć możliwość ponownego użycia tych klas i testowania ich niezależnie od innych klas podczas testów jednostkowych. Dependency Injection (lub czasami nazywany okablowaniem) pomaga w sklejaniu tych klas ze sobą, a jednocześnie utrzymaniu ich niezależności.

Rozważ, że masz aplikację, która ma komponent edytora tekstu i chcesz zapewnić sprawdzanie pisowni. Twój standardowy kod wyglądałby mniej więcej tak -

public class TextEditor {
   private SpellChecker spellChecker;
   
   public TextEditor() {
      spellChecker = new SpellChecker();
   }
}

To, co tutaj zrobiliśmy, to stworzenie zależności między TextEditor a SpellChecker. W scenariuszu odwrócenia kontroli zamiast tego zrobilibyśmy coś takiego -

public class TextEditor {
   private SpellChecker spellChecker;
   
   public TextEditor(SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }
}

Tutaj TextEditor nie powinien przejmować się implementacją sprawdzania pisowni. SpellChecker zostanie zaimplementowany niezależnie i zostanie dostarczony do TextEditor w czasie tworzenia instancji TextEditor. Cała procedura jest kontrolowana przez Spring Framework.

Tutaj usunęliśmy całkowitą kontrolę z TextEditor i zachowaliśmy ją gdzie indziej (np. Plik konfiguracyjny XML), a zależność (tj. Klasa SpellChecker) jest wprowadzana do klasy TextEditor poprzez Class Constructor. W ten sposób przepływ kontroli został „odwrócony” przez Dependency Injection (DI), ponieważ skutecznie delegowałeś zależności do jakiegoś systemu zewnętrznego.

Drugą metodą wstrzykiwania zależności jest przejście Setter Methodsklasy TextEditor, w której utworzymy instancję SpellChecker. Ta instancja będzie używana do wywoływania metod ustawiających w celu zainicjowania właściwości TextEditor.

Zatem DI istnieje w dwóch głównych wariantach, a kolejne dwa podrozdziały obejmują oba z przykładami -

Sr.No.	Typ i opis iniekcji zależności
1	Wstrzykiwanie zależności oparte na konstruktorze Metoda DI oparta na konstruktorze jest wykonywana, gdy kontener wywołuje konstruktor klasy z wieloma argumentami, z których każdy reprezentuje zależność od drugiej klasy.
2	Wstrzykiwanie zależności na podstawie metody ustawiającej Oparte na metodzie metody DI jest realizowane przez kontener wywołujący metody ustawiające w komponentach bean po wywołaniu bezargumentowego konstruktora lub statycznej metody fabrycznej bez argumentów w celu utworzenia wystąpienia komponentu bean.

Możesz mieszać zarówno DI oparte na konstruktorze, jak i na ustawieniach, ale dobrą zasadą jest używanie argumentów konstruktora dla obowiązkowych zależności i ustawiających dla opcjonalnych zależności.

Kod jest czystszy dzięki zasadzie DI, a odsprzęganie jest bardziej efektywne, gdy obiekty są dostarczane z ich zależnościami. Obiekt nie wyszukuje swoich zależności i nie zna lokalizacji ani klasy zależności, a raczej wszystko jest obsługiwane przez Spring Framework.

Jak wiesz, wewnętrzne klasy Javy są definiowane w ramach innych klas, podobnie inner beansto ziarna, które są zdefiniowane w zakresie innego ziarna. W związku z tym element <bean /> wewnątrz elementów <property /> lub <constructor-arg /> nazywa się internal bean i jest pokazany poniżej.

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "outerBean" class = "...">
      <property name = "target">
         <bean id = "innerBean" class = "..."/>
      </property>
   </bean>

</beans>

Przykład

Przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, 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	Tworzenie klas Java TextEditor , sprawdzania pisowni i MainApp pod com.tutorialspoint opakowaniu.
4	Utwórz plik konfiguracyjny Beans Beans.xml w obszarzesrc teczka.
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ść TextEditor.java plik -

package com.tutorialspoint;

public class TextEditor {
   private SpellChecker spellChecker;
   
   // a setter method to inject the dependency.
   public void setSpellChecker(SpellChecker spellChecker) {
      System.out.println("Inside setSpellChecker." );
      this.spellChecker = spellChecker;
   }
   
   // a getter method to return spellChecker
   public SpellChecker getSpellChecker() {
      return 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.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      TextEditor te = (TextEditor) context.getBean("textEditor");
      te.spellCheck();
   }
}

Poniżej znajduje się plik konfiguracyjny Beans.xml który ma konfigurację dla wtrysku opartego na ustawieniu, ale używa inner beans -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <!-- Definition for textEditor bean using inner bean -->
   <bean id = "textEditor" class = "com.tutorialspoint.TextEditor">
      <property name = "spellChecker">
         <bean id = "spellChecker" class = "com.tutorialspoint.SpellChecker"/>
      </property>
   </bean>

</beans>

Po utworzeniu plików źródłowych i konfiguracyjnych komponentów bean uruchom aplikację. Jeśli wszystko jest w porządku z Twoją aplikacją, wydrukuje następujący komunikat -

Inside SpellChecker constructor.
Inside setSpellChecker.
Inside checkSpelling.

Widziałeś, jak skonfigurować pierwotny typ danych przy użyciu value odwołania do atrybutów i obiektów przy użyciu refatrybut tagu <property> w pliku konfiguracyjnym Bean. Oba przypadki dotyczą przekazywania wartości pojedynczej fasoli.

A co, jeśli chcesz przekazywać wartości w liczbie mnogiej, takie jak typy kolekcji Java, takie jak lista, zestaw, mapa i właściwości. Aby poradzić sobie z tą sytuacją, Spring oferuje cztery typy elementów konfiguracji kolekcji, które są następujące:

Sr.No	Element i opis
1	<list> Pomaga to w okablowaniu, tj. Wprowadzaniu listy wartości, umożliwiając duplikaty.
2	<set> Pomaga to w okablowaniu zestawu wartości, ale bez żadnych duplikatów.
3	<map> Można tego użyć do wstrzyknięcia kolekcji par nazwa-wartość, gdzie nazwa i wartość mogą być dowolnego typu.
4	<props> Można to wykorzystać do wstrzyknięcia kolekcji par nazwa-wartość, w których nazwa i wartość są ciągami.

Możesz użyć <list> lub <set>, aby połączyć dowolną implementację java.util.Collection lub array.

Napotkasz dwie sytuacje (a) przekazanie bezpośrednich wartości kolekcji i (b) przekazanie referencji fasoli jako jednego z elementów kolekcji.

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	Utwórz klasy Java JavaCollection i MainApp w pakiecie com.tutorialspoint .
4	Utwórz plik konfiguracyjny Beans Beans.xml w obszarzesrc teczka.
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ść JavaCollection.java plik -

package com.tutorialspoint;
import java.util.*;

public class JavaCollection {
   List addressList;
   Set  addressSet;
   Map  addressMap;
   Properties addressProp;

   // a setter method to set List
   public void setAddressList(List addressList) {
      this.addressList = addressList;
   }
   
   // prints and returns all the elements of the list.
   public List getAddressList() {
      System.out.println("List Elements :"  + addressList);
      return addressList;
   }
   
   // a setter method to set Set
   public void setAddressSet(Set addressSet) {
      this.addressSet = addressSet;
   }
   
   // prints and returns all the elements of the Set.
   public Set getAddressSet() {
      System.out.println("Set Elements :"  + addressSet);
      return addressSet;
   }
   
   // a setter method to set Map
   public void setAddressMap(Map addressMap) {
      this.addressMap = addressMap;
   }
   
   // prints and returns all the elements of the Map.
   public Map getAddressMap() {
      System.out.println("Map Elements :"  + addressMap);
      return addressMap;
   }
   
   // a setter method to set Property
   public void setAddressProp(Properties addressProp) {
      this.addressProp = addressProp;
   }
   
   // prints and returns all the elements of the Property.
   public Properties getAddressProp() {
      System.out.println("Property Elements :"  + addressProp);
      return addressProp;
   }
}

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

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      JavaCollection jc=(JavaCollection)context.getBean("javaCollection");

      jc.getAddressList();
      jc.getAddressSet();
      jc.getAddressMap();
      jc.getAddressProp();
   }
}

Poniżej znajduje się plik konfiguracyjny Beans.xml który ma konfigurację dla wszystkich typów kolekcji -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <!-- Definition for javaCollection -->
   <bean id = "javaCollection" class = "com.tutorialspoint.JavaCollection">
      
      <!-- results in a setAddressList(java.util.List) call -->
      <property name = "addressList">
         <list>
            <value>INDIA</value>
            <value>Pakistan</value>
            <value>USA</value>
            <value>USA</value>
         </list>
      </property>

      <!-- results in a setAddressSet(java.util.Set) call -->
      <property name = "addressSet">
         <set>
            <value>INDIA</value>
            <value>Pakistan</value>
            <value>USA</value>
            <value>USA</value>
         </set>
      </property>

      <!-- results in a setAddressMap(java.util.Map) call -->
      <property name = "addressMap">
         <map>
            <entry key = "1" value = "INDIA"/>
            <entry key = "2" value = "Pakistan"/>
            <entry key = "3" value = "USA"/>
            <entry key = "4" value = "USA"/>
         </map>
      </property>
      
      <!-- results in a setAddressProp(java.util.Properties) call -->
      <property name = "addressProp">
         <props>
            <prop key = "one">INDIA</prop>
            <prop key = "one">INDIA</prop>
            <prop key = "two">Pakistan</prop>
            <prop key = "three">USA</prop>
            <prop key = "four">USA</prop>
         </props>
      </property>
   </bean>

</beans>

Po utworzeniu plików źródłowych i konfiguracyjnych komponentów bean uruchom aplikację. Jeśli wszystko jest w porządku z Twoją aplikacją, wydrukuje następujący komunikat -

List Elements :[INDIA, Pakistan, USA, USA] 
Set Elements :[INDIA, Pakistan, USA] 
ap Elements :{1 = INDIA, 2 = Pakistan, 3 = USA, 4 = USA} 
Property Elements :{two = Pakistan, one = INDIA, three = USA, four = USA}

Wstrzykiwanie odniesień do fasoli

Poniższa definicja Bean pomoże ci zrozumieć, jak wstrzyknąć odwołania do fasoli jako jeden z elementów kolekcji. Nawet możesz mieszać odwołania i wartości razem, jak pokazano w poniższym fragmencie kodu -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <!-- Bean Definition to handle references and values -->
   <bean id = "..." class = "...">

      <!-- Passing bean reference  for java.util.List -->
      <property name = "addressList">
         <list>
            <ref bean = "address1"/>
            <ref bean = "address2"/>
            <value>Pakistan</value>
         </list>
      </property>
      
      <!-- Passing bean reference  for java.util.Set -->
      <property name = "addressSet">
         <set>
            <ref bean = "address1"/>
            <ref bean = "address2"/>
            <value>Pakistan</value>
         </set>
      </property>
      
      <!-- Passing bean reference  for java.util.Map -->
      <property name = "addressMap">
         <map>
            <entry key = "one" value = "INDIA"/>
            <entry key = "two" value-ref = "address1"/>
            <entry key = "three" value-ref = "address2"/>
         </map>
      </property>
   </bean>

</beans>

Aby użyć powyższej definicji bean, musisz zdefiniować swoje metody ustawiające w taki sposób, aby mogły również obsługiwać odwołania.

Wstrzykiwanie wartości null i pustych ciągów

Jeśli chcesz przekazać pusty ciąg jako wartość, możesz przekazać go w następujący sposób -

<bean id = "..." class = "exampleBean">
   <property name = "email" value = ""/>
</bean>

Poprzedni przykład jest równoważny z kodem Java: exampleBean.setEmail („”)

Jeśli chcesz przekazać wartość NULL, możesz przekazać ją w następujący sposób -

<bean id = "..." class = "exampleBean">
   <property name = "email"><null/></property>
</bean>

Poprzedni przykład jest odpowiednikiem kodu Java: exampleBean.setEmail (null)

Dowiedziałeś się, jak zadeklarować fasolę za pomocą elementu <bean> i wstrzyknąć <bean> za pomocą elementów <constructor-arg> i <property> w pliku konfiguracyjnym XML.

Pojemnik Spring może autowire relacje między współpracującymi komponentami bean bez użycia elementów <constructor-arg> i <property>, co pomaga zmniejszyć ilość konfiguracji XML, którą należy napisać dla dużej aplikacji opartej na Spring.

Tryby automatycznego okablowania

Poniżej przedstawiono tryby autowiring, których można użyć do poinstruowania kontenera Spring, aby używał autowiring do wstrzykiwania zależności. Do określenia służy atrybut autowire elementu <bean />autowire tryb dla definicji fasoli.

Sr.No	Tryb i opis
1	no Jest to ustawienie domyślne, które oznacza brak automatycznego okablowania i do okablowania należy użyć jawnego odniesienia do komponentu bean. Nie masz nic specjalnego do tego okablowania. To właśnie widzieliście w rozdziale Dependency Injection.
2	wg nazwy Automatyczne okablowanie według nazwy właściwości. Kontener Spring sprawdza właściwości fasoli, dla których atrybut autowire jest ustawiony na byName w pliku konfiguracyjnym XML. Następnie próbuje dopasować i połączyć swoje właściwości z ziarnami zdefiniowanymi przez te same nazwy w pliku konfiguracyjnym.
3	według rodzaju Automatyczne okablowanie według typu danych właściwości. Kontener Spring sprawdza właściwości fasoli, dla których atrybut autowire jest ustawiony na byType w pliku konfiguracyjnym XML. Następnie próbuje dopasować i połączyć właściwość, jeśli jesttypepasuje do dokładnie jednej z nazw ziaren w pliku konfiguracyjnym. Jeśli istnieje więcej niż jedna taka fasola, zgłaszany jest fatalny wyjątek.
4	constructor Similar to byType, but type applies to constructor arguments. If there is not exactly one bean of the constructor argument type in the container, a fatal error is raised.
5	autodetect Spring first tries to wire using autowire by constructor, if it does not work, Spring tries to autowire by byType.

You can use byType or constructor autowiring mode to wire arrays and other typed-collections.

Limitations with autowiring

Autowiring works best when it is used consistently across a project. If autowiring is not used in general, it might be confusing for developers to use it to wire only one or two bean definitions. Though, autowiring can significantly reduce the need to specify properties or constructor arguments but you should consider the limitations and disadvantages of autowiring before using them.

Sr.No.	Limitations & Description
1	Overriding possibility You can still specify dependencies using <constructor-arg> and <property> settings which will always override autowiring.
2	Primitive data types You cannot autowire so-called simple properties such as primitives, Strings, and Classes.
3	Confusing nature Autowiring is less exact than explicit wiring, so if possible prefer using explict wiring.

Starting from Spring 2.5 it became possible to configure the dependency injection using annotations. So instead of using XML to describe a bean wiring, you can move the bean configuration into the component class itself by using annotations on the relevant class, method, or field declaration.

Annotation injection is performed before XML injection. Thus, the latter configuration will override the former for properties wired through both approaches.

Annotation wiring is not turned on in the Spring container by default. So, before we can use annotation-based wiring, we will need to enable it in our Spring configuration file. So consider the following configuration file in case you want to use any annotation in your Spring application.

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context = "http://www.springframework.org/schema/context"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>
   <!-- bean definitions go here -->

</beans>

Once <context:annotation-config/> is configured, you can start annotating your code to indicate that Spring should automatically wire values into properties, methods, and constructors. Let us look at a few important annotations to understand how they work −

Sr.No.	Annotation & Description
1	@Required The @Required annotation applies to bean property setter methods.
2	@Autowired The @Autowired annotation can apply to bean property setter methods, non-setter methods, constructor and properties.
3	@Qualifier The @Qualifier annotation along with @Autowired can be used to remove the confusion by specifiying which exact bean will be wired.
4	JSR-250 Annotations Spring supports JSR-250 based annotations which include @Resource, @PostConstruct and @PreDestroy annotations.

So far you have seen how we configure Spring beans using XML configuration file. If you are comfortable with XML configuration, then it is really not required to learn how to proceed with Java-based configuration as you are going to achieve the same result using either of the configurations available.

Java-based configuration option enables you to write most of your Spring configuration without XML but with the help of few Java-based annotations explained in this chapter.

@Configuration & @Bean Annotations

Annotating a class with the @Configuration indicates that the class can be used by the Spring IoC container as a source of bean definitions. The @Bean annotation tells Spring that a method annotated with @Bean will return an object that should be registered as a bean in the Spring application context. The simplest possible @Configuration class would be as follows −

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

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

The above code will be equivalent to the following XML configuration −

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

Here, the method name is annotated with @Bean works as bean ID and it creates and returns the actual bean. Your configuration class can have a declaration for more than one @Bean. Once your configuration classes are defined, you can load and provide them to Spring container using AnnotationConfigApplicationContext as follows −

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

You can load various configuration classes as follows −

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

Example

Let us have a working Eclipse IDE in place and take the following steps to create a Spring application −

Steps	Description
1	Create a project with a name SpringExample and create a package com.tutorialspoint under the src folder in the created project.
2	Add required Spring libraries using Add External JARs option as explained in the Spring Hello World Example chapter.
3	Because you are using Java-based annotations, so you also need to add CGLIB.jar from your Java installation directory and ASM.jar library which can be downloaded from asm.ow2.org.
4	Create Java classes HelloWorldConfig, HelloWorld and MainApp under the com.tutorialspoint package.
5	The final step is to create the content of all the Java files and Bean Configuration file and run the application as explained below.

Here is the content of HelloWorldConfig.java file

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

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

Here is the content of 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);
   }
}

Following is the content of the 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();
   }
}

Once you are done creating all the source files and adding the required additional libraries, let us run the application. You should note that there is no configuration file required. If everything is fine with your application, it will print the following message −

Your Message : Hello World!

Injecting Bean Dependencies

When @Beans have dependencies on one another, expressing that the dependency is as simple as having one bean method calling another as follows −

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

Here, the foo bean receives a reference to bar via the constructor injection. Now let us look at another working example.

Example

Let us have a working Eclipse IDE in place and take the following steps to create a Spring application −

Steps	Description
1	Create a project with a name SpringExample and create a package com.tutorialspoint under the src folder in the created project.
2	Add required Spring libraries using Add External JARs option as explained in the Spring Hello World Example chapter.
3	Because you are using Java-based annotations, so you also need to add CGLIB.jar from your Java installation directory and ASM.jar library which can be downloaded from asm.ow2.org.
4	Create Java classes TextEditorConfig, TextEditor, SpellChecker and MainApp under the com.tutorialspoint package.
5	The final step is to create the content of all the Java files and Bean Configuration file and run the application as explained below.

Here is the content of 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( );
   }
}

Here is the content of 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();
   }
}

Following is the content of another dependent class file SpellChecker.java

package com.tutorialspoint;

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

Following is the content of the 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();
   }
}

Inside SpellChecker constructor.
Inside TextEditor constructor.
Inside checkSpelling.

The @Import Annotation

The @Import annotation allows for loading @Bean definitions from another configuration class. Consider a ConfigA class as follows −

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

You can import above Bean declaration in another Bean Declaration as follows −

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

Now, rather than needing to specify both ConfigA.class and ConfigB.class when instantiating the context, only ConfigB needs to be supplied as follows −

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

Widzieliście we wszystkich rozdziałach, że rdzeniem Wiosny jest ApplicationContext, który zarządza całym cyklem życia ziaren. ApplicationContext publikuje określone typy zdarzeń podczas ładowania komponentów bean. Na przykład ContextStartedEvent jest publikowane, gdy kontekst jest uruchamiany, a ContextStoppedEvent jest publikowany, gdy kontekst jest zatrzymany.

Postępowania w przypadku ApplicationContext jest poprzez ApplicationEvent klasy i ApplicationListener interfejsu. W związku z tym, jeśli komponent bean implementuje ApplicationListener , to za każdym razem, gdy ApplicationEvent zostanie opublikowany w ApplicationContext, zostanie powiadomiony o tym komponencie bean.

Wiosna zapewnia następujące standardowe wydarzenia -

Sr.No.	Wbudowane wydarzenia i opis wiosny
1	ContextRefreshedEvent To zdarzenie jest publikowane, gdy ApplicationContext jest inicjowany lub odświeżany. Można to również wywołać za pomocą metody refresh () w interfejsie ConfigurableApplicationContext .
2	ContextStartedEvent To zdarzenie jest publikowane, gdy ApplicationContext jest uruchamiany przy użyciu metody start () w interfejsie ConfigurableApplicationContext . Możesz sondować swoją bazę danych lub możesz ponownie uruchomić każdą zatrzymaną aplikację po otrzymaniu tego zdarzenia.
3	ContextStoppedEvent To zdarzenie jest publikowane po zatrzymaniu ApplicationContext przy użyciu metody stop () w interfejsie ConfigurableApplicationContext . Po otrzymaniu tego wydarzenia możesz wykonać wymagane prace domowe.
4	ContextClosedEvent To zdarzenie jest publikowane po zamknięciu ApplicationContext przy użyciu metody close () w interfejsie ConfigurableApplicationContext . Zamknięty kontekst dobiega końca; nie można go odświeżyć ani ponownie uruchomić.
5	RequestHandledEvent Jest to zdarzenie specyficzne dla sieci WWW informujące wszystkie komponenty bean, że żądanie HTTP zostało obsłużone.

Obsługa zdarzeń Springa jest jednowątkowa, więc jeśli zdarzenie zostanie opublikowane, dopóki wszyscy odbiorcy nie otrzymają komunikatu, procesy są blokowane i przepływ nie będzie kontynuowany. Dlatego podczas projektowania aplikacji należy zachować ostrożność, jeśli ma być używana obsługa zdarzeń.

Słuchanie wydarzeń kontekstowych

Aby nasłuchiwać zdarzenia kontekstu, komponent bean powinien implementować interfejs ApplicationListener , który ma tylko jedną metodęonApplicationEvent(). Napiszmy więc przykład, aby zobaczyć, w jaki sposób zdarzenia się propagują i jak można umieścić kod w celu wykonania wymaganego zadania na podstawie określonych zdarzeń.

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

Krok	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	Utwórz klasy Java HelloWorld , CStartEventHandler , CStopEventHandler i MainApp w pakiecie com.tutorialspoint .
4	Utwórz plik konfiguracyjny Beans Beans.xml w obszarzesrc teczka.
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ść 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ść CStartEventHandler.java plik

package com.tutorialspoint;

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStartedEvent;

public class CStartEventHandler 
   implements ApplicationListener<ContextStartedEvent>{

   public void onApplicationEvent(ContextStartedEvent event) {
      System.out.println("ContextStartedEvent Received");
   }
}

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

package com.tutorialspoint;

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStoppedEvent;

public class CStopEventHandler 
   implements ApplicationListener<ContextStoppedEvent>{

   public void onApplicationEvent(ContextStoppedEvent event) {
      System.out.println("ContextStoppedEvent Received");
   }
}

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

package com.tutorialspoint;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ConfigurableApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      // Let us raise a start event.
      context.start();
	  
      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();

      // Let us raise a stop event.
      context.stop();
   }
}

Poniżej znajduje się plik konfiguracyjny Beans.xml

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
      <property name = "message" value = "Hello World!"/>
   </bean>

   <bean id = "cStartEventHandler" class = "com.tutorialspoint.CStartEventHandler"/>
   <bean id = "cStopEventHandler" class = "com.tutorialspoint.CStopEventHandler"/>

</beans>

Po utworzeniu plików źródłowych i konfiguracyjnych komponentów bean uruchom aplikację. Jeśli wszystko jest w porządku z Twoją aplikacją, wydrukuje następujący komunikat -

ContextStartedEvent Received
Your Message : Hello World!
ContextStoppedEvent Received

Jeśli chcesz, możesz opublikować własne zdarzenia niestandardowe, a później możesz je uchwycić, aby podjąć dowolne działanie przeciwko tym zdarzeniom niestandardowym. Jeśli jesteś zainteresowany pisaniem własnych wydarzeń niestandardowych, możesz sprawdzić zdarzenia niestandardowe na wiosnę.

Istnieje wiele kroków, które należy wykonać, aby napisać i opublikować własne wydarzenia niestandardowe. Postępuj zgodnie z instrukcjami podanymi w tym rozdziale, aby pisać, publikować i obsługiwać niestandardowe wydarzenia wiosenne.

Kroki	Opis
1	Utwórz projekt o nazwie SpringExample i utwórz pakiet com.tutorialspoint w obszarzesrcfolder w utworzonym projekcie. Wszystkie klasy zostaną utworzone w ramach tego pakietu.
2	Dodaj wymagane biblioteki Spring za pomocą opcji Dodaj zewnętrzne pliki JAR , jak wyjaśniono w rozdziale Spring Hello World Example .
3	Utwórz klasę zdarzenia CustomEvent , rozszerzającApplicationEvent. Ta klasa musi definiować domyślny konstruktor, który powinien dziedziczyć konstruktor z klasy ApplicationEvent.
4	Po zdefiniowaniu klasy zdarzenia możesz opublikować ją z dowolnej klasy, powiedzmy EventClassPublisher, która implementuje ApplicationEventPublisherAware . Musisz również zadeklarować tę klasę w pliku konfiguracyjnym XML jako komponent bean, aby kontener mógł zidentyfikować komponent bean jako wydawcę zdarzeń, ponieważ implementuje interfejs ApplicationEventPublisherAware.
5	Opublikowane zdarzenie można obsłużyć w klasie, powiedzmy EventClassHandler, która implementuje interfejs ApplicationListener i implementuje metodę onApplicationEvent dla zdarzenia niestandardowego.
6	Utwórz plik konfiguracyjny fasoli Beans.xml w obszarzesrcfolder i klasę MainApp, która będzie działać jako aplikacja Spring.
7	Ostatnim krokiem jest utworzenie zawartości wszystkich plików Java i pliku konfiguracyjnego Bean i uruchomienie aplikacji, jak wyjaśniono poniżej.

Oto treść CustomEvent.java plik

package com.tutorialspoint;

import org.springframework.context.ApplicationEvent;

public class CustomEvent extends ApplicationEvent{
   public CustomEvent(Object source) {
      super(source);
   }
   public String toString(){
      return "My Custom Event";
   }
}

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

package com.tutorialspoint;

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;

public class CustomEventPublisher implements ApplicationEventPublisherAware {
   private ApplicationEventPublisher publisher;
   
   public void setApplicationEventPublisher (ApplicationEventPublisher publisher) {
      this.publisher = publisher;
   }
   public void publish() {
      CustomEvent ce = new CustomEvent(this);
      publisher.publishEvent(ce);
   }
}

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

package com.tutorialspoint;

import org.springframework.context.ApplicationListener;

public class CustomEventHandler implements ApplicationListener<CustomEvent> {
   public void onApplicationEvent(CustomEvent event) {
      System.out.println(event.toString());
   }
}

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

package com.tutorialspoint;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ConfigurableApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");
	  
      CustomEventPublisher cvp = 
         (CustomEventPublisher) context.getBean("customEventPublisher");
      
      cvp.publish();  
      cvp.publish();
   }
}

Poniżej znajduje się plik konfiguracyjny Beans.xml

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "customEventHandler" class = "com.tutorialspoint.CustomEventHandler"/>
   <bean id = "customEventPublisher" class = "com.tutorialspoint.CustomEventPublisher"/>

</beans>

Po utworzeniu plików źródłowych i konfiguracyjnych komponentów bean uruchom aplikację. Jeśli wszystko jest w porządku z Twoją aplikacją, wydrukuje następujący komunikat -

y Custom Event
y Custom Event

Jednym z kluczowych składników Spring Framework jest Aspect oriented programming (AOP)struktura. Programowanie zorientowane aspektowo polega na rozbiciu logiki programu na odrębne części zwane tak zwanymi problemami. Nazywa się funkcje, które obejmują wiele punktów aplikacjicross-cutting concernsa te przekrojowe problemy są koncepcyjnie oddzielone od logiki biznesowej aplikacji. Istnieje wiele typowych dobrych przykładów aspektów, takich jak logowanie, audyt, transakcje deklaratywne, bezpieczeństwo, buforowanie itp.

Kluczową jednostką modułowości w OOP jest klasa, podczas gdy w AOP jednostką modułowości jest aspekt. Dependency Injection pomaga oddzielić obiekty aplikacji od siebie, a AOP pomaga oddzielić problemy związane z cięciem krzyżowym od obiektów, na które mają one wpływ. AOP jest jak wyzwalacze w językach programowania, takich jak Perl, .NET, Java i inne.

Moduł Spring AOP zapewnia przechwytywacze do przechwytywania aplikacji. Na przykład, gdy metoda jest wykonywana, możesz dodać dodatkowe funkcje przed lub po wykonaniu metody.

Terminologie AOP

Zanim zaczniemy pracę z AOP, zapoznajmy się z pojęciami i terminologią AOP. Te terminy nie są specyficzne dla Springa, są raczej związane z AOP.

Sr.No	Warunki i opis
1	Aspect Jest to moduł zawierający zestaw interfejsów API zapewniających wymagania przekrojowe. Na przykład moduł rejestrowania będzie nazywał się aspektem AOP do rejestrowania. Aplikacja może mieć wiele aspektów w zależności od wymagań.
2	Join point Stanowi to punkt w aplikacji, w którym można podłączyć aspekt AOP. Można też powiedzieć, że jest to rzeczywiste miejsce w aplikacji, w którym zostanie wykonana akcja z wykorzystaniem frameworka Spring AOP.
3	Advice Jest to rzeczywista akcja, która ma zostać podjęta przed lub po wykonaniu metody. Jest to rzeczywisty fragment kodu, który jest wywoływany podczas wykonywania programu przez framework Spring AOP.
4	Pointcut Jest to zestaw co najmniej jednego punktu złączenia, w którym należy wykonać poradę. Możesz określić punkty za pomocą wyrażeń lub wzorców, jak zobaczymy w naszych przykładach AOP.
5	Introduction Wprowadzenie pozwala na dodanie nowych metod lub atrybutów do istniejących klas.
6	Target object Obiekt, na który zwraca uwagę jeden lub więcej aspektów. Ten obiekt zawsze będzie obiektem proxy, nazywanym również obiektem zalecanym.
7	Weaving Tkanie to proces łączenia aspektów z innymi typami aplikacji lub obiektami w celu stworzenia zalecanego obiektu. Można to zrobić w czasie kompilacji, wczytywania lub w czasie wykonywania.

Rodzaje porad

Aspekty wiosenne mogą działać z pięcioma rodzajami porad wymienionych poniżej -

Sr.No	Porady i opis
1	before Uruchom poradę przed wykonaniem metody a.
2	after Uruchom poradę po wykonaniu metody, niezależnie od jej wyniku.
3	after-returning Uruchom poradę po wykonaniu metody a tylko wtedy, gdy metoda zakończy się pomyślnie.
4	after-throwing Uruchamiaj porady po wykonaniu metody a tylko wtedy, gdy metoda kończy działanie przez zgłoszenie wyjątku.
5	around Uruchom poradę przed i po wywołaniu zalecanej metody.

Wdrażanie niestandardowych aspektów

Wiosna wspiera @AspectJ annotation style podejście i schema-basedpodejście do wdrażania niestandardowych aspektów. Te dwa podejścia zostały szczegółowo wyjaśnione w kolejnych sekcjach.

Sr.No	Podejście i opis
1	Oparty na schemacie XML Aspekty są implementowane przy użyciu zwykłych klas wraz z konfiguracją opartą na XML.
2	Oparty na @AspectJ @AspectJ odnosi się do stylu deklarowania aspektów jako zwykłych klas Java z adnotacjami Java 5.

Podczas pracy z bazą danych przy użyciu zwykłego starego JDBC pisanie niepotrzebnego kodu obsługującego wyjątki, otwieranie i zamykanie połączeń z bazą danych itp. Staje się uciążliwe. Jednak Spring JDBC Framework zajmuje się wszystkimi niskopoziomowymi szczegółami zaczynając od otwarcia połączenia, i wykonaj instrukcję SQL, wykonaj wyjątki, obsłuż transakcje i ostatecznie zamknij połączenie.

Wystarczy więc zdefiniować parametry połączenia i określić instrukcję SQL do wykonania, a także wykonać wymaganą pracę dla każdej iteracji podczas pobierania danych z bazy danych.

Spring JDBC zapewnia kilka podejść i odpowiednio różne klasy do połączenia z bazą danych. Zamierzam przyjąć klasyczne i najpopularniejsze podejście, które wykorzystujeJdbcTemplateklasa ramy. Jest to centralna klasa szkieletowa, która zarządza całą komunikacją z bazą danych i obsługą wyjątków.

Klasa JdbcTemplate

Klasa JDBC Template wykonuje zapytania SQL, aktualizuje instrukcje, przechowuje wywołania procedur, wykonuje iterację zestawów wyników i wyodrębnia zwrócone wartości parametrów. Przechwytuje również wyjątki JDBC i tłumaczy je na ogólną, zawierającą więcej informacji hierarchię wyjątków zdefiniowaną w pakiecie org.springframework.dao.

Instancje JdbcTemplate klasy są threadsafe raz skonfigurowany. Możesz więc skonfigurować pojedyncze wystąpienie JdbcTemplate, a następnie bezpiecznie wstrzyknąć to współużytkowane odniesienie do wielu DAO.

Powszechną praktyką podczas korzystania z klasy szablonu JDBC jest skonfigurowanie źródła danych w pliku konfiguracyjnym Spring, a następnie wstrzyknięcie zależności tego współdzielonego komponentu bean DataSource do klas DAO, a JdbcTemplate jest tworzony w programie ustawiającym dla źródła danych.

Konfigurowanie źródła danych

Stwórzmy tabelę bazy danych Student w naszej bazie danych TEST. Zakładamy, że pracujesz z bazą danych MySQL, jeśli pracujesz z jakąkolwiek inną bazą danych, możesz odpowiednio zmienić swoje zapytania DDL i SQL.

CREATE TABLE Student(
   ID   INT NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(20) NOT NULL,
   AGE  INT NOT NULL,
   PRIMARY KEY (ID)
);

Teraz musimy dostarczyć źródło danych do szablonu JDBC, aby mógł skonfigurować się w celu uzyskania dostępu do bazy danych. Możesz skonfigurować źródło danych w pliku XML za pomocą fragmentu kodu, jak pokazano w poniższym fragmencie kodu -

<bean id = "dataSource" 
   class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
   <property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
   <property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
   <property name = "username" value = "root"/>
   <property name = "password" value = "password"/>
</bean>

Obiekt dostępu do danych (DAO)

DAO to skrót od Data Access Object, który jest powszechnie używany do interakcji z bazą danych. DAO istnieją, aby zapewnić środki do odczytu i zapisu danych w bazie danych i powinny udostępniać tę funkcjonalność poprzez interfejs, za pomocą którego reszta aplikacji będzie miała do nich dostęp.

Obsługa DAO w Spring ułatwia spójną pracę z technologiami dostępu do danych, takimi jak JDBC, Hibernate, JPA czy JDO.

Wykonywanie instrukcji SQL

Zobaczmy, jak możemy wykonać operację CRUD (tworzenie, odczytywanie, aktualizowanie i usuwanie) na tabelach bazy danych za pomocą SQL i obiektu szablonu JDBC.

Querying for an integer

String SQL = "select count(*) from Student";
int rowCount = jdbcTemplateObject.queryForInt( SQL );

Querying for a long

String SQL = "select count(*) from Student";
long rowCount = jdbcTemplateObject.queryForLong( SQL );

A simple query using a bind variable

String SQL = "select age from Student where id = ?";
int age = jdbcTemplateObject.queryForInt(SQL, new Object[]{10});

Querying for a String

String SQL = "select name from Student where id = ?";
String name = jdbcTemplateObject.queryForObject(SQL, new Object[]{10}, String.class);

Querying and returning an object

String SQL = "select * from Student where id = ?";
Student student = jdbcTemplateObject.queryForObject(
   SQL, new Object[]{10}, new StudentMapper());

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setID(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      
      return student;
   }
}

Querying and returning multiple objects

String SQL = "select * from Student";
List<Student> students = jdbcTemplateObject.query(
   SQL, new StudentMapper());

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setID(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      
      return student;
   }
}

Inserting a row into the table

String SQL = "insert into Student (name, age) values (?, ?)";
jdbcTemplateObject.update( SQL, new Object[]{"Zara", 11} );

Updating a row into the table

String SQL = "update Student set name = ? where id = ?";
jdbcTemplateObject.update( SQL, new Object[]{"Zara", 10} );

Deleting a row from the table

String SQL = "delete Student where id = ?";
jdbcTemplateObject.update( SQL, new Object[]{20} );

Wykonywanie instrukcji DDL

Możesz użyć execute(..)z jdbcTemplate do wykonywania instrukcji SQL lub instrukcji DDL. Poniżej znajduje się przykład użycia instrukcji CREATE do utworzenia tabeli:

String SQL = "CREATE TABLE Student( " +
   "ID   INT NOT NULL AUTO_INCREMENT, " +
   "NAME VARCHAR(20) NOT NULL, " +
   "AGE  INT NOT NULL, " +
   "PRIMARY KEY (ID));"

jdbcTemplateObject.execute( SQL );

Spring JDBC Framework Przykłady

W oparciu o powyższe koncepcje, sprawdźmy kilka ważnych przykładów, które pomogą Ci zrozumieć wykorzystanie frameworka JDBC na wiosnę -

Sr.No.	Przykład i opis
1	Przykład wiosennego JDBC Ten przykład wyjaśnia, jak napisać prostą aplikację Spring opartą na JDBC.
2	Procedura składowana SQL na wiosnę Dowiedz się, jak wywołać procedurę składowaną SQL podczas korzystania z JDBC na wiosnę.

Transakcja w bazie danych to sekwencja działań, które są traktowane jako pojedyncza jednostka pracy. Działania te powinny zakończyć się całkowicie lub nie przynieść żadnego efektu. Zarządzanie transakcjami jest ważną częścią aplikacji korporacyjnej zorientowanej na RDBMS w celu zapewnienia integralności i spójności danych. Pojęcie transakcji można opisać za pomocą następujących czterech kluczowych właściwości opisanych jakoACID -

Atomicity - Transakcję należy traktować jako pojedynczą jednostkę operacji, co oznacza, że cała sekwencja operacji zakończyła się sukcesem lub niepowodzeniem.
Consistency - Reprezentuje spójność referencyjną integralności bazy danych, unikalne klucze podstawowe w tabelach itp.
Isolation- W tym samym czasie może być przetwarzanych wiele transakcji z tym samym zestawem danych. Każda transakcja powinna być odizolowana od innych, aby zapobiec uszkodzeniu danych.
Durability - Po zakończeniu transakcji wyniki tej transakcji muszą być trwałe i nie mogą zostać usunięte z bazy danych z powodu awarii systemu.

Prawdziwy system baz danych RDBMS gwarantuje wszystkie cztery właściwości dla każdej transakcji. Uproszczony widok transakcji wysłanej do bazy danych za pomocą SQL jest następujący:

Rozpocznij transakcję za pomocą polecenia begin transaction .
Wykonuj różne operacje usuwania, aktualizacji lub wstawiania za pomocą zapytań SQL.
Jeśli wszystkie operacje zakończą się pomyślnie, wykonaj zatwierdzenie, w przeciwnym razie wycofaj wszystkie operacje.

Struktura Spring zapewnia abstrakcyjną warstwę na wierzchu różnych podstawowych interfejsów API do zarządzania transakcjami. Obsługa transakcji Springa ma na celu zapewnienie alternatywy dla transakcji EJB poprzez dodanie możliwości transakcyjnych do POJO. Spring obsługuje zarówno programowe, jak i deklaratywne zarządzanie transakcjami. EJB wymagają serwera aplikacji, ale zarządzanie transakcjami Spring można zaimplementować bez potrzeby serwera aplikacji.

Transakcje lokalne a transakcje globalne

Transakcje lokalne są specyficzne dla pojedynczego zasobu transakcyjnego, takiego jak połączenie JDBC, podczas gdy transakcje globalne mogą obejmować wiele zasobów transakcyjnych, takich jak transakcje w systemie rozproszonym.

Lokalne zarządzanie transakcjami może być przydatne w scentralizowanym środowisku komputerowym, w którym składniki aplikacji i zasoby znajdują się w jednym miejscu, a zarządzanie transakcjami obejmuje tylko lokalnego menedżera danych działającego na jednym komputerze. Transakcje lokalne są łatwiejsze do wdrożenia.

Globalne zarządzanie transakcjami jest wymagane w rozproszonym środowisku komputerowym, w którym wszystkie zasoby są rozproszone w wielu systemach. W takim przypadku zarządzanie transakcjami musi odbywać się zarówno na poziomie lokalnym, jak i globalnym. Transakcja rozproszona lub globalna jest wykonywana w wielu systemach, a jej wykonanie wymaga koordynacji między globalnym systemem zarządzania transakcjami a wszystkimi lokalnymi menedżerami danych wszystkich zaangażowanych systemów.

Programowe a deklaratywne

Spring obsługuje dwa rodzaje zarządzania transakcjami -

Automatyzacja zarządzania transakcjami - Oznacza to, że musisz zarządzać transakcją za pomocą programowania. Zapewnia to wyjątkową elastyczność, ale jest trudna do utrzymania.
Deklaratywne zarządzanie transakcjami - oznacza to oddzielenie zarządzania transakcjami od kodu biznesowego. Do zarządzania transakcjami używa się tylko adnotacji lub konfiguracji opartej na języku XML.

Deklaratywne zarządzanie transakcjami jest lepsze niż zautomatyzowane zarządzanie transakcjami, chociaż jest mniej elastyczne niż zautomatyzowane zarządzanie transakcjami, które pozwala kontrolować transakcje za pomocą kodu. Ale jako rodzaj problemu przekrojowego, deklaratywne zarządzanie transakcjami można modularyzować za pomocą podejścia AOP. Spring obsługuje deklaratywne zarządzanie transakcjami za pośrednictwem struktury Spring AOP.

Wiosenne abstrakcje transakcji

Klucz do abstrakcji transakcji Spring jest zdefiniowany przez interfejs org.springframework.transaction.PlatformTransactionManager , który wygląda następująco -

public interface PlatformTransactionManager {
   TransactionStatus getTransaction(TransactionDefinition definition);
   throws TransactionException;
   
   void commit(TransactionStatus status) throws TransactionException;
   void rollback(TransactionStatus status) throws TransactionException;
}

Sr.No	Metoda i opis
1	TransactionStatus getTransaction(TransactionDefinition definition) Ta metoda zwraca aktualnie aktywną transakcję lub tworzy nową, zgodnie z określonym zachowaniem propagacji.
2	void commit(TransactionStatus status) Metoda ta zatwierdza daną transakcję ze względu na jej status.
3	void rollback(TransactionStatus status) Ta metoda wykonuje wycofanie danej transakcji.

TransactionDefinition jest interfejs rdzeń obsługi transakcji na wiosnę i jest zdefiniowany w następujący sposób -

public interface TransactionDefinition {
   int getPropagationBehavior();
   int getIsolationLevel();
   String getName();
   int getTimeout();
   boolean isReadOnly();
}

Sr.No	Metoda i opis
1	int getPropagationBehavior() Ta metoda zwraca zachowanie propagacji. Spring oferuje wszystkie opcje propagacji transakcji znane z EJB CMT.
2	int getIsolationLevel() Ta metoda zwraca stopień, w jakim transakcja jest odizolowana od pracy innych transakcji.
3	String getName() Ta metoda zwraca nazwę tej transakcji.
4	int getTimeout() Ta metoda zwraca czas w sekundach, w którym transakcja musi zostać zakończona.
5	boolean isReadOnly() Ta metoda zwraca, czy transakcja jest tylko do odczytu.

Poniżej przedstawiono możliwe wartości poziomu izolacji -

Sr.No	Izolacja i opis
1	TransactionDefinition.ISOLATION_DEFAULT To jest domyślny poziom izolacji.
2	TransactionDefinition.ISOLATION_READ_COMMITTED Wskazuje, że zapobiega się zabrudzonym odczytom; mogą wystąpić odczyty niepowtarzalne i odczyty fantomowe.
3	TransactionDefinition.ISOLATION_READ_UNCOMMITTED Wskazuje, że mogą wystąpić brudne odczyty, niepowtarzalne odczyty i odczyty pozorne.
4	TransactionDefinition.ISOLATION_REPEATABLE_READ Wskazuje, że zapobiega się zabrudzonym odczytom i niepowtarzalnym odczytom; mogą wystąpić odczyty fantomowe.
5	TransactionDefinition.ISOLATION_SERIALIZABLE Wskazuje, że zapobiega się zabrudzonym odczytom, niepowtarzalnym odczytom i odczytom fantomowym.

Poniżej przedstawiono możliwe wartości typów propagacji -

Sr.No.	Propagacja i opis
1	TransactionDefinition.PROPAGATION_MANDATORY Obsługuje bieżącą transakcję; zgłasza wyjątek, jeśli nie istnieje żadna bieżąca transakcja.
2	TransactionDefinition.PROPAGATION_NESTED Wykonywany w ramach transakcji zagnieżdżonej, jeśli istnieje bieżąca transakcja.
3	TransactionDefinition.PROPAGATION_NEVER Nie obsługuje bieżącej transakcji; zgłasza wyjątek, jeśli istnieje bieżąca transakcja.
4	TransactionDefinition.PROPAGATION_NOT_SUPPORTED Nie obsługuje bieżącej transakcji; raczej zawsze wykonywane nietransakcyjnie.
5	TransactionDefinition.PROPAGATION_REQUIRED Obsługuje bieżącą transakcję; tworzy nowy, jeśli taki nie istnieje.
6	TransactionDefinition.PROPAGATION_REQUIRES_NEW Tworzy nową transakcję, zawieszając bieżącą transakcję, jeśli taka istnieje.
7	TransactionDefinition.PROPAGATION_SUPPORTS Obsługuje bieżącą transakcję; jest wykonywany bez transakcji, jeśli nie istnieje.
8	TransactionDefinition.TIMEOUT_DEFAULT Używa domyślnego limitu czasu podstawowego systemu transakcyjnego lub żadnego, jeśli limity czasu nie są obsługiwane.

TransactionStatus interfejs zapewnia prostą drogę do kodu transakcyjnego do realizacji transakcji i zapytań kontrola statusu transakcji.

public interface TransactionStatus extends SavepointManager {
   boolean isNewTransaction();
   boolean hasSavepoint();
   void setRollbackOnly();
   boolean isRollbackOnly();
   boolean isCompleted();
}

Sr.No.	Metoda i opis
1	boolean hasSavepoint() Ta metoda zwraca, czy transakcja wewnętrznie przenosi punkt zapisu, tj. Została utworzona jako transakcja zagnieżdżona na podstawie punktu zapisu.
2	boolean isCompleted() Ta metoda zwraca informację, czy transakcja została zakończona, tj. Czy została już zatwierdzona, czy wycofana.
3	boolean isNewTransaction() Ta metoda zwraca wartość true w przypadku, gdy obecna transakcja jest nowa.
4	boolean isRollbackOnly() Ta metoda zwraca, czy transakcja została oznaczona jako tylko wycofywanie.
5	void setRollbackOnly() Ta metoda ustawia transakcję jako tylko wycofywanie.

Struktura Spring Web MVC zapewnia architekturę Model-View-Controller (MVC) i gotowe komponenty, których można używać do tworzenia elastycznych i luźno powiązanych aplikacji internetowych. Wzorzec MVC powoduje oddzielenie różnych aspektów aplikacji (logika wejściowa, logika biznesowa i logika interfejsu użytkownika), zapewniając jednocześnie luźne powiązanie między tymi elementami.

Plik Model hermetyzuje dane aplikacji i generalnie będą składać się z POJO.
Plik View jest odpowiedzialny za renderowanie danych modelu i generalnie generuje dane wyjściowe HTML, które przeglądarka klienta może zinterpretować.
Plik Controller odpowiada za przetwarzanie żądań użytkowników i budowanie odpowiedniego modelu i przekazuje go do widoku w celu renderowania.

DispatcherServlet

Struktura modelu Spring Web kontrolera widoku (MVC) została zaprojektowana wokół DispatcherServlet, który obsługuje wszystkie żądania i odpowiedzi HTTP. Przepływ pracy przetwarzania żądań w Spring Web MVC DispatcherServlet jest zilustrowany na poniższym diagramie -

Poniżej znajduje się sekwencja zdarzeń odpowiadająca przychodzącemu żądaniu HTTP do DispatcherServlet -

Po otrzymaniu żądania HTTP DispatcherServlet konsultuje się z HandlerMapping w celu wywołania odpowiedniego kontrolera .
Kontroler wykonuje żądanie i wywołuje odpowiednie metody usług opartych na używane GET lub metodą POST. Metoda usługi ustawi dane modelu na podstawie zdefiniowanej logiki biznesowej i zwróci nazwę widoku do DispatcherServlet .
DispatcherServlet odbędzie pomoc ViewResolver pickup zdefiniowany widok na życzenie.
Po sfinalizowaniu widoku DispatcherServlet przekazuje dane modelu do widoku, który jest ostatecznie renderowany w przeglądarce.

Wszystkie wyżej wymienione komponenty, tj. HandlerMapping, Controller i ViewResolver są częściami WebApplicationContext w, który jest rozszerzeniem zwykłego ApplicationContext z dodatkowymi funkcjami niezbędnymi dla aplikacji internetowych.

Wymagana konfiguracja

Musisz zmapować żądania, które mają obsługiwać DispatcherServlet , przy użyciu mapowania adresu URL wweb.xmlplik. Poniżej znajduje się przykład pokazujący deklarację i mapowanieHelloWeb Przykład DispatcherServlet -

<web-app id = "WebApp_ID" version = "2.4"
   xmlns = "http://java.sun.com/xml/ns/j2ee" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/j2ee 
   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    
   <display-name>Spring MVC Application</display-name>
   
   <servlet>
      <servlet-name>HelloWeb</servlet-name>
      <servlet-class>
         org.springframework.web.servlet.DispatcherServlet
      </servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>

   <servlet-mapping>
      <servlet-name>HelloWeb</servlet-name>
      <url-pattern>*.jsp</url-pattern>
   </servlet-mapping>

</web-app>

Plik web.xmlplik będzie przechowywany w katalogu WebContent / WEB-INF aplikacji internetowej. Po inicjalizacjiHelloWeb DispatcherServlet, framework spróbuje załadować kontekst aplikacji z pliku o nazwie [servlet-name]-servlet.xmlznajdujący się w katalogu WebContent / WEB-INF aplikacji. W tym przypadku nasz plik będzieHelloWebservlet.xml.

Następnie znacznik <servlet-mapping> wskazuje, jakie adresy URL będą obsługiwane przez który serwlet DispatcherServlet. Tutaj wszystkie żądania HTTP kończące się na.jsp będzie obsługiwany przez HelloWeb DispatcherServlet.

Jeśli nie chcesz używać domyślnej nazwy pliku [nazwa-serwletu] -servlet.xml i domyślnej lokalizacji jako WebContent / WEB-INF , możesz dostosować tę nazwę i lokalizację pliku, dodając moduł nasłuchujący serwletów ContextLoaderListener w swoim pliku web.xml w następujący sposób -

<web-app...>

   <!-------- DispatcherServlet definition goes here----->
   ....
   <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/HelloWeb-servlet.xml</param-value>
   </context-param>

   <listener>
      <listener-class>
         org.springframework.web.context.ContextLoaderListener
      </listener-class>
   </listener>
   
</web-app>

Teraz sprawdźmy wymaganą konfigurację HelloWeb-servlet.xmlplik umieszczony w katalogu WebContent / WEB-INF aplikacji internetowej -

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans     
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:component-scan base-package = "com.tutorialspoint" />

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/" />
      <property name = "suffix" value = ".jsp" />
   </bean>

</beans>

Poniżej znajdują się ważne punkty dotyczące HelloWeb-servlet.xml plik -

Plik [nazwa-serwletu] -servlet.xml zostanie użyty do utworzenia zdefiniowanych komponentów bean, przesłaniając definicje wszystkich komponentów bean zdefiniowanych o tej samej nazwie w zasięgu globalnym.
Znacznik <context: component-scan ...> zostanie użyty do aktywacji funkcji skanowania adnotacji Spring MVC, która umożliwia korzystanie z adnotacji, takich jak @Controller i @RequestMapping itp.
InternalResourceViewResolver będą miały zasady określone w celu rozwiązania nazwy widoku. Zgodnie z powyższą regułą, logiczny widok nazwanyhellojest delegowany do implementacji widoku znajdującej się pod adresem /WEB-INF/jsp/hello.jsp .

Poniższa sekcja pokaże, jak tworzyć rzeczywiste komponenty, tj. Kontroler, model i widok.

Definiowanie kontrolera

Serwlet DispatcherServlet deleguje żądanie do kontrolerów w celu wykonania specyficznej dla niego funkcjonalności. Plik@Controlleradnotacja wskazuje, że dana klasa pełni rolę kontrolera. Plik@RequestMapping adnotacja służy do mapowania adresu URL na całą klasę lub konkretną metodę obsługi.

@Controller
@RequestMapping("/hello")
public class HelloController { 
   @RequestMapping(method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");
      return "hello";
   }
}

Plik @Controlleradnotacja definiuje klasę jako kontroler Spring MVC. Tutaj pierwsze użycie@RequestMapping wskazuje, że wszystkie metody obsługi na tym kontrolerze są względne w stosunku do /hellościeżka. Następna adnotacja@RequestMapping(method = RequestMethod.GET)służy do deklarowania metody theprintHello () jako domyślnej metody obsługi kontrolera do obsługi żądania HTTP GET. Możesz zdefiniować inną metodę obsługi dowolnego żądania POST pod tym samym adresem URL.

Możesz napisać powyższy kontroler w innej formie, w której możesz dodać dodatkowe atrybuty w @RequestMapping w następujący sposób -

@Controller
public class HelloController {
   @RequestMapping(value = "/hello", method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");
      return "hello";
   }
}

Plik value atrybut wskazuje adres URL, na który mapowana jest metoda obsługi, a plik methodatrybut definiuje metodę usługi do obsługi żądania HTTP GET. Na temat kontrolera zdefiniowanego powyżej należy zwrócić uwagę na następujące ważne punkty:

Zdefiniujesz wymaganą logikę biznesową w ramach metody usługi. Możesz wywołać inną metodę wewnątrz tej metody zgodnie z wymaganiami.
Na podstawie zdefiniowanej logiki biznesowej utworzysz model w ramach tej metody. Możesz użyć metody ustawiającej różne atrybuty modelu, a widok będzie miał dostęp do tych atrybutów, aby przedstawić wynik końcowy. W tym przykładzie tworzony jest model z atrybutem „komunikat”.
Zdefiniowana metoda usługi może zwrócić String, który zawiera nazwę pliku viewdo wykorzystania do renderowania modelu. Ten przykład zwraca „hello” jako logiczną nazwę widoku.

Tworzenie widoków JSP

Spring MVC obsługuje wiele typów widoków dla różnych technologii prezentacji. Należą do nich - JSP, HTML, PDF, arkusze Excela, XML, szablony Velocity, XSLT, JSON, Atom i kanały RSS, JasperReports, itp. Ale najczęściej używamy szablonów JSP napisanych w JSTL.

Napiszmy proste hello wyświetl w /WEB-INF/hello/hello.jsp -

<html>
   <head>
      <title>Hello Spring MVC</title>
   </head>
   
   <body>
      <h2>${message}</h2>
   </body>
</html>

Tutaj ${message}to atrybut, który ustawiliśmy wewnątrz kontrolera. W widoku może być wyświetlanych wiele atrybutów.

Spring Web MVC Framework Przykłady

W oparciu o powyższe koncepcje, zapoznajmy się z kilkoma ważnymi przykładami, które pomogą Ci zbudować Twoje Spring Web Applications -

Sr.No.	Przykład i opis
1	Przykład Hello World Spring MVC Ten przykład wyjaśnia, jak napisać prostą aplikację Spring Web Hello World.
2	Przykład obsługi formularza Spring MVC Ten przykład wyjaśnia, jak napisać aplikację Spring Web za pomocą formularzy HTML, aby przesłać dane do kontrolera i wyświetlić przetworzony wynik.
3	Przykład przekierowania strony wiosny Dowiedz się, jak korzystać z funkcji przekierowywania stron w Spring MVC Framework.
4	Przykład wiosennych stron statycznych Dowiedz się, jak uzyskać dostęp do stron statycznych wraz ze stronami dynamicznymi w Spring MVC Framework.
5	Przykład obsługi wyjątków wiosennych Dowiedz się, jak obsługiwać wyjątki w Spring MVC Framework.

Jest to bardzo łatwa w użyciu funkcjonalność Log4J w aplikacjach Springa. Poniższy przykład poprowadzi Cię przez proste kroki, aby wyjaśnić prostą integrację między Log4J i Spring.

Zakładamy, że już masz log4Jzainstalowany na twoim komputerze. Jeśli go nie masz, możesz go pobrać zhttps://logging.apache.org/i po prostu wyodrębnij spakowany plik w dowolnym folderze. Użyjemy tylkolog4j-x.y.z.jar w naszym projekcie.

Następnie przygotujmy działające środowisko Eclipse IDE i podejmijmy następujące kroki, aby opracować aplikację internetową opartą na formularzu dynamicznym przy użyciu Spring Web Framework -

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	Dodaj do projektu bibliotekę log4j log4j-xyzjar, korzystając z opcji Dodaj zewnętrzne pliki JAR .
4	Utwórz klasy Java HelloWorld i MainApp w pakiecie com.tutorialspoint .
5	Utwórz plik konfiguracyjny Beans Beans.xml w obszarzesrc teczka.
6	Utwórz plik konfiguracyjny log4J log4j.properties wsrc teczka.
7	Ostatnim krokiem jest utworzenie zawartości wszystkich plików Java i pliku konfiguracyjnego Bean i uruchomienie aplikacji, jak wyjaśniono poniżej.

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ść drugiego pliku MainApp.java

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.apache.log4j.Logger;

public class MainApp {
   static Logger log = Logger.getLogger(MainApp.class.getName());
   
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      log.info("Going to create HelloWord Obj");
      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
      
      log.info("Exiting the program");
   }
}

Możesz generować debug i errorwiadomość w podobny sposób jak wygenerowaliśmy wiadomości informacyjne. Przyjrzyjmy się teraz zawartościBeans.xml plik

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
      <property name = "message" value = "Hello World!"/>
   </bean>

</beans>

Poniżej znajduje się treść log4j.properties który definiuje standardowe reguły wymagane dla Log4J do tworzenia komunikatów dziennika

# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
# Set the name of the file
log4j.appender.FILE.File=C:\\log.out

# Set the immediate flush to true (default)
log4j.appender.FILE.ImmediateFlush=true

# Set the threshold to debug mode
log4j.appender.FILE.Threshold=debug

# Set the append to false, overwrite
log4j.appender.FILE.Append=false

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

Po utworzeniu plików źródłowych i konfiguracyjnych komponentów bean uruchom aplikację. Jeśli wszystko jest w porządku z Twoją aplikacją, spowoduje to wyświetlenie następującego komunikatu w konsoli Eclipse -

Your Message : Hello World!

Jeśli sprawdzisz dysk C: \\, powinieneś znaleźć swój plik dziennika log.out z różnymi komunikatami dziennika, na przykład następującymi -

<!-- initialization log messages -->

Going to create HelloWord Obj
Returning cached instance of singleton bean 'helloWorld'
Exiting the program

Jakarta Commons Logging (JCL) API

Alternatywnie możesz użyć Jakarta Commons Logging (JCL)API do generowania dziennika w Twojej aplikacji Spring. JCL można pobrać zhttps://jakarta.apache.org/commons/logging/. Jedynym plikiem, którego technicznie potrzebujemy z tego pakietu, jest plik commons-logging-xyzjar , który należy umieścić w ścieżce klas w podobny sposób, jak umieściłeś log4j-xyzjar w powyższym przykładzie.

Aby skorzystać z funkcji rejestrowania, potrzebujesz obiektu org.apache.commons.logging.Log, a następnie możesz wywołać jedną z następujących metod zgodnie z wymaganiami -

fatal (komunikat o obiekcie)
błąd (komunikat o obiekcie)
ostrzeżenie (wiadomość o obiekcie)
info (wiadomość o obiekcie)
debugowanie (komunikat o obiekcie)
trace (komunikat o obiekcie)

Poniżej przedstawiono zastąpienie pliku MainApp.java, który wykorzystuje interfejs JCL API

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.apache.commons.logging. Log;
import org.apache.commons.logging. LogFactory;

public class MainApp {
   static Log log = LogFactory.getLog(MainApp.class.getName());

   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      log.info("Going to create HelloWord Obj");
      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();

      log.info("Exiting the program");
   }
}

Musisz upewnić się, że dołączyłeś do projektu plik commons-logging-xyzjar, przed skompilowaniem i uruchomieniem programu.

Pozostawiając resztę konfiguracji i zawartości bez zmian w powyższym przykładzie, jeśli skompilujesz i uruchomisz swoją aplikację, uzyskasz podobny wynik, jak ten, który otrzymałeś przy użyciu Log4J API.