Frühling - Kurzanleitung
Spring ist das beliebteste Anwendungsentwicklungsframework für Enterprise Java. Millionen von Entwicklern auf der ganzen Welt verwenden Spring Framework, um leistungsstarken, leicht testbaren und wiederverwendbaren Code zu erstellen.
Spring Framework ist eine Open Source Java-Plattform. Es wurde ursprünglich von Rod Johnson geschrieben und erstmals im Juni 2003 unter der Apache 2.0-Lizenz veröffentlicht.
Der Frühling ist leicht, wenn es um Größe und Transparenz geht. Die Basisversion des Spring Frameworks ist ca. 2 MB groß.
Die Kernfunktionen des Spring Framework können bei der Entwicklung jeder Java-Anwendung verwendet werden. Es gibt jedoch Erweiterungen zum Erstellen von Webanwendungen auf der Java EE-Plattform. Das Spring Framework zielt darauf ab, die Verwendung der J2EE-Entwicklung zu vereinfachen und gute Programmierpraktiken zu fördern, indem ein POJO-basiertes Programmiermodell ermöglicht wird.
Vorteile der Verwendung des Spring Framework
Im Folgenden finden Sie eine Liste der wenigen großen Vorteile der Verwendung von Spring Framework:
Mit Spring können Entwickler Anwendungen der Enterprise-Klasse mithilfe von POJOs entwickeln. Die Verwendung von nur POJOs hat den Vorteil, dass Sie kein EJB-Containerprodukt wie einen Anwendungsserver benötigen, sondern nur einen robusten Servlet-Container wie Tomcat oder ein kommerzielles Produkt verwenden können.
Der Frühling ist modular aufgebaut. Obwohl die Anzahl der Pakete und Klassen beträchtlich ist, müssen Sie sich nur um die benötigten Pakete kümmern und den Rest ignorieren.
Spring erfindet das Rad nicht neu, sondern nutzt einige der vorhandenen Technologien wie mehrere ORM-Frameworks, Protokollierungs-Frameworks, JEE-, Quarz- und JDK-Timer und andere Ansichtstechnologien.
Das Testen einer mit Spring geschriebenen Anwendung ist einfach, da umgebungsabhängiger Code in dieses Framework verschoben wird. Durch die Verwendung von JavaBeanstyle-POJOs wird es außerdem einfacher, die Abhängigkeitsinjektion zum Injizieren von Testdaten zu verwenden.
Das Webframework von Spring ist ein gut gestaltetes MVC-Webframework, das eine hervorragende Alternative zu Webframeworks wie Struts oder anderen überentwickelten oder weniger beliebten Webframeworks darstellt.
Spring bietet eine praktische API, um technologie-spezifische Ausnahmen (z. B. von JDBC, Hibernate oder JDO ausgelöst) in konsistente, nicht aktivierte Ausnahmen zu übersetzen.
Leichte IoC-Container sind in der Regel leicht, insbesondere im Vergleich zu EJB-Containern. Dies ist vorteilhaft für die Entwicklung und Bereitstellung von Anwendungen auf Computern mit begrenztem Speicher und begrenzten CPU-Ressourcen.
Spring bietet eine konsistente Transaktionsverwaltungsschnittstelle, die auf eine lokale Transaktion (z. B. mithilfe einer einzelnen Datenbank) und auf globale Transaktionen (z. B. mithilfe von JTA) skaliert werden kann.
Abhängigkeitsinjektion (DI)
Die Technologie, mit der sich Spring am meisten identifiziert, ist die Dependency Injection (DI)Geschmack der Inversion der Kontrolle. DasInversion of Control (IoC)ist ein allgemeines Konzept und kann auf viele verschiedene Arten ausgedrückt werden. Die Abhängigkeitsinjektion ist nur ein konkretes Beispiel für die Inversion der Kontrolle.
Beim Schreiben einer komplexen Java-Anwendung sollten Anwendungsklassen so unabhängig wie möglich von anderen Java-Klassen sein, um die Möglichkeit zu erhöhen, diese Klassen wiederzuverwenden und sie beim Komponententest unabhängig von anderen Klassen zu testen. Die Abhängigkeitsinjektion hilft dabei, diese Klassen zusammenzukleben und gleichzeitig unabhängig zu halten.
Was genau ist Abhängigkeitsinjektion? Schauen wir uns diese beiden Wörter getrennt an. Hier übersetzt sich der Abhängigkeitsteil in eine Assoziation zwischen zwei Klassen. Zum Beispiel ist Klasse A von Klasse B abhängig. Schauen wir uns nun den zweiten Teil an, die Injektion. Dies bedeutet lediglich, dass Klasse B vom IoC in Klasse A injiziert wird.
Die Abhängigkeitsinjektion kann durch Übergabe von Parametern an den Konstruktor oder durch Nachkonstruktion unter Verwendung von Setter-Methoden erfolgen. Da die Abhängigkeitsinjektion das Herzstück von Spring Framework ist, werden wir dieses Konzept in einem separaten Kapitel mit einem relevanten Beispiel erläutern.
Aspektorientierte Programmierung (AOP)
Eine der Schlüsselkomponenten von Spring ist die Aspect Oriented Programming (AOP)Rahmen. Die Funktionen, die mehrere Punkte einer Anwendung umfassen, werden aufgerufencross-cutting concernsDiese Querschnittsthemen sind konzeptionell von der Geschäftslogik der Anwendung getrennt. Es gibt verschiedene Beispiele für Aspekte wie Protokollierung, deklarative Transaktionen, Sicherheit, Caching usw.
Die Schlüsseleinheit der Modularität in OOP ist die Klasse, während in AOP die Einheit der Modularität der Aspekt ist. Mit DI können Sie Ihre Anwendungsobjekte voneinander entkoppeln, mit AOP können Sie Querschnittsthemen von den betroffenen Objekten entkoppeln.
Das AOP-Modul von Spring Framework bietet eine aspektorientierte Programmierimplementierung, mit der Sie Methodenabfangjäger und Pointcuts definieren können, um Code sauber zu entkoppeln, der Funktionen implementiert, die getrennt werden sollten. Wir werden mehr über Spring AOP-Konzepte in einem separaten Kapitel diskutieren.
Spring könnte möglicherweise eine zentrale Anlaufstelle für alle Ihre Unternehmensanwendungen sein. Spring ist jedoch modular aufgebaut, sodass Sie auswählen können, welche Module für Sie geeignet sind, ohne den Rest einbringen zu müssen. Der folgende Abschnitt enthält Details zu allen in Spring Framework verfügbaren Modulen.
Das Spring Framework bietet ungefähr 20 Module, die je nach Anwendungsanforderung verwendet werden können.
Kernbehälter
Der Core Container besteht aus den Modulen Core, Beans, Context und Expression Language, deren Details wie folgt lauten:
Das Core Das Modul bietet die grundlegenden Teile des Frameworks, einschließlich der IoC- und Dependency Injection-Funktionen.
Das Bean Das Modul bietet BeanFactory, eine ausgefeilte Implementierung des Factory-Musters.
Das ContextDas Modul baut auf der soliden Basis der Core- und Beans-Module auf und ist ein Medium für den Zugriff auf alle definierten und konfigurierten Objekte. Die ApplicationContext-Schnittstelle ist der Schwerpunkt des Context-Moduls.
Das SpEL Das Modul bietet eine leistungsstarke Ausdruckssprache zum Abfragen und Bearbeiten eines Objektdiagramms zur Laufzeit.
Datenzugriff / Integration
Die Datenzugriffs- / Integrationsschicht besteht aus den Modulen JDBC, ORM, OXM, JMS und Transaction, deren Details wie folgt sind:
Das JDBC Das Modul bietet eine JDBC-Abstraktionsschicht, die die mühsame JDBC-bezogene Codierung überflüssig macht.
Das ORM Das Modul bietet Integrationsschichten für gängige objektrelationale Zuordnungs-APIs, einschließlich JPA, JDO, Hibernate und iBatis.
Das OXM Das Modul bietet eine Abstraktionsschicht, die Objekt- / XML-Mapping-Implementierungen für JAXB, Castor, XMLBeans, JiBX und XStream unterstützt.
Der Java Messaging Service JMS Das Modul enthält Funktionen zum Erstellen und Konsumieren von Nachrichten.
Das Transaction Das Modul unterstützt die programmatische und deklarative Transaktionsverwaltung für Klassen, die spezielle Schnittstellen implementieren, und für alle Ihre POJOs.
Netz
Die Webschicht besteht aus den Modulen Web, Web-MVC, Web-Socket und Web-Portlet, deren Details wie folgt lauten:
Das Web Das Modul bietet grundlegende weborientierte Integrationsfunktionen wie mehrteilige Funktionen zum Hochladen von Dateien und die Initialisierung des IoC-Containers mithilfe von Servlet-Listenern und einem weborientierten Anwendungskontext.
Das Web-MVC Das Modul enthält die Model-View-Controller (MVC) -Implementierung von Spring für Webanwendungen.
Das Web-Socket Das Modul bietet Unterstützung für die WebSocket-basierte bidirektionale Kommunikation zwischen dem Client und dem Server in Webanwendungen.
Das Web-Portlet Das Modul stellt die MVC-Implementierung zur Verwendung in einer Portlet-Umgebung bereit und spiegelt die Funktionalität des Web-Servlet-Moduls wider.
Verschiedenes
Es gibt nur wenige andere wichtige Module wie AOP-, Aspekt-, Instrumentierungs-, Web- und Testmodule, deren Details wie folgt lauten:
Das AOP Das Modul bietet eine aspektorientierte Programmierimplementierung, mit der Sie Methodenabfangjäger und Pointcuts definieren können, um Code sauber zu entkoppeln, der Funktionen implementiert, die getrennt werden sollten.
Das Aspects Das Modul bietet die Integration mit AspectJ, einem leistungsstarken und ausgereiften AOP-Framework.
Das Instrumentation Das Modul bietet Unterstützung für Klasseninstrumente und Klassenladeprogrammierungen, die auf bestimmten Anwendungsservern verwendet werden können.
Das MessagingDas Modul unterstützt STOMP als WebSocket-Unterprotokoll zur Verwendung in Anwendungen. Es unterstützt auch ein Annotation-Programmiermodell zum Weiterleiten und Verarbeiten von STOMP-Nachrichten von WebSocket-Clients.
Das Test Das Modul unterstützt das Testen von Spring-Komponenten mit JUnit- oder TestNG-Frameworks.
In diesem Kapitel erfahren Sie, wie Sie eine Entwicklungsumgebung vorbereiten, um Ihre Arbeit mit Spring Framework zu beginnen. Außerdem erfahren Sie, wie Sie JDK, Tomcat und Eclipse auf Ihrem Computer einrichten, bevor Sie Spring Framework einrichten.
Schritt 1 - Java Development Kit (JDK) einrichten
Sie können die neueste Version des SDK von der Java-Site von Oracle herunterladen - Java SE Downloads. Anweisungen zum Installieren von JDK finden Sie in heruntergeladenen Dateien. Befolgen Sie die Anweisungen zum Installieren und Konfigurieren des Setups. Stellen Sie schließlich die Umgebungsvariablen PATH und JAVA_HOME so ein, dass sie auf das Verzeichnis verweisen, das Java und Javac enthält, normalerweise java_install_dir / bin bzw. java_install_dir.
Wenn Sie Windows ausführen und das JDK in C: \ jdk1.6.0_15 installiert haben, müssen Sie die folgende Zeile in Ihre Datei C: \ autoexec.bat einfügen.
set PATH=C:\jdk1.6.0_15\bin;%PATH%
set JAVA_HOME=C:\jdk1.6.0_15Alternativ müssen Sie unter Windows NT / 2000 / XP mit der rechten Maustaste auf Arbeitsplatz klicken und Eigenschaften → Erweitert → Umgebungsvariablen auswählen. Anschließend müssen Sie den PATH-Wert aktualisieren und auf die Schaltfläche OK klicken.
Wenn unter Unix (Solaris, Linux usw.) das SDK in /usr/local/jdk1.6.0_15 installiert ist und Sie die C-Shell verwenden, müssen Sie Folgendes in Ihre .cshrc-Datei einfügen.
setenv PATH /usr/local/jdk1.6.0_15/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.6.0_15Wenn Sie alternativ eine integrierte Entwicklungsumgebung (IDE) wie Borland JBuilder, Eclipse, IntelliJ IDEA oder Sun ONE Studio verwenden, müssen Sie ein einfaches Programm kompilieren und ausführen, um zu bestätigen, dass die IDE weiß, wo Sie Java installiert haben. Andernfalls müssen Sie eine ordnungsgemäße Einrichtung durchführen, wie im Dokument der IDE angegeben.
Schritt 2 - Installieren Sie die Apache Common Logging API
Sie können die neueste Version der Apache Commons Logging API von herunterladen https://commons.apache.org/logging/. Wenn Sie die Installation heruntergeladen haben, entpacken Sie die Binärdistribution an einem geeigneten Ort. Zum Beispiel in C: \ commons-logging-1.1.1 unter Windows oder /usr/local/commons-logging-1.1.1 unter Linux / Unix. Dieses Verzeichnis enthält die folgenden JAR-Dateien und andere unterstützende Dokumente usw.
Stellen Sie sicher, dass Sie Ihre CLASSPATH-Variable in diesem Verzeichnis richtig eingestellt haben, da sonst beim Ausführen Ihrer Anwendung ein Problem auftritt.
Schritt 3 - Eclipse IDE einrichten
Alle Beispiele in diesem Tutorial wurden mit Eclipse IDE geschrieben. Wir empfehlen Ihnen daher, die neueste Version von Eclipse auf Ihrem Computer zu installieren.
Laden Sie zum Installieren der Eclipse-IDE die neuesten Eclipse-Binärdateien von herunter https://www.eclipse.org/downloads/. Wenn Sie die Installation heruntergeladen haben, entpacken Sie die Binärdistribution an einem geeigneten Ort. Zum Beispiel in C: \ eclipse unter Windows oder / usr / local / eclipse unter Linux / Unix und setzen Sie schließlich die Variable PATH entsprechend.
Eclipse kann durch Ausführen der folgenden Befehle auf einem Windows-Computer gestartet werden, oder Sie können einfach auf eclipse.exe doppelklicken
%C:\eclipse\eclipse.exeEclipse kann durch Ausführen der folgenden Befehle auf einem Unix-Computer (Solaris, Linux usw.) gestartet werden:
$/usr/local/eclipse/eclipseWenn nach einem erfolgreichen Start alles in Ordnung ist, sollte das folgende Ergebnis angezeigt werden:
Schritt 4 - Einrichten von Spring Framework-Bibliotheken
Wenn jetzt alles in Ordnung ist, können Sie mit dem Einrichten Ihres Spring-Frameworks fortfahren. Im Folgenden finden Sie die einfachen Schritte zum Herunterladen und Installieren des Frameworks auf Ihrem Computer.
Treffen Sie eine Auswahl, ob Sie Spring unter Windows oder Unix installieren möchten, und fahren Sie dann mit dem nächsten Schritt fort, um die ZIP-Datei für Windows und die ZZ-Datei für Unix herunterzuladen.
Laden Sie die neueste Version der Spring Framework-Binärdateien von herunter https://repo.spring.io/release/org/springframework/spring.
Zum Zeitpunkt der Entwicklung dieses Tutorials spring-framework-4.1.6.RELEASE-dist.zipwurde auf Windows-Computer heruntergeladen. Nachdem die heruntergeladene Datei entpackt wurde, gibt es die folgende Verzeichnisstruktur in E: \ spring.
Sie finden alle Spring-Bibliotheken im Verzeichnis E:\spring\libs. Stellen Sie sicher, dass Sie Ihre CLASSPATH-Variable in diesem Verzeichnis richtig eingestellt haben, da sonst beim Ausführen Ihrer Anwendung ein Problem auftritt. Wenn Sie Eclipse verwenden, muss CLASSPATH nicht festgelegt werden, da alle Einstellungen über Eclipse vorgenommen werden.
Sobald Sie mit diesem letzten Schritt fertig sind, können Sie mit Ihrem ersten Frühlingsbeispiel im nächsten Kapitel fortfahren.
Beginnen wir mit der eigentlichen Programmierung mit Spring Framework. Bevor Sie mit dem Schreiben Ihres ersten Beispiels mit Spring Framework beginnen, müssen Sie sicherstellen, dass Sie Ihre Spring-Umgebung ordnungsgemäß eingerichtet haben, wie im Kapitel Spring - Environment Setup erläutert . Wir gehen auch davon aus, dass Sie ein wenig über Eclipse IDE verfügen.
Lassen Sie uns nun eine einfache Frühlingsanwendung schreiben, die "Hallo Welt!" oder eine andere Nachricht basierend auf der Konfiguration in der Spring Beans-Konfigurationsdatei.
Schritt 1 - Java-Projekt erstellen
Der erste Schritt besteht darin, ein einfaches Java-Projekt mit Eclipse IDE zu erstellen. Folgen Sie der OptionFile → New → Project und schließlich auswählen Java ProjectAssistent aus der Assistentenliste. Benennen Sie Ihr Projekt nun alsHelloSpring Verwenden des Assistentenfensters wie folgt:
Sobald Ihr Projekt erfolgreich erstellt wurde, haben Sie den folgenden Inhalt in Ihrem Project Explorer - -
Schritt 2 - Erforderliche Bibliotheken hinzufügen
Als zweiten Schritt fügen wir Spring Framework und allgemeine Protokollierungs-API-Bibliotheken in unser Projekt ein. Klicken Sie dazu mit der rechten Maustaste auf Ihren ProjektnamenHelloSpring und folgen Sie dann der folgenden Option im Kontextmenü: Build Path → Configure Build Path um das Java Build Path-Fenster wie folgt anzuzeigen:
Jetzt benutzen Add External JARs Schaltfläche unter der Libraries Registerkarte, um die folgenden Kern-JARs aus den Installationsverzeichnissen von Spring Framework und Common Logging hinzuzufügen:
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
Schritt 3 - Quelldateien erstellen
Lassen Sie uns nun die tatsächlichen Quelldateien unter dem erstellen HelloSpringProjekt. Zuerst müssen wir ein Paket namens erstellencom.tutorialspoint. Klicken Sie dazu mit der rechten Maustaste aufsrc im Paket-Explorer-Abschnitt und folgen Sie der Option - New → Package.
Als nächstes werden wir erstellen HelloWorld.java und MainApp.java Dateien unter dem Paket com.tutorialspoint.
Hier ist der Inhalt von HelloWorld.java Datei -
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}Es folgt der Inhalt der zweiten Datei 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();
}
}Folgende zwei wichtige Punkte sind über das Hauptprogramm zu beachten:
Der erste Schritt besteht darin, einen Anwendungskontext zu erstellen, in dem wir die Framework-API verwendet haben ClassPathXmlApplicationContext(). Diese API lädt die Beans-Konfigurationsdatei und übernimmt schließlich basierend auf der bereitgestellten API das Erstellen und Initialisieren aller Objekte, dh der in der Konfigurationsdatei genannten Beans.
Der zweite Schritt wird verwendet, um die erforderliche Bean mit zu erhalten getBean()Methode des erstellten Kontexts. Diese Methode verwendet die Bean-ID, um ein generisches Objekt zurückzugeben, das schließlich in das tatsächliche Objekt umgewandelt werden kann. Sobald Sie ein Objekt haben, können Sie mit diesem Objekt eine beliebige Klassenmethode aufrufen.
Schritt 4 - Bean-Konfigurationsdatei erstellen
Sie müssen eine Bean-Konfigurationsdatei erstellen, die eine XML-Datei ist und als Zement fungiert, der die Beans, dh die Klassen, zusammenklebt. Diese Datei muss unter dem erstellt werdensrc Verzeichnis wie im folgenden Screenshot gezeigt -
Normalerweise benennen Entwickler diese Datei als Beans.xmlSie können jedoch einen beliebigen Namen auswählen. Sie müssen sicherstellen, dass diese Datei in CLASSPATH verfügbar ist, und in der Hauptanwendung denselben Namen verwenden, während Sie einen Anwendungskontext erstellen, wie in der Datei MainApp.java gezeigt.
Die Beans.xml wird verwendet, um verschiedenen Beans eindeutige IDs zuzuweisen und die Erstellung von Objekten mit unterschiedlichen Werten zu steuern, ohne dass dies Auswirkungen auf eine der Spring-Quelldateien hat. Mit der folgenden Datei können Sie beispielsweise einen beliebigen Wert für die Variable "message" übergeben und verschiedene Werte der Nachricht drucken, ohne die Dateien HelloWorld.java und MainApp.java zu beeinträchtigen. Mal sehen, wie es funktioniert -
<?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>Wenn die Spring-Anwendung in den Speicher geladen wird, verwendet Framework die obige Konfigurationsdatei, um alle definierten Beans zu erstellen, und weist ihnen eine eindeutige ID zu, wie in definiert <bean>Etikett. Sie können verwenden<property> Tag, um die Werte verschiedener Variablen zu übergeben, die zum Zeitpunkt der Objekterstellung verwendet wurden.
Schritt 5 - Ausführen des Programms
Sobald Sie mit dem Erstellen der Quell- und Beans-Konfigurationsdateien fertig sind, können Sie diesen Schritt ausführen, bei dem Ihr Programm kompiliert und ausgeführt wird. Lassen Sie dazu die Registerkarte MainApp.Java-Datei aktiv und verwenden Sie eine der beiden OptionenRun Option in der Eclipse-IDE verfügbar oder verwenden Ctrl + F11 um Ihre zu kompilieren und auszuführen MainAppAnwendung. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung in der Konsole von Eclipse IDE gedruckt:
Your Message : Hello World!Herzlichen Glückwunsch, Sie haben Ihre erste Frühlingsanwendung erfolgreich erstellt. Sie können die Flexibilität der obigen Spring-Anwendung erkennen, indem Sie den Wert der Eigenschaft "message" ändern und beide Quelldateien unverändert lassen.
Der Spring-Container ist das Kernstück des Spring Framework. Der Container erstellt die Objekte, verdrahtet sie, konfiguriert sie und verwaltet ihren gesamten Lebenszyklus von der Erstellung bis zur Zerstörung. Der Spring-Container verwendet DI, um die Komponenten zu verwalten, aus denen eine Anwendung besteht. Diese Objekte werden Spring Beans genannt, auf die wir im nächsten Kapitel eingehen werden.
Der Container erhält seine Anweisungen zum Instanziieren, Konfigurieren und Zusammenstellen von Objekten durch Lesen der bereitgestellten Konfigurationsmetadaten. Die Konfigurationsmetadaten können entweder durch XML, Java-Anmerkungen oder Java-Code dargestellt werden. Das folgende Diagramm zeigt eine allgemeine Ansicht der Funktionsweise von Spring. Der Spring IoC-Container verwendet Java POJO-Klassen und Konfigurationsmetadaten, um ein vollständig konfiguriertes und ausführbares System oder eine Anwendung zu erstellen.
Spring bietet die folgenden zwei unterschiedlichen Arten von Behältern.
| Sr.Nr. | Behälter & Beschreibung |
|---|---|
| 1 | Spring BeanFactory Container Dies ist der einfachste Container, der die grundlegende Unterstützung für DI bietet, und wird von der Schnittstelle org.springframework.beans.factory.BeanFactory definiert. Die BeanFactory und verwandte Schnittstellen wie BeanFactoryAware, InitializingBean und DisposableBean sind in Spring weiterhin vorhanden, um die Abwärtskompatibilität mit einer großen Anzahl von Frameworks von Drittanbietern zu gewährleisten, die in Spring integriert sind. |
| 2 | Spring ApplicationContext Container Dieser Container bietet weitere unternehmensspezifische Funktionen, z. B. die Möglichkeit, Textnachrichten aus einer Eigenschaftendatei aufzulösen und Anwendungsereignisse für interessierte Ereignis-Listener zu veröffentlichen. Dieser Container wird von der Schnittstelle org.springframework.context.ApplicationContext definiert. |
Der ApplicationContext- Container enthält alle Funktionen des BeanFactory- Containers. Daher wird er generell gegenüber BeanFactory empfohlen . BeanFactory kann weiterhin für leichtgewichtige Anwendungen wie mobile Geräte oder appletbasierte Anwendungen verwendet werden, bei denen Datenvolumen und Geschwindigkeit von Bedeutung sind.
Die Objekte, die das Rückgrat Ihrer Anwendung bilden und vom Spring IoC-Container verwaltet werden, werden aufgerufen beans. Eine Bean ist ein Objekt, das von einem Spring IoC-Container instanziiert, zusammengestellt und anderweitig verwaltet wird. Diese Beans werden mit den Konfigurationsmetadaten erstellt, die Sie dem Container bereitstellen. Zum Beispiel in Form von XML <bean /> -Definitionen, die Sie bereits in den vorherigen Kapiteln gesehen haben.
Die Bean-Definition enthält die aufgerufenen Informationen configuration metadata, die benötigt wird, damit der Container Folgendes weiß:
- So erstellen Sie eine Bohne
- Details zum Lebenszyklus von Bean
- Beans Abhängigkeiten
Alle oben genannten Konfigurationsmetadaten werden in eine Reihe der folgenden Eigenschaften übersetzt, aus denen jede Bean-Definition besteht.
| Sr.Nr. | Eigenschaften & Beschreibung |
|---|---|
| 1 | class Dieses Attribut ist obligatorisch und gibt die Bean-Klasse an, die zum Erstellen der Bean verwendet werden soll. |
| 2 | name Dieses Attribut gibt die Bean-ID eindeutig an. In XML-basierten Konfigurationsmetadaten verwenden Sie die Attribute id und / oder name, um die Bean-IDs anzugeben. |
| 3 | scope Dieses Attribut gibt den Bereich der Objekte an, die aus einer bestimmten Bean-Definition erstellt wurden, und wird im Kapitel Bean-Bereiche erläutert. |
| 4 | constructor-arg Dies wird zum Einfügen der Abhängigkeiten verwendet und wird in den folgenden Kapiteln erläutert. |
| 5 | properties Dies wird zum Einfügen der Abhängigkeiten verwendet und wird in den folgenden Kapiteln erläutert. |
| 6 | autowiring mode Dies wird zum Einfügen der Abhängigkeiten verwendet und wird in den folgenden Kapiteln erläutert. |
| 7 | lazy-initialization mode Eine verzögert initialisierte Bean weist den IoC-Container an, eine Bean-Instanz zu erstellen, wenn sie zum ersten Mal angefordert wird, und nicht beim Start. |
| 8 | initialization method Ein Rückruf, der aufgerufen werden soll, nachdem alle erforderlichen Eigenschaften für die Bean vom Container festgelegt wurden. Dies wird im Kapitel über den Bohnenlebenszyklus erläutert. |
| 9 | destruction method Ein Rückruf, der verwendet wird, wenn der Container mit der Bean zerstört wird. Dies wird im Kapitel über den Bohnenlebenszyklus erläutert. |
Spring-Konfigurationsmetadaten
Der Spring IoC-Container ist vollständig von dem Format entkoppelt, in dem diese Konfigurationsmetadaten tatsächlich geschrieben wurden. Im Folgenden sind die drei wichtigen Methoden zum Bereitstellen von Konfigurationsmetadaten für den Spring Container aufgeführt:
- XML-basierte Konfigurationsdatei.
- Annotationsbasierte Konfiguration
- Java-basierte Konfiguration
Sie haben bereits gesehen, wie XML-basierte Konfigurationsmetadaten für den Container bereitgestellt werden. Lassen Sie uns jedoch ein weiteres Beispiel einer XML-basierten Konfigurationsdatei mit verschiedenen Bean-Definitionen sehen, einschließlich verzögerter Initialisierung, Initialisierungsmethode und Zerstörungsmethode.
<?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>Sie können Spring Hello World Example überprüfen, um zu verstehen, wie Spring Beans definiert, konfiguriert und erstellt werden.
Wir werden die annotationsbasierte Konfiguration in einem separaten Kapitel behandeln. Es wird absichtlich in einem separaten Kapitel behandelt, da wir möchten, dass Sie einige andere wichtige Spring-Konzepte verstehen, bevor Sie mit der Programmierung mit Spring Dependency Injection with Annotations beginnen.
Beim Definieren einer <Bean> haben Sie die Möglichkeit, einen Bereich für diese Bean zu deklarieren. Um beispielsweise zu erzwingen, dass Spring jedes Mal eine neue Bean-Instanz erstellt, wenn eine benötigt wird, sollten Sie das Gültigkeitsbereichsattribut der Bean als deklarierenprototype. Wenn Spring jedes Mal dieselbe Bean-Instanz zurückgeben soll, sollten Sie das Gültigkeitsbereichsattribut der Bean als deklarierensingleton.
Das Spring Framework unterstützt die folgenden fünf Bereiche, von denen drei nur verfügbar sind, wenn Sie einen webfähigen ApplicationContext verwenden.
| Sr.Nr. | Umfang & Beschreibung |
|---|---|
| 1 | singleton Dadurch wird die Bean-Definition auf eine einzelne Instanz pro Spring IoC-Container festgelegt (Standard). |
| 2 | prototype Dadurch wird eine einzelne Bean-Definition auf eine beliebige Anzahl von Objektinstanzen festgelegt. |
| 3 | request Dadurch wird eine Bean-Definition einer HTTP-Anforderung zugeordnet. Nur gültig im Kontext eines webfähigen Spring ApplicationContext. |
| 4 | session Dadurch wird eine Bean-Definition einer HTTP-Sitzung zugeordnet. Nur gültig im Kontext eines webfähigen Spring ApplicationContext. |
| 5 | global-session Dadurch wird eine Bean-Definition einer globalen HTTP-Sitzung zugeordnet. Nur gültig im Kontext eines webfähigen Spring ApplicationContext. |
In diesem Kapitel werden wir uns mit den ersten beiden Bereichen befassen, und die verbleibenden drei werden besprochen, wenn wir uns mit dem webfähigen Spring ApplicationContext befassen.
Der Singleton-Bereich
Wenn ein Bereich auf Singleton festgelegt ist, erstellt der Spring IoC-Container genau eine Instanz des durch diese Bean-Definition definierten Objekts. Diese einzelne Instanz wird in einem Cache solcher Singleton-Beans gespeichert, und alle nachfolgenden Anforderungen und Referenzen für diese benannte Bean geben das zwischengespeicherte Objekt zurück.
Der Standardbereich ist immer Singleton. Wenn Sie jedoch nur eine Instanz einer Bean benötigen, können Sie die festlegenscope Eigentum an singleton in der Bean-Konfigurationsdatei, wie im folgenden Code-Snippet gezeigt -
<!-- A bean definition with singleton scope -->
<bean id = "..." class = "..." scope = "singleton">
<!-- collaborators and configuration for this bean go here -->
</bean>Beispiel
Lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:
| Schritte | Beschreibung |
|---|---|
| 1 | Erstellen Sie ein Projekt mit dem Namen SpringExample und erstellen Sie ein Paket com.tutorialspoint unter demsrc Ordner im erstellten Projekt. |
| 2 | Fügen Sie die erforderlichen Spring-Bibliotheken mit der Option Externe JARs hinzufügen hinzu, wie im Kapitel Spring Hello World-Beispiel erläutert . |
| 3 | Erstellen Java - Klassen Hello World und MainApp unter dem com.tutorialspoint Paket. |
| 4 | Erstellen Sie die Beans-Konfigurationsdatei Beans.xml untersrc Mappe. |
| 5 | Der letzte Schritt besteht darin, den Inhalt aller Java-Dateien und der Bean-Konfigurationsdatei zu erstellen und die Anwendung wie unten erläutert auszuführen. |
Hier ist der Inhalt von HelloWorld.java Datei -
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}Es folgt der Inhalt der MainApp.java Datei -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.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();
}
}Es folgt die Konfigurationsdatei Beans.xml erforderlich für Singleton-Bereich -
<?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>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt:
Your Message : I'm object A
Your Message : I'm object ADer Prototyp Umfang
Wenn der Bereich auf Prototyp festgelegt ist, erstellt der Spring IoC-Container jedes Mal eine neue Bean-Instanz des Objekts, wenn eine Anforderung für diese bestimmte Bean gestellt wird. Verwenden Sie in der Regel den Prototypbereich für alle State-Full-Beans und den Singleton-Bereich für zustandslose Beans.
Um einen Prototypbereich zu definieren, können Sie den festlegen scope Eigentum an prototype in der Bean-Konfigurationsdatei, wie im folgenden Code-Snippet gezeigt -
<!-- A bean definition with prototype scope -->
<bean id = "..." class = "..." scope = "prototype">
<!-- collaborators and configuration for this bean go here -->
</bean>Beispiel
Lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:
| Schritte | Beschreibung |
|---|---|
| 1 | Erstellen Sie ein Projekt mit dem Namen SpringExample und erstellen Sie ein Paket com.tutorialspoint unter demsrc Ordner im erstellten Projekt. |
| 2 | Fügen Sie die erforderlichen Spring-Bibliotheken mit der Option Externe JARs hinzufügen hinzu, wie im Kapitel Spring Hello World-Beispiel erläutert . |
| 3 | Erstellen Java - Klassen Hello World und MainApp unter dem com.tutorialspoint Paket. |
| 4 | Erstellen Sie die Beans-Konfigurationsdatei Beans.xml untersrc Mappe. |
| 5 | Der letzte Schritt besteht darin, den Inhalt aller Java-Dateien und der Bean-Konfigurationsdatei zu erstellen und die Anwendung wie unten erläutert auszuführen. |
Hier ist der Inhalt von HelloWorld.java Datei
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}Es folgt der Inhalt der MainApp.java Datei -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.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();
}
}Es folgt die Konfigurationsdatei Beans.xml erforderlich für den Umfang des Prototyps -
<?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>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt:
Your Message : I'm object A
Your Message : nullDer Lebenszyklus einer Frühlingsbohne ist leicht zu verstehen. Wenn eine Bean instanziiert wird, muss möglicherweise eine Initialisierung durchgeführt werden, um sie in einen verwendbaren Zustand zu versetzen. In ähnlicher Weise kann eine Reinigung erforderlich sein, wenn die Bohne nicht mehr benötigt wird und aus dem Behälter entfernt wird.
Obwohl es Listen der Aktivitäten gibt, die zwischen dem Zeitpunkt der Bean-Instanziierung und ihrer Zerstörung hinter den Kulissen stattfinden, werden in diesem Kapitel nur zwei wichtige Rückrufmethoden für den Bean-Lebenszyklus behandelt, die zum Zeitpunkt der Bean-Initialisierung und ihrer Zerstörung erforderlich sind.
Um Setup und Teardown für eine Bean zu definieren, deklarieren wir einfach die <Bean> mit initmethod und / oder destroy-methodParameter. Das Attribut init-method gibt eine Methode an, die unmittelbar nach der Instanziierung für die Bean aufgerufen werden soll. In ähnlicher Weise gibt destroyymethod eine Methode an, die unmittelbar vor dem Entfernen einer Bean aus dem Container aufgerufen wird.
Initialisierungsrückrufe
Die Schnittstelle org.springframework.beans.factory.InitializingBean gibt eine einzelne Methode an -
void afterPropertiesSet() throws Exception;Auf diese Weise können Sie die obige Schnittstelle einfach implementieren und die Initialisierungsarbeiten können innerhalb der afterPropertiesSet () -Methode wie folgt ausgeführt werden:
public class ExampleBean implements InitializingBean {
public void afterPropertiesSet() {
// do some initialization work
}
}Bei XML-basierten Konfigurationsmetadaten können Sie die verwenden init-methodAttribut, um den Namen der Methode anzugeben, die eine ungültige Signatur ohne Argumente hat. Zum Beispiel -
<bean id = "exampleBean" class = "examples.ExampleBean" init-method = "init"/>Es folgt die Klassendefinition -
public class ExampleBean {
public void init() {
// do some initialization work
}
}Zerstörungsrückrufe
Die Schnittstelle org.springframework.beans.factory.DisposableBean gibt eine einzelne Methode an -
void destroy() throws Exception;Somit können Sie einfach die obige Schnittstelle implementieren und die Finalisierungsarbeiten können innerhalb der destroy () -Methode wie folgt durchgeführt werden:
public class ExampleBean implements DisposableBean {
public void destroy() {
// do some destruction work
}
}Bei XML-basierten Konfigurationsmetadaten können Sie die verwenden destroy-methodAttribut, um den Namen der Methode anzugeben, die eine ungültige Signatur ohne Argumente hat. Zum Beispiel -
<bean id = "exampleBean" class = "examples.ExampleBean" destroy-method = "destroy"/>Es folgt die Klassendefinition -
public class ExampleBean {
public void destroy() {
// do some destruction work
}
}Wenn Sie den IoC-Container von Spring in einer Nicht-Webanwendungsumgebung verwenden; In einer Rich-Client-Desktop-Umgebung registrieren Sie beispielsweise einen Shutdown-Hook bei der JVM. Dies stellt ein ordnungsgemäßes Herunterfahren sicher und ruft die entsprechenden Zerstörungsmethoden für Ihre Singleton-Beans auf, sodass alle Ressourcen freigegeben werden.
Es wird empfohlen, die InitializingBean- oder DisposableBean-Rückrufe nicht zu verwenden, da die XML-Konfiguration hinsichtlich der Benennung Ihrer Methode viel Flexibilität bietet.
Beispiel
Lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:
| Schritte | Beschreibung |
|---|---|
| 1 | Erstellen Sie ein Projekt mit dem Namen SpringExample und erstellen Sie ein Paket com.tutorialspoint unter demsrc Ordner im erstellten Projekt. |
| 2 | Fügen Sie die erforderlichen Spring-Bibliotheken mit der Option Externe JARs hinzufügen hinzu, wie im Kapitel Spring Hello World-Beispiel erläutert . |
| 3 | Erstellen Java - Klassen Hello World und MainApp unter dem com.tutorialspoint Paket. |
| 4 | Erstellen Sie die Beans-Konfigurationsdatei Beans.xml untersrc Mappe. |
| 5 | Der letzte Schritt besteht darin, den Inhalt aller Java-Dateien und der Bean-Konfigurationsdatei zu erstellen und die Anwendung wie unten erläutert auszuführen. |
Hier ist der Inhalt von HelloWorld.java Datei -
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
public void init(){
System.out.println("Bean is going through init.");
}
public void destroy() {
System.out.println("Bean will destroy now.");
}
}Es folgt der Inhalt der MainApp.javaDatei. Hier müssen Sie einen Shutdown-Hook registrierenregisterShutdownHook()Methode, die in der AbstractApplicationContext-Klasse deklariert ist. Dadurch wird ein ordnungsgemäßes Herunterfahren sichergestellt und die entsprechenden Zerstörungsmethoden aufgerufen.
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();
}
}Es folgt die Konfigurationsdatei Beans.xml erforderlich für Init- und Destroy-Methoden -
<?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>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt:
Bean is going through init.
Your Message : Hello World!
Bean will destroy now.Standardinitialisierungs- und Zerstörungsmethoden
Wenn Sie zu viele Beans mit Initialisierungs- und / oder Zerstörungsmethoden mit demselben Namen haben, müssen Sie diese nicht deklarieren init-method und destroy-methodauf jeder einzelnen Bohne. Stattdessen bietet das Framework die Flexibilität, eine solche Situation mithilfe von zu konfigurierendefault-init-method und default-destroy-method Attribute für das <beans> -Element wie folgt:
<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>Das BeanPostProcessor Die Schnittstelle definiert Rückrufmethoden, die Sie implementieren können, um Ihre eigene Instanziierungslogik, Abhängigkeitsauflösungslogik usw. bereitzustellen. Sie können auch eine benutzerdefinierte Logik implementieren, nachdem der Spring-Container das Instanziieren, Konfigurieren und Initialisieren einer Bean abgeschlossen hat, indem Sie eine oder mehrere BeanPostProcessor-Implementierungen einstecken .
Sie können mehrere BeanPostProcessor-Schnittstellen konfigurieren und die Reihenfolge steuern, in der diese BeanPostProcessor-Schnittstellen ausgeführt werden, indem Sie die festlegen order Eigenschaft vorausgesetzt, der BeanPostProcessor implementiert die Ordered Schnittstelle.
Die BeanPostProcessors arbeiten mit Bean- (oder Objekt-) Instanzen. Dies bedeutet, dass der Spring IoC-Container eine Bean-Instanz instanziiert und die BeanPostProcessor-Schnittstellen ihre Arbeit erledigen.
Ein ApplicationContext erkennt automatisch alle Beans, die mit der Implementierung des definiert werden BeanPostProcessor Schnittstelle und registriert diese Beans als Postprozessoren, die dann vom Container bei der Bean-Erstellung entsprechend aufgerufen werden.
Beispiel
Die folgenden Beispiele zeigen, wie BeanPostProcessors im Kontext eines ApplicationContext geschrieben, registriert und verwendet werden.
Lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:
| Schritte | Beschreibung |
|---|---|
| 1 | Erstellen Sie ein Projekt mit dem Namen SpringExample und erstellen Sie ein Paket com.tutorialspoint unter demsrc Ordner im erstellten Projekt. |
| 2 | Fügen Sie die erforderlichen Spring-Bibliotheken mit der Option Externe JARs hinzufügen hinzu, wie im Kapitel Spring Hello World-Beispiel erläutert . |
| 3 | Erstellen Java - Klassen Hello World , InitHelloWorld und MainApp unter dem com.tutorialspoint Paket. |
| 4 | Erstellen Sie die Beans-Konfigurationsdatei Beans.xml untersrc Mappe. |
| 5 | Der letzte Schritt besteht darin, den Inhalt aller Java-Dateien und der Bean-Konfigurationsdatei zu erstellen und die Anwendung wie unten erläutert auszuführen. |
Hier ist der Inhalt von HelloWorld.java Datei -
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
public void init(){
System.out.println("Bean is going through init.");
}
public void destroy(){
System.out.println("Bean will destroy now.");
}
}Dies ist ein sehr einfaches Beispiel für die Implementierung von BeanPostProcessor, bei dem vor und nach der Initialisierung einer Bean ein Bean-Name gedruckt wird. Sie können eine komplexere Logik vor und nach der Initialisierung einer Bean implementieren, da Sie in beiden Postprozessor-Methoden Zugriff auf das Bean-Objekt haben.
Hier ist der Inhalt von InitHelloWorld.java Datei -
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
}
}Es folgt der Inhalt der MainApp.javaDatei. Hier müssen Sie einen Shutdown-Hook registrierenregisterShutdownHook()Methode, die in der AbstractApplicationContext-Klasse deklariert ist. Dies stellt ein ordnungsgemäßes Herunterfahren sicher und ruft die entsprechenden Zerstörungsmethoden auf.
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();
}
}Es folgt die Konfigurationsdatei Beans.xml erforderlich für Init- und Destroy-Methoden -
<?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>Wenn Sie mit dem Erstellen der Quell- und Bean-Konfigurationsdateien fertig sind, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt:
BeforeInitialization : helloWorld
Bean is going through init.
AfterInitialization : helloWorld
Your Message : Hello World!
Bean will destroy now.Eine Bean-Definition kann viele Konfigurationsinformationen enthalten, einschließlich Konstruktorargumente, Eigenschaftswerte und container-spezifische Informationen wie Initialisierungsmethode, Name der statischen Factory-Methode usw.
Eine untergeordnete Bean-Definition erbt Konfigurationsdaten von einer übergeordneten Definition. Die untergeordnete Definition kann je nach Bedarf einige Werte überschreiben oder andere hinzufügen.
Die Vererbung der Spring Bean-Definition hat nichts mit der Vererbung von Java-Klassen zu tun, aber das Vererbungskonzept ist dasselbe. Sie können eine übergeordnete Bean-Definition als Vorlage definieren und andere untergeordnete Beans können die erforderliche Konfiguration von der übergeordneten Bean erben.
Wenn Sie XML-basierte Konfigurationsmetadaten verwenden, geben Sie mithilfe der Taste eine untergeordnete Bean-Definition an parent Attribut, das die übergeordnete Bean als Wert dieses Attributs angibt.
Beispiel
Lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:
| Schritte | Beschreibung |
|---|---|
| 1 | Erstellen Sie ein Projekt mit dem Namen SpringExample und erstellen Sie ein Paket com.tutorialspoint unter demsrc Ordner im erstellten Projekt. |
| 2 | Fügen Sie die erforderlichen Spring-Bibliotheken mit der Option Externe JARs hinzufügen hinzu, wie im Kapitel Spring Hello World-Beispiel erläutert . |
| 3 | Erstellen Java - Klassen Hello World , HelloIndia und MainApp unter dem com.tutorialspoint Paket. |
| 4 | Erstellen Sie die Beans-Konfigurationsdatei Beans.xml untersrc Mappe. |
| 5 | Der letzte Schritt besteht darin, den Inhalt aller Java-Dateien und der Bean-Konfigurationsdatei zu erstellen und die Anwendung wie unten erläutert auszuführen. |
Es folgt die Konfigurationsdatei Beans.xmlwo wir definiert „helloworld“ Bohne , die zwei Eigenschaften hat message1 und message2 . Die nächste "helloIndia" -Bohne wurde mithilfe von "als untergeordnetes Element der" helloWorld "-Bohne definiertparentAttribut. Das Kind bean inherits message2 Eigenschaft wie es ist, und überschreibt message1 Eigenschaft und führt eine weitere Eigenschaft 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>Hier ist der Inhalt von HelloWorld.java Datei -
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);
}
}Hier ist der Inhalt von HelloIndia.java Datei -
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);
}
}Es folgt der Inhalt der MainApp.java Datei -
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();
}
}Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt:
World Message1 : Hello World!
World Message2 : Hello Second World!
India Message1 : Hello India!
India Message2 : Hello Second World!
India Message3 : Namaste India!Wenn Sie hier beobachtet haben, haben wir message2 beim Erstellen der Bean "helloIndia" nicht übergeben, aber es wurde aufgrund der Vererbung der Bean-Definition übergeben.
Bean-Definitionsvorlage
Sie können eine Bean-Definitionsvorlage erstellen, die von anderen untergeordneten Bean-Definitionen ohne großen Aufwand verwendet werden kann. Beim Definieren einer Bean-Definitionsvorlage sollten Sie die nicht angebenclass Attribut und sollte angeben abstract Attribut und sollte das abstrakte Attribut mit dem Wert von angeben true wie im folgenden Code-Snippet gezeigt -
<?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>Die übergeordnete Bean kann nicht alleine instanziiert werden, da sie unvollständig ist, und sie wird auch explizit als abstrakt markiert . Wenn eine Definition wie diese abstrakt ist, kann sie nur als reine Template-Bean-Definition verwendet werden, die als übergeordnete Definition für untergeordnete Definitionen dient.
Jede Java-basierte Anwendung verfügt über einige Objekte, die zusammenarbeiten, um das darzustellen, was der Endbenutzer als funktionierende Anwendung ansieht. Beim Schreiben einer komplexen Java-Anwendung sollten Anwendungsklassen so unabhängig wie möglich von anderen Java-Klassen sein, um die Möglichkeit zu erhöhen, diese Klassen wiederzuverwenden und sie beim Komponententest unabhängig von anderen Klassen zu testen. Die Abhängigkeitsinjektion (oder manchmal auch Verkabelung genannt) hilft dabei, diese Klassen zusammenzukleben und sie gleichzeitig unabhängig zu halten.
Angenommen, Sie haben eine Anwendung mit einer Texteditor-Komponente und möchten eine Rechtschreibprüfung durchführen. Ihr Standardcode würde ungefähr so aussehen -
public class TextEditor {
private SpellChecker spellChecker;
public TextEditor() {
spellChecker = new SpellChecker();
}
}Wir haben hier eine Abhängigkeit zwischen dem TextEditor und dem SpellChecker erstellt. In einer Umkehrung des Kontrollszenarios würden wir stattdessen so etwas tun -
public class TextEditor {
private SpellChecker spellChecker;
public TextEditor(SpellChecker spellChecker) {
this.spellChecker = spellChecker;
}
}Hier sollte sich der TextEditor keine Gedanken über die Implementierung von SpellChecker machen. Der SpellChecker wird unabhängig implementiert und dem TextEditor zum Zeitpunkt der TextEditor-Instanziierung zur Verfügung gestellt. Dieser gesamte Vorgang wird vom Spring Framework gesteuert.
Hier haben wir die vollständige Kontrolle aus dem TextEditor entfernt und an einem anderen Ort (z. B. XML-Konfigurationsdatei) aufbewahrt, und die Abhängigkeit (dh die Klasse SpellChecker) wird über a in die Klasse TextEditor eingefügt Class Constructor. Daher wurde der Kontrollfluss durch Dependency Injection (DI) "invertiert", da Sie Abhängigkeiten effektiv an ein externes System delegiert haben.
Die zweite Methode zum Injizieren von Abhängigkeit ist durch Setter Methodsder TextEditor-Klasse, in der eine SpellChecker-Instanz erstellt wird. Diese Instanz wird verwendet, um Setter-Methoden aufzurufen, um die Eigenschaften von TextEditor zu initialisieren.
Daher gibt es DI in zwei Hauptvarianten, und die folgenden beiden Unterkapitel werden beide mit Beispielen behandeln -
| Sr.Nr. | Art und Beschreibung der Abhängigkeitsinjektion |
|---|---|
| 1 | Konstruktorbasierte Abhängigkeitsinjektion Konstruktorbasiertes DI wird erreicht, wenn der Container einen Klassenkonstruktor mit einer Reihe von Argumenten aufruft, die jeweils eine Abhängigkeit von der anderen Klasse darstellen. |
| 2 | Setter-basierte Abhängigkeitsinjektion Setter-basierte DI wird durch den Container erreicht, der Setter-Methoden für Ihre Beans aufruft, nachdem ein Konstruktor ohne Argumente oder eine statische Factory-Methode ohne Argumente aufgerufen wurde, um Ihre Bean zu instanziieren. |
Sie können sowohl konstruktorbasierte als auch Setter-basierte DI mischen. Es ist jedoch eine gute Faustregel, Konstruktorargumente für obligatorische Abhängigkeiten und Setter für optionale Abhängigkeiten zu verwenden.
Der Code ist mit dem DI-Prinzip sauberer und die Entkopplung ist effektiver, wenn Objekte mit ihren Abhängigkeiten versehen werden. Das Objekt sucht nicht nach seinen Abhängigkeiten und kennt weder den Ort noch die Klasse der Abhängigkeiten, sondern alles wird vom Spring Framework erledigt.
Wie Sie wissen, werden innere Java-Klassen im Rahmen anderer Klassen definiert. inner beanssind Beans, die im Rahmen einer anderen Bean definiert sind. Daher wird ein <bean /> -Element innerhalb der <property /> - oder <constructor-arg /> -Elemente als innere Bean bezeichnet und wird unten gezeigt.
<?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>Beispiel
Lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:
| Schritte | Beschreibung |
|---|---|
| 1 | Erstellen Sie ein Projekt mit dem Namen SpringExample und erstellen Sie ein Paket com.tutorialspoint unter demsrc Ordner im erstellten Projekt. |
| 2 | Fügen Sie die erforderlichen Spring-Bibliotheken mit der Option Externe JARs hinzufügen hinzu, wie im Kapitel Spring Hello World-Beispiel erläutert . |
| 3 | Erstellen Sie die Java-Klassen TextEditor , SpellChecker und MainApp unter dem Paket com.tutorialspoint . |
| 4 | Erstellen Sie die Beans-Konfigurationsdatei Beans.xml untersrc Mappe. |
| 5 | Der letzte Schritt besteht darin, den Inhalt aller Java-Dateien und der Bean-Konfigurationsdatei zu erstellen und die Anwendung wie unten erläutert auszuführen. |
Hier ist der Inhalt von TextEditor.java Datei -
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();
}
}Es folgt der Inhalt einer anderen abhängigen Klassendatei SpellChecker.java - -
package com.tutorialspoint;
public class SpellChecker {
public SpellChecker(){
System.out.println("Inside SpellChecker constructor." );
}
public void checkSpelling(){
System.out.println("Inside checkSpelling." );
}
}Es folgt der Inhalt der MainApp.java Datei -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.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();
}
}Es folgt die Konfigurationsdatei Beans.xml welches die Konfiguration für die Setter-basierte Injektion hat, aber verwendet 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>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt:
Inside SpellChecker constructor.
Inside setSpellChecker.
Inside checkSpelling.Sie haben gesehen, wie Sie den primitiven Datentyp mithilfe von konfigurieren value Attribut- und Objektreferenzen mit refAttribut des <property> -Tags in Ihrer Bean-Konfigurationsdatei. In beiden Fällen geht es darum, einen Singularwert an eine Bohne zu übergeben.
Was ist nun, wenn Sie mehrere Werte wie Java Collection-Typen wie List, Set, Map und Properties übergeben möchten? Um die Situation zu bewältigen, bietet Spring vier Arten von Sammlungskonfigurationselementen an:
| Sr.Nr. | Element & Beschreibung |
|---|---|
| 1 | <list> Dies hilft bei der Verkabelung, dh beim Einfügen einer Liste von Werten, wodurch Duplikate zugelassen werden. |
| 2 | <set> Dies hilft bei der Verkabelung einer Reihe von Werten, jedoch ohne Duplikate. |
| 3 | <map> Dies kann verwendet werden, um eine Sammlung von Name-Wert-Paaren einzufügen, wobei Name und Wert von einem beliebigen Typ sein können. |
| 4 | <props> Dies kann verwendet werden, um eine Sammlung von Name-Wert-Paaren einzufügen, bei denen Name und Wert beide Zeichenfolgen sind. |
Sie können entweder <list> oder <set> verwenden, um eine Implementierung von java.util.Collection oder an zu verkabeln array.
Sie werden auf zwei Situationen stoßen: (a) Übergeben direkter Werte der Sammlung und (b) Übergeben einer Referenz einer Bean als eines der Sammlungselemente.
Beispiel
Lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:
| Schritte | Beschreibung |
|---|---|
| 1 | Erstellen Sie ein Projekt mit dem Namen SpringExample und erstellen Sie ein Paket com.tutorialspoint unter demsrc Ordner im erstellten Projekt. |
| 2 | Fügen Sie die erforderlichen Spring-Bibliotheken mit der Option Externe JARs hinzufügen hinzu, wie im Kapitel Spring Hello World-Beispiel erläutert . |
| 3 | Erstellen Sie die Java-Klassen JavaCollection und MainApp unter dem Paket com.tutorialspoint . |
| 4 | Erstellen Sie die Beans-Konfigurationsdatei Beans.xml untersrc Mappe. |
| 5 | Der letzte Schritt besteht darin, den Inhalt aller Java-Dateien und der Bean-Konfigurationsdatei zu erstellen und die Anwendung wie unten erläutert auszuführen. |
Hier ist der Inhalt von JavaCollection.java Datei -
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;
}
}Es folgt der Inhalt der MainApp.java Datei -
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();
}
}Es folgt die Konfigurationsdatei Beans.xml welches Konfiguration für alle Arten von Sammlungen hat -
<?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>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt:
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}Injizieren von Bean-Referenzen
Die folgende Bean-Definition hilft Ihnen zu verstehen, wie Bean-Referenzen als eines der Elemente der Sammlung eingefügt werden. Sogar Sie können Referenzen und Werte miteinander mischen, wie im folgenden Codeausschnitt gezeigt -
<?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>Um die obige Bean-Definition zu verwenden, müssen Sie Ihre Setter-Methoden so definieren, dass sie auch Referenzen verarbeiten können.
Injizieren von null und leeren Zeichenfolgenwerten
Wenn Sie eine leere Zeichenfolge als Wert übergeben müssen, können Sie sie wie folgt übergeben:
<bean id = "..." class = "exampleBean">
<property name = "email" value = ""/>
</bean>Das vorstehende Beispiel entspricht dem Java-Code: exampleBean.setEmail ("")
Wenn Sie einen NULL-Wert übergeben müssen, können Sie ihn wie folgt übergeben:
<bean id = "..." class = "exampleBean">
<property name = "email"><null/></property>
</bean>Das vorstehende Beispiel entspricht dem Java-Code: exampleBean.setEmail (null)
Sie haben gelernt, wie Sie Beans mit dem Element <bean> deklarieren und <bean> mit den Elementen <constructor-arg> und <property> in die XML-Konfigurationsdatei einfügen.
Der Federbehälter kann autowire Beziehungen zwischen zusammenarbeitenden Beans ohne Verwendung von <constructor-arg> - und <property> -Elementen, wodurch Sie weniger XML-Konfiguration für eine große Spring-basierte Anwendung schreiben müssen.
Autowiring-Modi
Im Folgenden sind die automatischen Verdrahtungsmodi aufgeführt, mit denen der Spring-Container angewiesen werden kann, die automatische Verdrahtung für die Abhängigkeitsinjektion zu verwenden. Sie verwenden das Autowire-Attribut des <bean /> -Elements, um anzugebenautowire Modus für eine Bean-Definition.
| Sr.Nr. | Modus & Beschreibung |
|---|---|
| 1 | no Dies ist die Standardeinstellung, dh keine automatische Verdrahtung, und Sie sollten für die Verkabelung eine explizite Bean-Referenz verwenden. Sie haben für diese Verkabelung nichts Besonderes zu tun. Dies haben Sie bereits im Kapitel Abhängigkeitsinjektion gesehen. |
| 2 | namentlich Autowiring nach Eigenschaftsname. Federbehälter schaut auf die Eigenschaften der Bohnen auf dem autowire Attribut gesetzt ist byName in der XML - Konfigurationsdatei. Anschließend wird versucht, die Eigenschaften mit den gleichnamigen Beans in der Konfigurationsdatei abzugleichen und zu verknüpfen. |
| 3 | nach Typ Autowiring nach Eigenschaftsdatentyp. Federbehälter schaut auf die Eigenschaften der Bohnen auf dem autowire Attribut gesetzt ist byType in der XML - Konfigurationsdatei. Es versucht dann, eine Eigenschaft abzugleichen und zu verkabeln, wenn dies der Fall isttypestimmt mit genau einem der Beans-Namen in der Konfigurationsdatei überein. Wenn mehr als eine solche Beans vorhanden ist, wird eine schwerwiegende Ausnahme ausgelöst. |
| 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();
}
}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 −
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);
}Lebenszyklus-Rückrufe
Die Annotation @Bean unterstützt die Angabe beliebiger Rückrufmethoden für Initialisierung und Zerstörung, ähnlich wie die Attribute init-method und destroy-method von Spring XML für das Bean-Element.
public class Foo {
public void init() {
// initialization logic
}
public void cleanup() {
// destruction logic
}
}
@Configuration
public class AppConfig {
@Bean(initMethod = "init", destroyMethod = "cleanup" )
public Foo foo() {
return new Foo();
}
}Bean Scope festlegen
Der Standardbereich ist Singleton. Sie können dies jedoch mit der Annotation @Scope wie folgt überschreiben:
@Configuration
public class AppConfig {
@Bean
@Scope("prototype")
public Foo foo() {
return new Foo();
}
}Sie haben in allen Kapiteln gesehen, dass der Kern des Frühlings das ist ApplicationContext, die den gesamten Lebenszyklus der Bohnen verwaltet. Der ApplicationContext veröffentlicht beim Laden der Beans bestimmte Arten von Ereignissen. Beispielsweise wird ein ContextStartedEvent veröffentlicht, wenn der Kontext gestartet wird, und ContextStoppedEvent wird veröffentlicht, wenn der Kontext gestoppt wird.
Die Ereignisbehandlung im ApplicationContext wird über die ApplicationEvent- Klasse und die ApplicationListener- Schnittstelle bereitgestellt . Wenn eine Bean den ApplicationListener implementiert , wird diese Bean jedes Mal benachrichtigt , wenn ein ApplicationEvent im ApplicationContext veröffentlicht wird.
Der Frühling bietet die folgenden Standardereignisse:
| Sr.Nr. | Spring Built-in Events & Beschreibung |
|---|---|
| 1 | ContextRefreshedEvent Dieses Ereignis wird veröffentlicht, wenn der ApplicationContext entweder initialisiert oder aktualisiert wird. Dies kann auch mit der refresh () -Methode auf der ConfigurableApplicationContext- Schnittstelle ausgelöst werden. |
| 2 | ContextStartedEvent Dieses Ereignis wird veröffentlicht, wenn der ApplicationContext mithilfe der start () -Methode auf der ConfigurableApplicationContext- Schnittstelle gestartet wird. Sie können Ihre Datenbank abfragen oder eine gestoppte Anwendung nach Erhalt dieses Ereignisses neu starten. |
| 3 | ContextStoppedEvent Dieses Ereignis wird veröffentlicht, wenn der ApplicationContext mithilfe der stop () -Methode auf der ConfigurableApplicationContext- Schnittstelle gestoppt wird. Nach Erhalt dieser Veranstaltung können Sie die erforderlichen Reinigungsarbeiten durchführen. |
| 4 | ContextClosedEvent Dieses Ereignis wird veröffentlicht, wenn der ApplicationContext mit der Methode close () auf der ConfigurableApplicationContext- Schnittstelle geschlossen wird. Ein geschlossener Kontext erreicht sein Lebensende; Es kann nicht aktualisiert oder neu gestartet werden. |
| 5 | RequestHandledEvent Dies ist ein webspezifisches Ereignis, das allen Beans mitteilt, dass eine HTTP-Anforderung bearbeitet wurde. |
Die Ereignisbehandlung von Spring ist Single-Threaded. Wenn also ein Ereignis veröffentlicht wird, werden die Prozesse blockiert und der Ablauf wird nicht fortgesetzt, bis alle Empfänger die Nachricht erhalten. Daher sollte beim Entwerfen Ihrer Anwendung vorsichtig vorgegangen werden, wenn die Ereignisbehandlung verwendet werden soll.
Kontextereignisse abhören
Um ein Kontextereignis abzuhören, sollte eine Bean die ApplicationListener- Schnittstelle implementieren, die nur eine Methode hatonApplicationEvent(). Lassen Sie uns also ein Beispiel schreiben, um zu sehen, wie sich die Ereignisse verbreiten und wie Sie Ihren Code für bestimmte Aufgaben basierend auf bestimmten Ereignissen einsetzen können.
Lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:
| Schritt | Beschreibung |
|---|---|
| 1 | Erstellen Sie ein Projekt mit dem Namen SpringExample und erstellen Sie ein Paket com.tutorialspoint unter demsrc Ordner im erstellten Projekt. |
| 2 | Fügen Sie die erforderlichen Spring-Bibliotheken mit der Option Externe JARs hinzufügen hinzu, wie im Kapitel Spring Hello World-Beispiel erläutert . |
| 3 | Erstellen Java - Klassen Hello World , CStartEventHandler , CStopEventHandler und MainApp unter dem com.tutorialspoint Paket. |
| 4 | Erstellen Sie die Beans-Konfigurationsdatei Beans.xml untersrc Mappe. |
| 5 | Der letzte Schritt besteht darin, den Inhalt aller Java-Dateien und der Bean-Konfigurationsdatei zu erstellen und die Anwendung wie unten erläutert auszuführen. |
Hier ist der Inhalt von HelloWorld.java Datei
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}Es folgt der Inhalt der CStartEventHandler.java Datei
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");
}
}Es folgt der Inhalt der CStopEventHandler.java Datei
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");
}
}Es folgt der Inhalt der MainApp.java Datei
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();
}
}Es folgt die Konfigurationsdatei 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>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt:
ContextStartedEvent Received
Your Message : Hello World!
ContextStoppedEvent ReceivedWenn Sie möchten, können Sie Ihre eigenen benutzerdefinierten Ereignisse veröffentlichen und diese später erfassen, um Maßnahmen gegen diese benutzerdefinierten Ereignisse zu ergreifen. Wenn Sie daran interessiert sind, Ihre eigenen benutzerdefinierten Ereignisse zu schreiben, können Sie Benutzerdefinierte Ereignisse im Frühjahr überprüfen .
Es gibt eine Reihe von Schritten, um Ihre eigenen benutzerdefinierten Ereignisse zu schreiben und zu veröffentlichen. Befolgen Sie die Anweisungen in diesem Kapitel, um benutzerdefinierte Frühlingsereignisse zu schreiben, zu veröffentlichen und zu verarbeiten.
| Schritte | Beschreibung |
|---|---|
| 1 | Erstellen Sie ein Projekt mit dem Namen SpringExample und erstellen Sie ein Paket com.tutorialspoint unter demsrcOrdner im erstellten Projekt. Alle Klassen werden unter diesem Paket erstellt. |
| 2 | Fügen Sie die erforderlichen Spring-Bibliotheken mit der Option Externe JARs hinzufügen hinzu, wie im Kapitel Spring Hello World-Beispiel erläutert . |
| 3 | Erstellen Sie eine Ereignisklasse, CustomEvent, indem Sie sie erweiternApplicationEvent. Diese Klasse muss einen Standardkonstruktor definieren, der den Konstruktor von der ApplicationEvent-Klasse erben soll. |
| 4 | Sobald Ihre Ereignisklasse definiert ist, können Sie sie von jeder Klasse aus veröffentlichen, beispielsweise EventClassPublisher, der ApplicationEventPublisherAware implementiert . Sie müssen diese Klasse auch in der XML-Konfigurationsdatei als Bean deklarieren, damit der Container die Bean als Ereignisverleger identifizieren kann, da sie die ApplicationEventPublisherAware-Schnittstelle implementiert. |
| 5 | Ein veröffentlichtes Ereignis kann in einer Klasse behandelt werden, beispielsweise EventClassHandler, der die ApplicationListener- Schnittstelle implementiert und die onApplicationEvent- Methode für das benutzerdefinierte Ereignis implementiert . |
| 6 | Erstellen Sie die Beans-Konfigurationsdatei Beans.xml untersrcOrdner und eine MainApp- Klasse, die als Spring-Anwendung fungiert. |
| 7 | Der letzte Schritt besteht darin, den Inhalt aller Java-Dateien und der Bean-Konfigurationsdatei zu erstellen und die Anwendung wie unten erläutert auszuführen. |
Hier ist der Inhalt von CustomEvent.java Datei
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";
}
}Es folgt der Inhalt der CustomEventPublisher.java Datei
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);
}
}Es folgt der Inhalt der CustomEventHandler.java Datei
package com.tutorialspoint;
import org.springframework.context.ApplicationListener;
public class CustomEventHandler implements ApplicationListener<CustomEvent> {
public void onApplicationEvent(CustomEvent event) {
System.out.println(event.toString());
}
}Es folgt der Inhalt der MainApp.java Datei
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();
}
}Es folgt die Konfigurationsdatei 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>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt:
y Custom Event
y Custom EventEine der Schlüsselkomponenten von Spring Framework ist das Aspect oriented programming (AOP)Rahmen. Bei der aspektorientierten Programmierung wird die Programmlogik in verschiedene Teile zerlegt, die als sogenannte Anliegen bezeichnet werden. Die Funktionen, die mehrere Punkte einer Anwendung umfassen, werden aufgerufencross-cutting concernsDiese Querschnittsthemen sind konzeptionell von der Geschäftslogik der Anwendung getrennt. Es gibt verschiedene Beispiele für Aspekte wie Protokollierung, Prüfung, deklarative Transaktionen, Sicherheit, Caching usw.
Die Schlüsseleinheit der Modularität in OOP ist die Klasse, während in AOP die Einheit der Modularität der Aspekt ist. Mithilfe der Abhängigkeitsinjektion können Sie Ihre Anwendungsobjekte voneinander entkoppeln, und mit AOP können Sie Querschnittsthemen von den betroffenen Objekten entkoppeln. AOP ist wie Trigger in Programmiersprachen wie Perl, .NET, Java und anderen.
Das Spring AOP-Modul bietet Interceptors zum Abfangen einer Anwendung. Wenn beispielsweise eine Methode ausgeführt wird, können Sie vor oder nach der Methodenausführung zusätzliche Funktionen hinzufügen.
AOP-Terminologien
Bevor wir mit AOP arbeiten, sollten wir uns mit den AOP-Konzepten und -Terminologien vertraut machen. Diese Begriffe sind nicht spezifisch für Spring, sondern beziehen sich auf AOP.
| Sr.Nr. | Bedingungen & Beschreibung |
|---|---|
| 1 | Aspect Dies ist ein Modul mit einer Reihe von APIs, die Querschnittsanforderungen erfüllen. Beispielsweise würde ein Protokollierungsmodul als AOP-Aspekt für die Protokollierung bezeichnet. Eine Anwendung kann je nach Anforderung eine beliebige Anzahl von Aspekten haben. |
| 2 | Join point Dies stellt einen Punkt in Ihrer Anwendung dar, an dem Sie den AOP-Aspekt einbinden können. Sie können auch sagen, dass dies der tatsächliche Ort in der Anwendung ist, an dem mithilfe des Spring AOP-Frameworks eine Aktion ausgeführt wird. |
| 3 | Advice Dies ist die eigentliche Aktion, die entweder vor oder nach der Ausführung der Methode ausgeführt werden muss. Dies ist ein tatsächlicher Code, der während der Programmausführung durch das Spring AOP-Framework aufgerufen wird. |
| 4 | Pointcut Dies ist eine Reihe von einem oder mehreren Verbindungspunkten, an denen ein Rat ausgeführt werden soll. Sie können Punktschnitte mithilfe von Ausdrücken oder Mustern angeben, wie wir in unseren AOP-Beispielen sehen werden. |
| 5 | Introduction In einer Einführung können Sie den vorhandenen Klassen neue Methoden oder Attribute hinzufügen. |
| 6 | Target object Das Objekt wird durch einen oder mehrere Aspekte beraten. Dieses Objekt ist immer ein Proxy-Objekt, das auch als empfohlenes Objekt bezeichnet wird. |
| 7 | Weaving Beim Weben werden Aspekte mit anderen Anwendungstypen oder Objekten verknüpft, um ein empfohlenes Objekt zu erstellen. Dies kann zur Kompilierungszeit, Ladezeit oder zur Laufzeit erfolgen. |
Arten von Ratschlägen
Frühlingsaspekte können mit fünf Arten von Ratschlägen funktionieren, die wie folgt erwähnt werden:
| Sr.Nr. | Beratung & Beschreibung |
|---|---|
| 1 | before Führen Sie Ratschläge vor der Ausführung einer Methode aus. |
| 2 | after Führen Sie nach der Ausführung der Methode Ratschläge aus, unabhängig vom Ergebnis. |
| 3 | after-returning Führen Sie Ratschläge nach der Ausführung einer Methode nur aus, wenn die Methode erfolgreich abgeschlossen wurde. |
| 4 | after-throwing Führen Sie Ratschläge nach der Ausführung einer Methode nur aus, wenn die Methode durch Auslösen einer Ausnahme beendet wird. |
| 5 | around Führen Sie Ratschläge aus, bevor und nachdem die empfohlene Methode aufgerufen wurde. |
Implementierung benutzerdefinierter Aspekte
Feder unterstützt die @AspectJ annotation style Ansatz und die schema-basedAnsatz zur Implementierung benutzerdefinierter Aspekte. Diese beiden Ansätze wurden in den folgenden Abschnitten ausführlich erläutert.
| Sr.Nr. | Ansatz & Beschreibung |
|---|---|
| 1 | XML-Schema basiert Aspekte werden mithilfe der regulären Klassen zusammen mit der XML-basierten Konfiguration implementiert. |
| 2 | @AspectJ basiert @AspectJ bezieht sich auf einen Stil zum Deklarieren von Aspekten als reguläre Java-Klassen, die mit Java 5-Annotationen versehen sind. |
Während der Arbeit mit der Datenbank unter Verwendung von einfachem altem JDBC wird es mühsam, unnötigen Code zu schreiben, um Ausnahmen zu behandeln, Datenbankverbindungen zu öffnen und zu schließen usw. Spring JDBC Framework kümmert sich jedoch ab dem Öffnen der Verbindung um alle Details auf niedriger Ebene Führen Sie die SQL-Anweisung aus, verarbeiten Sie Ausnahmen, verarbeiten Sie Transaktionen und schließen Sie schließlich die Verbindung.
Sie müssen also nur die Verbindungsparameter definieren und die auszuführende SQL-Anweisung angeben und die erforderliche Arbeit für jede Iteration ausführen, während Sie Daten aus der Datenbank abrufen.
Spring JDBC bietet verschiedene Ansätze und entsprechend unterschiedliche Klassen für die Schnittstelle mit der Datenbank. Ich werde den klassischen und beliebtesten Ansatz wählen, der verwendet wirdJdbcTemplateKlasse des Frameworks. Dies ist die zentrale Framework-Klasse, die die gesamte Datenbankkommunikation und Ausnahmebehandlung verwaltet.
JdbcTemplate-Klasse
Die JDBC-Vorlagenklasse führt SQL-Abfragen aus, aktualisiert Anweisungen, speichert Prozeduraufrufe, führt eine Iteration über ResultSets durch und extrahiert zurückgegebene Parameterwerte. Außerdem werden JDBC-Ausnahmen abgefangen und in die generische, informativere Ausnahmehierarchie übersetzt, die im Paket org.springframework.dao definiert ist.
Instanzen der JdbcTemplate- Klasse sind nach der Konfiguration threadsicher . Sie können also eine einzelne Instanz einer JdbcTemplate konfigurieren und diese gemeinsam genutzte Referenz dann sicher in mehrere DAOs einfügen.
Bei Verwendung der JDBC-Vorlagenklasse wird häufig eine DataSource in Ihrer Spring-Konfigurationsdatei konfiguriert und diese gemeinsam genutzte DataSource-Bean dann in Ihre DAO-Klassen in Abhängigkeit injiziert. Die JdbcTemplate wird im Setter für die DataSource erstellt.
Datenquelle konfigurieren
Lassen Sie uns eine Datenbanktabelle erstellen Student in unserer Datenbank TEST. Wir gehen davon aus, dass Sie mit der MySQL-Datenbank arbeiten. Wenn Sie mit einer anderen Datenbank arbeiten, können Sie Ihre DDL- und SQL-Abfragen entsprechend ändern.
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
PRIMARY KEY (ID)
);Jetzt müssen wir der JDBC-Vorlage eine DataSource bereitstellen, damit sie sich selbst konfigurieren kann, um Datenbankzugriff zu erhalten. Sie können die DataSource in der XML-Datei mit einem Code konfigurieren, wie im folgenden Codeausschnitt gezeigt:
<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>Datenzugriffsobjekt (DAO)
DAO steht für Data Access Object, das üblicherweise für die Datenbankinteraktion verwendet wird. DAOs bieten eine Möglichkeit zum Lesen und Schreiben von Daten in die Datenbank und sollten diese Funktionalität über eine Schnittstelle verfügbar machen, über die der Rest der Anwendung auf sie zugreifen kann.
Die DAO-Unterstützung im Frühjahr erleichtert die konsistente Arbeit mit Datenzugriffstechnologien wie JDBC, Hibernate, JPA oder JDO.
SQL-Anweisungen ausführen
Lassen Sie uns sehen, wie wir die CRUD-Operation (Erstellen, Lesen, Aktualisieren und Löschen) für Datenbanktabellen mithilfe des SQL- und JDBC-Vorlagenobjekts ausführen können.
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} );Ausführen von DDL-Anweisungen
Du kannst den ... benutzen execute(..)Methode von jdbcTemplate zum Ausführen von SQL-Anweisungen oder DDL-Anweisungen. Im Folgenden finden Sie ein Beispiel für die Verwendung der CREATE-Anweisung zum Erstellen einer Tabelle:
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 );Beispiele für Spring JDBC Framework
Lassen Sie uns anhand der oben genannten Konzepte einige wichtige Beispiele überprüfen, die Ihnen helfen, die Verwendung des JDBC-Frameworks im Frühjahr zu verstehen.
| Sr.Nr. | Beispiel & Beschreibung |
|---|---|
| 1 | Spring JDBC Beispiel In diesem Beispiel wird erläutert, wie Sie eine einfache JDBC-basierte Spring-Anwendung schreiben. |
| 2 | Gespeicherte SQL-Prozedur im Frühjahr Erfahren Sie, wie Sie gespeicherte SQL-Prozeduren aufrufen, während Sie JDBC in Spring verwenden. |
Eine Datenbanktransaktion ist eine Folge von Aktionen, die als einzelne Arbeitseinheit behandelt werden. Diese Aktionen sollten entweder vollständig abgeschlossen sein oder überhaupt keine Wirkung haben. Das Transaktionsmanagement ist ein wichtiger Bestandteil der RDBMS-orientierten Unternehmensanwendung, um die Datenintegrität und -konsistenz sicherzustellen. Das Konzept von Transaktionen kann mit den folgenden vier Schlüsseleigenschaften beschrieben werden:ACID - -
Atomicity - Eine Transaktion sollte als eine einzelne Operationseinheit behandelt werden. Dies bedeutet, dass entweder die gesamte Abfolge von Operationen erfolgreich oder nicht erfolgreich ist.
Consistency - Dies repräsentiert die Konsistenz der referenziellen Integrität der Datenbank, eindeutiger Primärschlüssel in Tabellen usw.
Isolation- Möglicherweise werden viele Transaktionen gleichzeitig mit demselben Datensatz verarbeitet. Jede Transaktion sollte von anderen isoliert werden, um eine Beschädigung der Daten zu verhindern.
Durability - Sobald eine Transaktion abgeschlossen ist, müssen die Ergebnisse dieser Transaktion dauerhaft gemacht werden und können aufgrund eines Systemfehlers nicht aus der Datenbank gelöscht werden.
Ein echtes RDBMS-Datenbanksystem garantiert alle vier Eigenschaften für jede Transaktion. Die vereinfachte Ansicht einer Transaktion, die mit SQL an die Datenbank ausgegeben wurde, lautet wie folgt:
Starten Sie die Transaktion mit dem Befehl begin transaction .
Führen Sie verschiedene Lösch-, Aktualisierungs- oder Einfügevorgänge mithilfe von SQL-Abfragen aus.
Wenn alle die Operation erfolgreich ist dann ausführen begeht sonst Rollback alle Vorgänge.
Das Spring Framework bietet eine abstrakte Ebene über verschiedenen zugrunde liegenden Transaktionsverwaltungs-APIs. Die Transaktionsunterstützung von Spring zielt darauf ab, eine Alternative zu EJB-Transaktionen bereitzustellen, indem POJOs Transaktionsfunktionen hinzugefügt werden. Spring unterstützt sowohl das programmatische als auch das deklarative Transaktionsmanagement. EJBs erfordern einen Anwendungsserver, aber das Spring-Transaktionsmanagement kann implementiert werden, ohne dass ein Anwendungsserver erforderlich ist.
Lokale und globale Transaktionen
Lokale Transaktionen sind spezifisch für eine einzelne Transaktionsressource wie eine JDBC-Verbindung, während globale Transaktionen mehrere Transaktionsressourcen wie Transaktionen in einem verteilten System umfassen können.
Das lokale Transaktionsmanagement kann in einer zentralisierten Computerumgebung nützlich sein, in der sich Anwendungskomponenten und -ressourcen an einem einzigen Standort befinden und das Transaktionsmanagement nur einen lokalen Datenmanager umfasst, der auf einem einzelnen Computer ausgeführt wird. Lokale Transaktionen sind einfacher zu implementieren.
Globales Transaktionsmanagement ist in einer verteilten Computerumgebung erforderlich, in der alle Ressourcen auf mehrere Systeme verteilt sind. In einem solchen Fall muss das Transaktionsmanagement sowohl auf lokaler als auch auf globaler Ebene erfolgen. Eine verteilte oder globale Transaktion wird über mehrere Systeme ausgeführt, und ihre Ausführung erfordert eine Koordination zwischen dem globalen Transaktionsmanagementsystem und allen lokalen Datenmanagern aller beteiligten Systeme.
Programmatisch vs. deklarativ
Spring unterstützt zwei Arten der Transaktionsverwaltung:
Programmatische Transaktionsverwaltung - Dies bedeutet, dass Sie die Transaktion mithilfe der Programmierung verwalten müssen. Das gibt Ihnen extreme Flexibilität, aber es ist schwierig zu warten.
Deklarative Transaktionsverwaltung - Dies bedeutet, dass Sie die Transaktionsverwaltung vom Geschäftscode trennen. Sie verwenden nur Anmerkungen oder XML-basierte Konfiguration, um die Transaktionen zu verwalten.
Das deklarative Transaktionsmanagement ist dem programmatischen Transaktionsmanagement vorzuziehen, obwohl es weniger flexibel ist als das programmatische Transaktionsmanagement, mit dem Sie Transaktionen über Ihren Code steuern können. Als eine Art Querschnittsthema kann das deklarative Transaktionsmanagement mit dem AOP-Ansatz modularisiert werden. Spring unterstützt das deklarative Transaktionsmanagement über das Spring AOP-Framework.
Spring Transaction Abstracts
Der Schlüssel für die Spring-Transaktionsabstraktion wird von der Schnittstelle org.springframework.transaction.PlatformTransactionManager wie folgt definiert:
public interface PlatformTransactionManager {
TransactionStatus getTransaction(TransactionDefinition definition);
throws TransactionException;
void commit(TransactionStatus status) throws TransactionException;
void rollback(TransactionStatus status) throws TransactionException;
}| Sr.Nr. | Methode & Beschreibung |
|---|---|
| 1 | TransactionStatus getTransaction(TransactionDefinition definition) Diese Methode gibt eine aktuell aktive Transaktion zurück oder erstellt eine neue, entsprechend dem angegebenen Weitergabeverhalten. |
| 2 | void commit(TransactionStatus status) Diese Methode schreibt die angegebene Transaktion hinsichtlich ihres Status fest. |
| 3 | void rollback(TransactionStatus status) Diese Methode führt ein Rollback der angegebenen Transaktion durch. |
Die TransactionDefinition ist die Kernschnittstelle der Transaktionsunterstützung in Spring und wird wie folgt definiert:
public interface TransactionDefinition {
int getPropagationBehavior();
int getIsolationLevel();
String getName();
int getTimeout();
boolean isReadOnly();
}| Sr.Nr. | Methode & Beschreibung |
|---|---|
| 1 | int getPropagationBehavior() Diese Methode gibt das Ausbreitungsverhalten zurück. Spring bietet alle von EJB CMT bekannten Optionen zur Transaktionsweitergabe. |
| 2 | int getIsolationLevel() Diese Methode gibt den Grad zurück, in dem diese Transaktion von der Arbeit anderer Transaktionen isoliert ist. |
| 3 | String getName() Diese Methode gibt den Namen dieser Transaktion zurück. |
| 4 | int getTimeout() Diese Methode gibt die Zeit in Sekunden zurück, in der die Transaktion abgeschlossen sein muss. |
| 5 | boolean isReadOnly() Diese Methode gibt zurück, ob die Transaktion schreibgeschützt ist. |
Nachfolgend sind die möglichen Werte für die Isolationsstufe aufgeführt -
| Sr.Nr. | Isolierung & Beschreibung |
|---|---|
| 1 | TransactionDefinition.ISOLATION_DEFAULT Dies ist die Standardisolationsstufe. |
| 2 | TransactionDefinition.ISOLATION_READ_COMMITTED Zeigt an, dass fehlerhafte Lesevorgänge verhindert werden. Nicht wiederholbare Lesevorgänge und Phantomlesevorgänge können auftreten. |
| 3 | TransactionDefinition.ISOLATION_READ_UNCOMMITTED Zeigt an, dass Dirty Reads, nicht wiederholbare Reads und Phantom Reads auftreten können. |
| 4 | TransactionDefinition.ISOLATION_REPEATABLE_READ Zeigt an, dass fehlerhafte und nicht wiederholbare Lesevorgänge verhindert werden. Phantom Reads können auftreten. |
| 5 | TransactionDefinition.ISOLATION_SERIALIZABLE Zeigt an, dass Dirty Reads, nicht wiederholbare Reads und Phantom Reads verhindert werden. |
Nachfolgend sind die möglichen Werte für Ausbreitungstypen aufgeführt:
| Sr.Nr. | Vermehrung & Beschreibung |
|---|---|
| 1 | TransactionDefinition.PROPAGATION_MANDATORY Unterstützt eine aktuelle Transaktion; löst eine Ausnahme aus, wenn keine aktuelle Transaktion vorhanden ist. |
| 2 | TransactionDefinition.PROPAGATION_NESTED Wird innerhalb einer verschachtelten Transaktion ausgeführt, wenn eine aktuelle Transaktion vorhanden ist. |
| 3 | TransactionDefinition.PROPAGATION_NEVER Unterstützt keine aktuelle Transaktion; löst eine Ausnahme aus, wenn eine aktuelle Transaktion vorhanden ist. |
| 4 | TransactionDefinition.PROPAGATION_NOT_SUPPORTED Unterstützt keine aktuelle Transaktion; lieber immer nicht transaktional ausführen. |
| 5 | TransactionDefinition.PROPAGATION_REQUIRED Unterstützt eine aktuelle Transaktion; erstellt eine neue, wenn keine vorhanden ist. |
| 6 | TransactionDefinition.PROPAGATION_REQUIRES_NEW Erstellt eine neue Transaktion und setzt die aktuelle Transaktion aus, falls vorhanden. |
| 7 | TransactionDefinition.PROPAGATION_SUPPORTS Unterstützt eine aktuelle Transaktion; wird nicht transaktional ausgeführt, wenn keine vorhanden ist. |
| 8 | TransactionDefinition.TIMEOUT_DEFAULT Verwendet das Standardzeitlimit des zugrunde liegenden Transaktionssystems oder keines, wenn Zeitlimits nicht unterstützt werden. |
Die TransactionStatus- Schnittstelle bietet eine einfache Möglichkeit für Transaktionscode, die Transaktionsausführung zu steuern und den Transaktionsstatus abzufragen.
public interface TransactionStatus extends SavepointManager {
boolean isNewTransaction();
boolean hasSavepoint();
void setRollbackOnly();
boolean isRollbackOnly();
boolean isCompleted();
}| Sr.Nr. | Methode & Beschreibung |
|---|---|
| 1 | boolean hasSavepoint() Diese Methode gibt zurück, ob diese Transaktion intern einen Sicherungspunkt enthält, dh als verschachtelte Transaktion basierend auf einem Sicherungspunkt erstellt wurde. |
| 2 | boolean isCompleted() Diese Methode gibt zurück, ob diese Transaktion abgeschlossen ist, dh ob sie bereits festgeschrieben oder zurückgesetzt wurde. |
| 3 | boolean isNewTransaction() Diese Methode gibt true zurück, falls die aktuelle Transaktion neu ist. |
| 4 | boolean isRollbackOnly() Diese Methode gibt zurück, ob die Transaktion als Nur-Rollback markiert wurde. |
| 5 | void setRollbackOnly() Diese Methode legt die Transaktion als Nur-Rollback fest. |
Das Spring Web MVC-Framework bietet eine MVC-Architektur (Model-View-Controller) und fertige Komponenten, mit denen flexible und lose gekoppelte Webanwendungen entwickelt werden können. Das MVC-Muster führt dazu, dass die verschiedenen Aspekte der Anwendung (Eingangslogik, Geschäftslogik und UI-Logik) getrennt werden, während eine lose Kopplung zwischen diesen Elementen bereitgestellt wird.
Das Model kapselt die Anwendungsdaten und besteht im Allgemeinen aus POJO.
Das View ist für das Rendern der Modelldaten verantwortlich und generiert im Allgemeinen eine HTML-Ausgabe, die der Browser des Clients interpretieren kann.
Das Controller ist verantwortlich für die Verarbeitung von Benutzeranforderungen und die Erstellung eines geeigneten Modells und übergibt es zum Rendern an die Ansicht.
Das DispatcherServlet
Das MVC-Framework (Spring Web Model-View-Controller) basiert auf einem DispatcherServlet , das alle HTTP-Anforderungen und -Antworten verarbeitet. Der Anforderungsverarbeitungsworkflow des Spring Web MVC DispatcherServlet ist in der folgenden Abbildung dargestellt:
Im Folgenden ist der Ablauf der Ereignisse auf eine eingehende HTTP - Anforderung an entsprechenden DispatcherServlet -
Nach dem Empfang einer HTTP-Anforderung konsultiert DispatcherServlet das HandlerMapping , um den entsprechenden Controller aufzurufen .
Der Controller nimmt die Anforderung entgegen und ruft die entsprechenden Dienstmethoden basierend auf der verwendeten GET- oder POST-Methode auf. Die Servicemethode legt Modelldaten basierend auf der definierten Geschäftslogik fest und gibt den Ansichtsnamen an das DispatcherServlet zurück .
Das DispatcherServlet nimmt Hilfe von ViewResolver in Anspruch, um die definierte Ansicht für die Anforderung abzurufen .
Sobald die Ansicht abgeschlossen ist, übergibt das DispatcherServlet die Modelldaten an die Ansicht, die schließlich im Browser gerendert wird.
Alle oben genannten Komponenten, z. B. HandlerMapping, Controller und ViewResolver, sind Teile von WebApplicationContext w, einer Erweiterung des einfachen ApplicationContext mit einigen zusätzlichen Funktionen, die für Webanwendungen erforderlich sind.
Erforderliche Konfiguration
Sie müssen Anforderungen zuordnen, die das DispatcherServlet verarbeiten soll, indem Sie eine URL-Zuordnung im verwendenweb.xmlDatei. Das folgende Beispiel zeigt die Deklaration und Zuordnung fürHelloWeb DispatcherServlet- Beispiel -
<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>Das web.xmlDie Datei wird im Verzeichnis WebContent / WEB-INF Ihrer Webanwendung gespeichert. Bei der Initialisierung vonHelloWeb DispatcherServlet, das Framework versucht, den Anwendungskontext aus einer Datei mit dem Namen zu laden [servlet-name]-servlet.xmlbefindet sich im WebContent / WEB-INF-Verzeichnis der Anwendung. In diesem Fall wird unsere Datei seinHelloWebservlet.xml.
Als nächstes gibt das Tag <servlet-mapping> an, welche URLs von welchem DispatcherServlet verarbeitet werden. Hier enden alle HTTP-Anfragen mit.jsp wird von der behandelt HelloWeb DispatcherServlet.
Wenn Sie nicht den Standarddateinamen [Servlet-Name] -servlet.xml und den Standardspeicherort WebContent / WEB-INF verwenden möchten , können Sie diesen Dateinamen und Speicherort anpassen, indem Sie den Servlet-Listener ContextLoaderListener in Ihre Datei web.xml einfügen wie folgt -
<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>Lassen Sie uns nun die erforderliche Konfiguration für überprüfen HelloWeb-servlet.xmlDatei, die im WebContent / WEB-INF- Verzeichnis Ihrer Webanwendung abgelegt wird -
<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>Im Folgenden sind die wichtigen Punkte aufgeführt HelloWeb-servlet.xml Datei -
Die Datei [servlet-name] -servlet.xml wird zum Erstellen der definierten Beans verwendet, wobei die Definitionen aller im globalen Bereich mit demselben Namen definierten Beans überschrieben werden.
Das Tag <context: component-scan ...> wird verwendet, um die Spring MVC-Funktion zum Scannen von Annotationen zu aktivieren, mit der Annotationen wie @Controller und @RequestMapping usw. verwendet werden können.
Für den InternalResourceViewResolver sind Regeln zum Auflösen der Ansichtsnamen definiert. Gemäß der oben definierten Regel wird eine logische Ansicht benannthellowird an eine Ansichtsimplementierung delegiert, die sich unter /WEB-INF/jsp/hello.jsp befindet .
Der folgende Abschnitt zeigt Ihnen, wie Sie Ihre tatsächlichen Komponenten erstellen, z. B. Controller, Modell und Ansicht.
Controller definieren
Das DispatcherServlet delegiert die Anforderung an die Controller, um die dafür spezifischen Funktionen auszuführen. Das@ControllerAnnotation gibt an, dass eine bestimmte Klasse die Rolle eines Controllers übernimmt. Das@RequestMapping Annotation wird verwendet, um eine URL entweder einer gesamten Klasse oder einer bestimmten Handlermethode zuzuordnen.
@Controller
@RequestMapping("/hello")
public class HelloController {
@RequestMapping(method = RequestMethod.GET)
public String printHello(ModelMap model) {
model.addAttribute("message", "Hello Spring MVC Framework!");
return "hello";
}
}Das @ControllerAnnotation definiert die Klasse als Spring MVC-Controller. Hier die erste Verwendung von@RequestMapping gibt an, dass alle Handhabungsmethoden auf diesem Controller relativ zu /helloPfad. Nächste Anmerkung@RequestMapping(method = RequestMethod.GET)wird verwendet, um die printHello () -Methode als Standarddienstmethode des Controllers für die Verarbeitung von HTTP-GET-Anforderungen zu deklarieren. Sie können eine andere Methode definieren, um jede POST-Anforderung unter derselben URL zu verarbeiten.
Sie können den obigen Controller in einer anderen Form schreiben, in der Sie zusätzliche Attribute in @RequestMapping wie folgt hinzufügen können :
@Controller
public class HelloController {
@RequestMapping(value = "/hello", method = RequestMethod.GET)
public String printHello(ModelMap model) {
model.addAttribute("message", "Hello Spring MVC Framework!");
return "hello";
}
}Das value Das Attribut gibt die URL an, der die Handlermethode zugeordnet ist, und die methodDas Attribut definiert die Dienstmethode für die Verarbeitung der HTTP-GET-Anforderung. Die folgenden wichtigen Punkte sind bezüglich der oben definierten Steuerung zu beachten -
Sie definieren die erforderliche Geschäftslogik innerhalb einer Servicemethode. Sie können innerhalb dieser Methode je nach Anforderung eine andere Methode aufrufen.
Basierend auf der definierten Geschäftslogik erstellen Sie innerhalb dieser Methode ein Modell. Sie können verschiedene Modellattribute des Setters verwenden. Auf diese Attribute wird von der Ansicht zugegriffen, um das Endergebnis anzuzeigen. In diesem Beispiel wird ein Modell mit dem Attribut "Nachricht" erstellt.
Eine definierte Dienstmethode kann einen String zurückgeben, der den Namen des enthält viewzum Rendern des Modells verwendet werden. In diesem Beispiel wird "Hallo" als logischer Ansichtsname zurückgegeben.
JSP-Ansichten erstellen
Spring MVC unterstützt viele Arten von Ansichten für verschiedene Präsentationstechnologien. Dazu gehören - JSPs, HTML, PDF, Excel-Arbeitsblätter, XML, Velocity-Vorlagen, XSLT-, JSON-, Atom- und RSS-Feeds, JasperReports usw. Am häufigsten verwenden wir jedoch JSP-Vorlagen, die mit JSTL geschrieben wurden.
Lassen Sie uns eine einfache schreiben hello Ansicht in /WEB-INF/hello/hello.jsp -
<html>
<head>
<title>Hello Spring MVC</title>
</head>
<body>
<h2>${message}</h2>
</body>
</html>Hier ${message}ist das Attribut, das wir im Controller eingerichtet haben. Sie können mehrere Attribute in Ihrer Ansicht anzeigen lassen.
Beispiele für Spring Web MVC Framework
Lassen Sie uns anhand der oben genannten Konzepte einige wichtige Beispiele überprüfen, die Ihnen beim Erstellen Ihrer Spring-Webanwendungen helfen.
| Sr.Nr. | Beispiel & Beschreibung |
|---|---|
| 1 | Spring MVC Hello World Beispiel In diesem Beispiel wird erläutert, wie Sie eine einfache Spring Web Hello World-Anwendung schreiben. |
| 2 | Beispiel für die Handhabung von Feder-MVC-Formularen In diesem Beispiel wird erläutert, wie Sie eine Spring-Webanwendung mithilfe von HTML-Formularen schreiben, um die Daten an den Controller zu senden und ein verarbeitetes Ergebnis anzuzeigen. |
| 3 | Beispiel für die Umleitung von Frühlingsseiten Erfahren Sie, wie Sie die Seitenumleitungsfunktion in Spring MVC Framework verwenden. |
| 4 | Beispiel für statische Federseiten Erfahren Sie, wie Sie in Spring MVC Framework zusammen mit dynamischen Seiten auf statische Seiten zugreifen. |
| 5 | Beispiel für die Behandlung von Federausnahmen Erfahren Sie, wie Sie mit Ausnahmen in Spring MVC Framework umgehen. |
Dies ist eine sehr einfach zu verwendende Log4J-Funktionalität in Spring-Anwendungen. Das folgende Beispiel führt Sie durch einfache Schritte, um die einfache Integration zwischen Log4J und Spring zu erläutern.
Wir gehen davon aus, dass Sie bereits haben log4Jauf Ihrem Computer installiert. Wenn Sie es nicht haben, können Sie es von herunterladenhttps://logging.apache.org/und extrahieren Sie einfach die komprimierte Datei in einen beliebigen Ordner. Wir werden nur verwendenlog4j-x.y.z.jar in unserem Projekt.
Lassen Sie uns als Nächstes eine funktionierende Eclipse-IDE einrichten und die folgenden Schritte ausführen, um eine dynamische formularbasierte Webanwendung mit Spring Web Framework zu entwickeln:
| Schritte | Beschreibung |
|---|---|
| 1 | Erstellen Sie ein Projekt mit dem Namen SpringExample und erstellen Sie ein Paket com.tutorialspoint unter demsrc Ordner im erstellten Projekt. |
| 2 | Fügen Sie die erforderlichen Spring-Bibliotheken mit der Option Externe JARs hinzufügen hinzu, wie im Kapitel Spring Hello World-Beispiel erläutert . |
| 3 | Fügen Sie die log4j-Bibliothek log4j-xyzjar ebenfalls in Ihr Projekt ein, indem Sie Externe JARs hinzufügen verwenden . |
| 4 | Erstellen Java - Klassen Hello World und MainApp unter dem com.tutorialspoint Paket. |
| 5 | Erstellen Sie die Beans-Konfigurationsdatei Beans.xml untersrc Mappe. |
| 6 | Erstellen Sie die log4J-Konfigurationsdatei log4j.properties untersrc Mappe. |
| 7 | Der letzte Schritt besteht darin, den Inhalt aller Java-Dateien und der Bean-Konfigurationsdatei zu erstellen und die Anwendung wie unten erläutert auszuführen. |
Hier ist der Inhalt von HelloWorld.java Datei
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage() {
System.out.println("Your Message : " + message);
}
}Es folgt der Inhalt der zweiten Datei 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");
}
}Sie können generieren debug und errorNachricht auf ähnliche Weise, wie wir Info-Nachrichten generiert haben. Lassen Sie uns nun den Inhalt von sehenBeans.xml Datei
<?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>Es folgt der Inhalt von log4j.properties Hiermit werden die Standardregeln definiert, die Log4J zum Erstellen von Protokollnachrichten benötigt
# 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%nWenn Sie mit dem Erstellen der Quell- und Bean-Konfigurationsdateien fertig sind, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung in der Eclipse-Konsole ausgegeben:
Your Message : Hello World!Wenn Sie Ihr Laufwerk C: \\ überprüfen, sollten Sie Ihre Protokolldatei finden log.out mit verschiedenen Protokollnachrichten, wie folgt:
<!-- initialization log messages -->
Going to create HelloWord Obj
Returning cached instance of singleton bean 'helloWorld'
Exiting the programJCL-API (Jakarta Commons Logging)
Alternativ können Sie verwenden Jakarta Commons Logging (JCL)API zum Generieren eines Protokolls in Ihrer Spring-Anwendung. JCL kann von der heruntergeladen werdenhttps://jakarta.apache.org/commons/logging/. Die einzige Datei, die wir technisch aus diesem Paket benötigen, ist die Datei commons-logging-xyzjar , die auf ähnliche Weise in Ihren Klassenpfad eingefügt werden muss, wie Sie im obigen Beispiel log4j-xyzjar eingefügt haben .
Um die Protokollierungsfunktion nutzen zu können, benötigen Sie ein org.apache.commons.logging.Log- Objekt. Anschließend können Sie eine der folgenden Methoden gemäß Ihren Anforderungen aufrufen:
- fatal (Objektnachricht)
- Fehler (Objektmeldung)
- warn (Objektnachricht)
- info (Objektnachricht)
- Debug (Objektnachricht)
- trace (Objektnachricht)
Im Folgenden wird MainApp.java ersetzt, das die JCL-API verwendet
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");
}
}Sie müssen sicherstellen, dass Sie die Datei commons-logging-xyzjar in Ihr Projekt aufgenommen haben, bevor Sie das Programm kompilieren und ausführen.
Wenn Sie nun den Rest der Konfiguration und des Inhalts im obigen Beispiel unverändert lassen und Ihre Anwendung kompilieren und ausführen, erhalten Sie ein ähnliches Ergebnis wie mit der Log4J-API.