1 Basisfedermerkmale
Feder ist ein sehr aktives Open -Source -Framework; Es ist ein Framework, das mehrschichtige Javaee-Systeme basierend auf Kern baut, und der Hauptzweck ist es, die Unternehmensentwicklung zu vereinfachen.
Spring verwaltet Ihren Code auf nicht-invasive Weise. Spring befürwortet "Minimum Intrusion", was bedeutet, dass Sie zum richtigen Zeitpunkt die Feder installieren oder deinstallieren können, und die Frühling macht Java hell. (Offenes und Schließungsprinzip), hier ist das Schlussprinzip.
2. Tools, die zur Entwicklung des Frühlings erforderlich sind
(Hier wählen wir zuerst Spring 2.5 und dann 3.0)
2.1 Frühlings -JAR -Paket
Laden Sie Spring unter http://www.springource.org/download herunter und dekomprimieren Sie sie dann die folgende JAR -Datei im Dekompressionsverzeichnis und kopieren Sie sie in den Klassenpfad
»Die Kernklassenbibliothek des Frühlings ist dist/fing.jar unter Dist im Spring -Dokument
»Die vorgestellte Bibliothek von Drittanbietern ist alle Frühlingsdokument unter lib, lib/jakarta-commons/commons-logging.jar
»Wenn die Aspektprogrammierung (AOP) verwendet wird
»Wenn Sie die Anmerkungen in JSR-250 wie@Resource/@postconstruct/@prädestroy verwenden, ist auch die folgende JAR-Datei LIB/J2EE/Common-Annotations.jar erforderlich
Hinweis: JSR (Java Specification Request) bezieht sich auf eine formelle Anfrage, um JCP (Java Community Process) eine standardisierte technische Spezifikation hinzuzufügen. Jeder kann eine JSR (Java -Spezifikationsanfrage) einreichen, um der Java -Plattform neue APIs und Dienste hinzuzufügen. JSR ist zu einem wichtigen Standard in der Java -Welt geworden
2.2 Federkonfigurationsdatei
Standardmäßig ist es die Datei applicationContext.xml. Es können viele XML -Dateien erstellt werden, die im Allgemeinen in Projekten konfiguriert sind. (Im SRC -Verzeichnis erstellt)
3 Detaillierte Erläuterung der Grundfunktionen des Frühlings
3.1 Springioc
Die Kontrollinversion von Spring: Übergeben Sie die Erstellung, Initialisierung, Zerstörung und andere Objektaufgaben mit dem Federbehälter. Kontrolliert den Lebenszyklus eines Objekts durch den Federbehälter.
Schritt:
•A. Starten Sie den Frühlingsbehälter
1. Finden Sie Konfigurationsdateien im Klassenpfad, um den Container zu instanziieren
Die Codekopie lautet wie folgt: applicationContext ctx = new classSpathXmlApplicationContext (neuer String [] {"ApplicationContext.xml"});
Sie können im gesamten Klassenpfad nach XML -Dateien suchen
* Laden Sie diesen Weg. Sie müssen die Federkonfigurationsdatei unter den Klassenpfad des aktuellen Projekts stellen
* ClassPath Path bezieht sich auf das SRC -Verzeichnis des aktuellen Projekts, bei dem es sich um den Speicherort der Java -Quelldatei handelt.
2. Suchen Sie Konfigurationsdateien im Dateisystempfad, um den Container zu instanziieren
Die Konfigurationsdatei von Spring kann mehrere Konfigurationsdateien angeben und über String -Arrays übergeben werden.
Hinweis: Verwenden Sie die erste Methode, um den Container häufig zu starten
•B. Objekte aus dem Federbehälter extrahieren
Federbehälterstruktur:
3.2 Alias
<beans> <alias name = "person" alias = "p" /// Alias ist ein Alias, Sie können die Person Bean über p erhalten. <bean name = "person"/> </beans>
Mit einer solchen Konfiguration kann der Effekt der Benennung an einem Ort und die Verwendung verschiedener Namen an mehreren Stellen erreicht werden.
3.3 Interne Objekte für Federbehälter
1 Erstellen eines Objekts
1.1 Kein Parameterkonstruktor
<bean id = "helloWorld"> </bean>
1.2 statische Fabrikmethode
<bean id = "helloWorld2"
Werks-Methode = "GetInstance"> </bean>
1.3 Beispiel Factory -Methode
<bean id = "helloWorldfactory"> </bean>
<bean id = "helloWorld3" factory-bean
Erinnern Sie sich nur an das Konzept. Die erste Methode ist die am häufigsten verwendete, aber bei der Integration in andere Tools wird das Instanzfabrikmodell verwendet.
Beispiel :
Konfigurieren Sie applicationContext.xml
<? XSI: Schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-Beans-2.5.xsd"> <! -> <bean id = "helloWorld"> </bean> <! -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Werks-Methode = "GetInstance" > </bean> <! -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Erstellen Sie Entity Class HelloWorld
Paket com.itheima10.spring.createObject; öffentliche Klasse HelloWorld {public void hello () {System.out.println ("Hallo"); }}Stellen Sie eine statische Fabrik auf HelloWorldfactory ein
Paket com.itheima10.spring.createObject.Method; öffentliche Klasse HelloWorldfactory {public static helloWorld getInstance () {System.out.println ("statische Methode"); kehre neue helloWorld () zurück; }}Richten Sie eine physische Fabrik auf HelloWorldfactory2 fest2
paket com.itheima10.spring.createObject.method; public class HelloWorldfactory2 { / *** Das Werksobjekt muss erstellt werden, bevor die Methode* @return* / public helloWorld getInstance () {return New Helloworld () genannt werden kann; }}Schreiben Sie die Testmethode creatObjectMethodest
paket com.itheima10.spring.createObject.method; import org.junit.test; import org.springFramework.context.ApplicationContext import org.springframework CreateObjectMethodTest { / *** standardmäßig ruft der Spring Container den Standardkonstruktor einer Klasse auf, um ein Objekt zu erstellen. HelloWorld helloWorld = (helloWorld) context.getbean ("helloWorld"); helloWorld.hello (); }/*** Erstellen Sie ein Objekt mit einer statischen Fabrik* <bean id = "helloWorld2" factory-method = "getInstance"> </bean> Was der Frühlingscontainer tut: Die GetInstance-Methode wird unter Verwendung der HelloWorldfactory-Klasse*/@Test Public void testcreate genannt. ClassPathXmlApplicationContext ("ApplicationContext.xml"); HelloWorld helloWorld = (helloWorld) context.getbean ("helloWorld2"); helloWorld.hello (); }/** * Instance Factory-Methode erstellt ein Objekt * <bean id = "helloWorldfactory" *> </bean> * <bean id = "helloWorld3" factory-bean HelloWorld -Objekt*/ @test public void testcreateObject_instanceFactory () {applicationContext context = new classPathXmlApplicationContext ("applicationContext.xml"); HelloWorld helloWorld = (helloWorld) context.getbean ("helloWorld3"); helloWorld.hello (); }}2 Umfang des Objekts
Der Umfang eines Objekts hat zwei Eigenschaften: Singleton und Prototyp. Singleton bedeutet Singleton
2.1 Singleton (Standardwert)
In jedem Feder -IOC -Behälter gibt es nur eine Objektinstanz (geteilt).
2.2 Prototyp
Wenn Bohnen mehrmals instanziiert werden können (einmal eine Instanz erstellen, wird einmal verwendet). Der Frühling kann nicht für den gesamten Lebenszyklus einer Prototyp -Bohne verantwortlich sein. Dies bedeutet, dass der Kunde über die prototypen Scoped -Objekte klar ist und die teuren Ressourcen, die von einer Prototyp -Bean gehalten werden, frei machen.
<bean id = "helloWorld" Scope = "Singleton"> </bean>
<bean id = "helloWorld" Scope = "Prototyp"> </bean>
Erstellen Sie die Helloworld -Klasse
public class helloWorld {publiclist <string> lists = new ArrayList <string> (); public helloWorld () {System.out.println ("neue Instanz"); } public void hello () {System.out.println ("Hallo"); }}Erstellen Sie einen Testklassen Scopetest
Paket com.itheiman10.spring.scope; import org.junit.test; import org.springframework.context.applicationContext; Im Frühlingscontainer und diese Klasse ist ein Singleton, dann werden die Eigenschaften in der Klasse freigegeben. HelloWorld hello1 = (helloWorld) context.getbean ("helloWorld"); hello1.lists.add ("aaaa"); hello2 = (helloWorld) context.getbean ("helloWorld"); Hello2.lists.add ("BBBB"); System.out.println (helloWorld.lists.size ()); // 2 und nur eine neue Instanz ausgeben}/** * Wenn die Konfigurationsdatei von Spring wie folgt lautet: * <bean id = "helloWorld" Scope = "Prototyp"> </bean> dann erstellt der Spring Container mehrere Objekte für */@test public void testcreateObject. ClassPathXmlApplicationContext ("ApplicationContext.xml"); HelloWorld hello1 = (helloWorld) context.getbean ("helloWorld"); hello1.lists.add ("aaaa"); hello2 = (helloWorld) context.getbean ("helloWorld"); Hello2.lists.add ("BBBB"); System.out.println (helloWorld.lists.size ()); // 1 und nur neue Instanz ausgeben}}3 Initialisierungszeit
Lazy Loading - Standardmäßig wird die Bean initialisiert, wenn der Container beginnt, aber wir können die faul -init = "true" des Beanknotens angeben, um die Initialisierung der Bean zu verzögern. Zu diesem Zeitpunkt wird die Bohne nur initialisiert, wenn die Bohne zum ersten Mal abgerufen wird. wie:
<bean id = "xxx" Lazy-init = "true"/>
Wenn Sie eine verzögerte Initialisierung auf alle Bohnen anwenden möchten, können Sie in den Root Beans wie folgt Standard-Lazy-Init = "True" festlegen:
<Beans Standard-Lazy-init = "True" ...>
Spring instanziiert alle Singleton -Bohnen im Voraus bei Startup standardmäßig. Eine frühzeitige Instanziierung bedeutet, dass der ApplicationContext im Rahmen der Initialisierung alle Singleton -Bohnen automatisch erstellt und konfiguriert. Das ist normalerweise eine gute Sache. Denn auf diese Weise können Fehler in der Konfiguration sofort entdeckt werden.
Lazy-Init ist falsch, Spring Container meldet einen Fehler, wenn er gestartet wird (ein besserer Weg)
Lazy-Init ist wahr, und der Federcontainer macht beim Aufrufen der Klasse einen Fehler.
Konfigurieren Sie applicationContext.xml
<bean id = "helloWorld" Scope = "Prototyp"> </bean> </beans>
Erstellen Sie die Testklasse createObjectWhentest
Paket com.itheiman10.spring.createObject.when; when; org.junit.test; import org.springFramework.context.applicationContext import org.springframework HelloWorld -Objekt* 3. Objektaufrufmethode** <bean id = "helloWorld"> </bean> <bean id = "helloWorld2"> </bean> Da zwei Bohnen im Feder Container deklariert sind, muss der Federcontainer zwei Objekte erstellen: Wenn die Strümpfe 2, in der FRINDE -Container integriert ist, wird in der Feder -Konfiguration. Wenn die Tiefe berichtet werden, werden die Tiefs. und der Fehler wird besonders früh angezeigt. Wenn eine Bean eine große Datenmenge speichert, ist diese Methode nicht gut und die Daten können zu früh im Speicher stecken. Wenn eine Bean kein Singleton ist, egal wie sie konfiguriert ist, muss das Objekt erstellt werden, wenn es sich um einen Kontext handelt. context.getbean ("helloWorld"); } /*** <bean id = "helloWorld" Lazy-init = "true"> < /bean>* order* 1. starten Sie den Spring Container* 2. CONTEXT.getbean* 3. Die Konstruktorfunktion aufrufen, um ein Objekt zu erstellen* Beschreibung: Wenn Struts2, Hibernate, werden Federcontainer integriert, wenn ein Fehler in der Federkonfiguration verwendet wird. Wenn eine Bean eine große Datenmenge speichert, müssen Daten bei Bedarf geladen werden. context.getbean ("helloWorld"); }}4 Init, zerstöre Methoden
Wenn die Frühling Bohnen initialisiert oder Bohnen zerstört, ist manchmal eine gewisse Verarbeitung erforderlich, sodass der Frühling die beiden Lebenszyklusmethoden der Bohne beim Erstellen und Zerlegen von Bohnen aufrufen kann. Sie können eine Methode zum Betrieb angeben.
<bean id = "foo" class = "... foo" init-method = "setup" dekoration-method = "reaNdown"/>
Rufen Sie die Init-Method-Methode auf, wenn FOO in den Federbehälter geladen wird. Aufrufen von Bereitstellungs-Methoden Wenn Foo aus dem Container gelöscht wird (Scope = Singleton gültig)
HelloWorld schreiben
public class helloWorld {public helloWorld () {System.out.println ("neue Instanz"); } public void init () {System.out.println ("init"); } public void destroy () {system.out.println ("zerstören"); } public void hello () {System.out.println ("Hallo"); }}Schreiben Sie die Testklasse initestroyTest
Paket com.itheima10.spring.ioc.initdestroy; import org.junit.test; import org.springframework.context.applicationContext import org.spingframework Der Federcontainer* 2. HelloWorld -Objekt erstellen* 3. Ausführen der Init -Methode* Automatische Ausführung innerhalb des Federcontainers* 4. Objektaufrufmethode* 5. Die Zerstörungsmethode kann nur ausgeführt werden, wenn der Federbehälter geschlossen ist: Die Bohne ist ein Singleton* Diese Methode wird auch von der Frühlingscontainer bezeichnet. * Im Frühlingscontainer ist nur dann, wenn eine Bohne ein Singleton ist, der Frühlingsbehälter für die Erstellung, Initialisierung und Zerstörung von Objekten verantwortlich* Wenn eine Bean kein Singleton ist, ist der Frühlingscontainer nur für die Erstellung und Initialisierung*/ @Test public void testinitdestroy () {applicationContext context = new ClassPlaPlaPlicationContex ("applicationContext = new ClassPlaPlaPlicationcontex (" applicationContext = new ClassPhodexmlaPlicationContex ("applicationContext = New ClassPhodexmlaPlicationContex (" applicationContext. HelloWorld helloWorld = (helloWorld) context.getbean ("helloWorld"); helloWorld.hello (); ClassPathXmlApplicationContext ApplicationContext = (classPathXMLApplicationContext) Kontext; ApplicationContext.close (); }} Ausführungssequenzdiagramm:
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.