Guten Tag!
Ich habe mir zum Ziel gesetzt, das Spring-Framework für die Java-Sprache zu lernen. Während des Studiums beschloss ich, den Lernalgorithmus von Richard Feynman selbst zu überprüfen: Organisieren, Vereinfachen, Trainieren eines anderen. Im Allgemeinen begann ich im Frühjahr, eine Reihe von Kurzstunden für Anfänger aufzunehmen. Für diejenigen, die wiederholen möchten, habe ich den
Quellcode ausgelegt .
Lektion 01. IoC verstehen
Lassen Sie uns also Dichter zusammenbringen, sie komponieren und uns ihre Gedichte vorlesen.
Deklarieren Sie zunächst die Schnittstelle, die die Verse
src \ main \ java \ spring \ interfaces \ Lyricist.java generiert
:package spring.intarfaces; public interface Lyricist { public String Generate(); }
Wir implementieren diese Schnittstelle in der
Klasse src \ main \ java \ spring \ impls \ Mayakovsky.java :
package spring.impls; import spring.intarfaces.Lyricist; public class Mayakovsky implements Lyricist { @Override public String Generate() { return " \r\n" + " \r\n" + " \r\n" + " ?"; } }
Wir werden schreiben, dass wir ein bestimmtes Mayakovsky-Objekt in der XML-Konfigurationsdatei
src \ main \ resources \ ApplicationContext.xml erstellen werden:
<?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.xsd"> <bean id="LyricistBean1" class="spring.impls.Mayakovsky"/> </beans>
Assoziierte ID LyricistBean1 mit Mayakovsky Klassenname. Fast alles ist fertig, nur die aufrufende Klasse
src \ main \ java \ spring \ main \ Start.java fehlt :
package spring.main; import org.springframework.context.ApplicationContext; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import spring.intarfaces.Lyricist; public class Start { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml"); Lyricist lyr1 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr1.Generate()); ((ConfigurableApplicationContext) context).close();
In der Start-Klasse haben wir unsere Konfigurationsdatei gelesen und eine Instanz des Dichters namens bean LyricistBean1 erstellt. Ich habe eine Kopie des Dichters Mayakovsky bekommen. Die Funktion Generate () hat uns unsterbliche Zeichenfolgen zurückgegeben:
Und Sie
Nocturne spielen
könnten
auf einer Abflussrohrflöte?
Lektion 02. Auswählen einer Instanz, die über die Konfigurationsdatei erstellt werden soll
Nehmen wir an, ein Freund hat uns geholfen und eine weitere Implementierung unserer Lyricist
src \ main \ java \ spring \ impls \ Poushkin.java-Schnittstelle bereitgestellt :
package spring.impls; import spring.intarfaces.Lyricist; public class Poushkin implements Lyricist { @Override public String Generate() { return " :\r\n" + " ,\r\n" + " ,\r\n" + " ."; } }
Ändern Sie in der Konfigurationsdatei ApplicationContext.xml Mayakovsky in Poushkin.
Führen Sie das Programm aus. Wir
erhalten ein völlig anderes Ergebnis,
ohne es neu aufzubauen :
Ich erinnere mich an einen wundervollen Moment
Du bist vor mir erschienen
Wie eine flüchtige Vision
Wie ein Genie von purer Schönheit.
Lektion 03. Beans im Code, nicht in der Konfigurationsdatei
Angenommen, wir möchten
dem Schicksal der Konfigurationsdatei nicht die Wahl der Klasse des Dichters geben.
Ändern Sie die Klasse Poushkin.java
- Import importieren Bibliothek importieren org.springframework.stereotype.Component;
- Fügen Sie die Komponentenanmerkung ("LyricistBean1") vor die Klassendeklaration ein
Also haben wir Spring angedeutet, dass wir Poushkin in Form des ersten Dichters sehen wollen und nicht jemand anderen.
Die Konfigurationsdatei ApplicationContext.xml muss noch leicht repariert werden:
1. Fügen Sie den Namespace-Kontext hinzu: xmlns: context = "
www.springframework.org/schema/context ";
2. Löschen Sie die unnötige Zeile: />
3. Fügen Sie stattdessen einen Befehl hinzu, um dem Programm automatisch Beans aus allen Klassen im Verzeichnis spring.impls hinzuzufügen:
<context: component-scan base-package = "spring.impls" />
Daher sollte die Datei ApplicationContext.xml folgendermaßen aussehen:
<?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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd"> <context:component-scan base-package="spring.impls"/> </beans>
Wir fangen an. Wir erhalten das gleiche Ergebnis wie in der vorherigen Lektion.
Lektion 04. Konfigurationsklasse
Lassen Sie uns die XML-Datei insgesamt loswerden.
Alle Einstellungen können auch in der Java-Klasse sein. Manchmal ist es bequem.
Fügen Sie unserem Programm eine spezielle Konfigurationsklasse
src \ main \ java \ spring \ main \ LyricistConfiguration.java hinzu :
package spring.main; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; @ComponentScan(basePackages = { "spring.impls" }) @Configuration public class LyricistConfiguration { }
@ComponentScan zeigt an, in welchem Verzeichnis nach Beans gesucht werden soll.
@Configuration meldet, dass unsere Klasse eine spezielle Konfiguration ist.
Das war's, die XML-Datei wird nicht mehr benötigt. Es bleibt, diese Nachricht unserer Hauptklasse zu melden:
- Ergänzen Sie es mit dem erforderlichen Import import org.springframework.context.annotation.AnnotationConfigApplicationContext;
- Ersetzen Sie die Kontexterstellungszeile
ApplicationContext context = new AnnotationConfigApplicationContext (LyricistConfiguration.class);
Daher sollte die
Datei main
src \ main \ java \ spring \ main \ Start.java folgendermaßen aussehen:
package spring.main; import org.springframework.context.ApplicationContext; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import spring.intarfaces.Lyricist; public class Start { public static void main(String[] args) { ApplicationContext context = new AnnotationConfigApplicationContext(LyricistConfiguration.class); Lyricist lyr1 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr1.Generate()); ((ConfigurableApplicationContext) context).close();
Alles beginnt und produziert immer noch unsterbliche Puschkin-Linien. Alles arbeitet. Aber schon ohne xml.
Lektion 05. Singleton und Prototyp
Entdecken Sie die Funktionen der Konfigurationsdatei. Kehren wir daher ab der zweiten Lektion zum Projekt zurück. Versuchen wir, zwei Instanzen der Poushkin-Klasse in Start.java zu erstellen und sicherzustellen, dass der große Dichter derselbe ist:
Lyricist lyr1 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr1.Generate()); System.out.println(lyr1.hashCode()); Lyricist lyr2 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr2.Generate()); System.out.println(lyr2.hashCode());
Und die Verse sind die gleichen und der Hash-Code fällt ab. Alles ist in Ordnung.
Fügen Sie unserem Projekt einen einfachen Bürger hinzu, der keine Verse
src \ main \ java \ spring \ impls \ SimpleMan.java schreibt :
package spring.impls; import spring.intarfaces.Lyricist; public class SimpleMan implements Lyricist { @Override public String Generate() { return " , "; } }
Registrieren Sie die Klasse in der Konfigurationsdatei (unmittelbar nach dem ersten Bin).
<bean id="LyricistBean2" class="spring.impls.SimpleMan"/>
Wir versuchen zu schaffen
Lyricist lyr1 = context.getBean("LyricistBean2", Lyricist.class); System.out.println(lyr1.Generate()); System.out.println(lyr1.hashCode()); Lyricist lyr2 = context.getBean("LyricistBean2", Lyricist.class); System.out.println(lyr2.Generate()); System.out.println(lyr2.hashCode());
Der Bürger ist die ganze Zeit derselbe. Das Durcheinander ...
Ändern Sie die Registrierung der Bean in der Konfigurationsdatei, indem Sie das Zauberwort scope = "prototype" hinzufügen.
Infolgedessen sieht die Datei
src \ main \ resources \ ApplicationContext.xml folgendermaßen aus:
<?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.xsd"> <bean id="LyricistBean1" class="spring.impls.Poushkin" scope="singleton"/> <bean id="LyricistBean2" class="spring.impls.SimpleMan" scope="prototype"/> </beans>
Jetzt ist alles in Ordnung. Die Bürger sind jedes Mal anders. Aber Puschkin ist immer allein.
Aufmerksame Leute bemerkten, dass der Einstellungsbereich = "Singleton" im ersten Bin hinzugefügt wurde, aber diese Einstellung wird standardmäßig verwendet, sodass Sie sie nicht schreiben können.
Das ist alles für heute. Wenn dieser Beitrag moderiert wird und ich Zeit und Energie habe, wird es eine Fortsetzung über AOP, JDBC, Transaktionen, MVC und andere Weisheiten geben.
Grüße, Vladimir